JAVA全栈开发 第一阶段汇总-java基础、变量表达式、程序三大结构（顺序、选择、循环）、数组
一、java 基础
1.计算机语言的发展
- 机器语言（二进制）
- 汇编语言 (有一些简单的指令)
- 高级语言 ( c， c++)
- 面向对象语言 (java )
2.java发展
java 是一门面向对象的语言
java之父： 詹姆斯·高斯林（Green小组）
前身Oak语言 --> 95 更名 java
sun 公司 --> oracle公司 (2009)
3.java语言特性
-
简单性
Java由C++衍生而来，其风格语言与C、C++十分类似
Java提供了丰富的类库，可以帮助我们很方便的开发Java程序 -
面向对象
java的核心特点，用程序的方法描述事物的特征和行为
-
跨平台（与平台无关的语言）
java 编写一次，可以在多个平台下进行运行( java 不依赖操作系统 ，而是再编译后生成class 文件， class文件是在jvm (java 虚拟机)中进行运行)，平台指操作系统 （ window , liunx , unix , mac os ）
怎样做到跨平台？只要在计算机上安装虚拟机JVM就可以运行不同的程序 -
健壮性和安全性
删除了指针和释放内存等C++功能，避免非法内存操作。
通过java的安全体系架构来确保java代码的安全性 -
多线程
能同时完成多项任务 -
分布式
4.java技术分类
java技术分类： javaSE, javaEE, javaME
-
Java SE: Java Standard Edition (Java标准版)，Java技术的核心,也是学习JavaEE和JavaME编程的基础，主要用于桌面应用和C/S模式开发。
-
Java EE: Java Enterprise Edition (Java企业版)，在JavaSE基础上进行扩展，提供了分布计算、网络应用（B/S模式）等支持大型企业级应用开发的解决方案，是Java技术应用广泛的部分。
-
JavaME: Java Mirco Edition(Java微型版或Java移动版)，在JavaSE基础上进行精简，以提高运行效率，主要针对小型设备、便携移动设备、嵌入设备开发应用，如手机。不过，目前JavaME在手机上的使用，基本上已经被Android取代了。
98年， 发布java2 对应的技术名： j2se , j2ee ,j2me
2005 年更名操作
j2se -> java se j2ee -> java ee j2me -> java me八卦 ：
javase和j2se目前来说没有区别。java版本可以分为1.1(有名的是1.1.8)，1.2(又称2.0)，1.3，1.4，1.5(又称5.0)，1.6(又称6.0)。从1.2(2.0)开始，分为j2se,j2me 和j2ee。即standard edtion(基础及图形界面)，micro edition(用于手机等嵌入式开发)，enterprise edition(用于WEB开发)。直到java6，仍然沿用j2se， j2me，j2ee。
5.Java 版本
java版本与jdK版本
java SE 的版本，其实就是java 的版本
java 版本与jdk版本对应
jdk版本都是1.0 , 1.1 . … 1.9 之后就是10开始
6.Java安装
使用JAVA语言，只需要安装 JDK即可
要求： JDK 1.8
下载地址：
JDK的目录
bin: 存放JDK 的各种工具命令 ： 包括 javac ， java , javadoc 等
db: 存放数据相关的文件
include : 存放一些平台特定的头文件
lib: 存放JDK工具的一些补充 jar包
JDK， JRE，JVM的介绍
-
JVM（Java Virtual Machine），Java虚拟机
-
JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
-
JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具
总结 ： JDK > JRE > JVM
7.第一个JAVA程序 HelloWorld
编写HelloWorld.java
public class HelloWorld{
public static void main(String[] args){
System.out.println("hello world");
}
}
运行原理
运行的步骤
- win + r ， 输入 cmd
- 找到 HelloWorld.java的文件路径
- javac HelloWorld.java 进行编码， 生成一个字节码文件，后缀名为class
- java HelloWorld 回车 ，执行的是字节码
注： java , javac 命令， 对应的是jdk -> bin目录下的 java.exe , javac.exe 文件
进入命名窗口的方式
-
win + r , 输入cmd
-
在文件夹的上面，输入cmd ，命令窗口显示的是当前文件夹路径
-
按住shift ，再右键 ， 选择powershell
常见的DOS命令
盘符名符： 直接切换盘符， 如： D: 回车， 表示切换到D盘
dir 查看当前路径下的文件（包括文件夹）
cd 目录 进入指定的文件夹
cd 目录1/目录2/.. 进入多级目录
cd .. 返回上一级目录
cd \ 返回到盘符目录
cls 清屏
exit 退出（关闭窗口）
8.环境变量的配置
为什么要配置环境变量
在任何目录下面，都可以使用bin 目录下的相关命令(如： java.exe , javac.exe )
JAVA_HOME, path, CLASS_PATH
JAVA_HOME: 指定 JDK 的安装目录
path: windows 系统根据 Path 环境变量来查找命令
CLASS_PATH: 指定了运行 Java 程序时, 查找 Java 程序文件的路径。在当前文件夹找已编译的文件（.class）文件，如果找不到就去classpath路径下去找。找不到报错，找到了就运行。.;%JAVA_HOME%\lib\dt.jar; %JAVA_HOME%\lib\tools.jar;
-
编译、运行Java程序时，JRE会去该变量指定的路径中搜索所需的类(.class）文件，很多配置教程都让我们设置CLASSPATH环境变量Q为: .;%JAVA_HOME%libldtjar;%JAVA_HOME%l1ibltools.jar，但是其实没有必要。以jdk1.5为例，当我们配置完成后，写个HelloWorld.java。JRE会自动搜索
-
也就是说，在JDK1.5之后，完全可以不配置这个变量。不配置CLASSPATH，JRE会自动搜索当前路径下的类文件。编译、运行时，系统可以自动加载dt.jar和tools.jar文件中的Java类。
-
当然，使用JDK1.5以上的版本也可以在属性配置CLASSPATH环境变量，一旦设置了该变量，JRE就会按照该变量指定的路径搜索Java类(如果CLASSPATH中不包括当前路径.，JRE就不会在当前路径下搜索Java类)。这种方法是一劳永逸的，当我们只是想临时运行某些类，我们就可以将它们临时加到CLASSPATH中(cmd已关闭，就没了)。如下面所示;
配置环境变量的步骤
- 配置 JAVA_HOME, 点击 新建 ； 创建新的环境变量JAVA_HOME ，变量值输入JDK的安装目录 C:\Program Files\Java\jdk1.8.0_131
- 配置path ， 双击或点击编辑； %JAVA_HOME%\bin 进行添加，并将上移最前面
9.进制转换
进制有哪些：
二进制 ： 0 ，1 进行表示
八进制： 0-7 表示 , 以0开头
十进制： 0-9 表示 ， 不能以开头
十六进制： 0-9 A-F 表示， 以0x开头
十进制转其它进制
整数转换
- 十进制转二进制的转换原理：除以2，反向取余数，直到商为0终止。
- 十进制转八进制的转换原理：除以8，反向取余数，直到商为0终止。
- 十转十六原理：同上
小数转换
十进制小数转成2进制小数 原理： 乘2, 正向取整，直到达到想要的精确
其它进制转十进制
整数部分
二进制转十进制 : 从后向前，对应的数字 乘 进制的幂次方(从0依次添加) ， 将它们的进行相加，结果为就是十进制的值
八转十 ： 同上
16转十： 同上
小数部分
0.11111
10.存储单位
在计算机内部，信息都是釆用二进制的形式进行存储、运算、处理和传输的。信息存储单位有位、字节和字等几种。各种存储设备存储容量单位有KB、MB、GB和TB等几种
基本储存单元
-
位（bit）：二进制数中的一个数位，可以是0或者1，是计算机中数据的最小单位。
-
字节（Byte，B）：计算机中数据的基本单位，每8位组成一个字节。各种信息在计算机中存储、处理至少需要一个字节。例如，一个ASCII码用一个字节表示，一个汉字用两个字节表示。
-
字（Word）：两个字节称为一个字。汉字的存储单位都是一个字。
扩展的存储单位
-
在计算机各种存储介质（例如内存、硬盘、光盘等）的存储容量表示中，用户所接触到的存储单位不是位、字节和字，而是KB、MB、GB等，但这不是新的存储单位，而是基于字节换算的。
-
KB：1KB=1024B; 早期用的软盘有360KB和720KB的，不过软盘已经很少使用。
-
MB：1MB=1024KB; 早期微型机的内存有128MB、256MB、512MB，目前内存都是1GB、2GB甚至更大。
-
GB：1GB=1024MB; 早期微型机的硬盘有60GB、80GB，目前都是500GB、1TB甚至更大。
-
TB：1TB=1024GB; 目前个人用的微型机存储容量也都能达到这个级别了，而作为服务器或者专门的计算机，不可缺少这么大的存储容量。
11.idea的安装与破解
【复习补充day01】java 特性
-
简单性
和C语言,C++比，要简单很多，摒弃了繁琐的指针，结构体等操作，不需要自己管理内存 -
面向对象（OO）
面向过程：为了完成某个任务而进行一系列的步骤（以函数来实现） 面向对象：找对象（使用对象的方法） -
跨平台
平台（操作系统(OS) ： window, liunx ,unix , mac os）
一次编译，到处运行
java程序，会编译成字节码文件(class文件)， 由JVM进行，所以说，java程序不依赖操作系统 .(不同操作系统 上安装对应的JVM， Java语言运行在JVM)
-
健壮性和安全性
有自己垃圾回收机制(Java会自己进行垃圾回收)
-
多线性
同一时间片断，有多任务再进行执行
1.标识符
什么是标识符： 计算机语言的一种符号（名称），代表着某种含义
用户定义的标识符(用户取的名字):
语法规则：
１．由字母， 数字，＿，＄组成
２．不能以数字开头
３．不能使用关键字
４．没有长度限制
行业规则：
1, 不能使用中文和￥
2, 源文件的名字首字母大写, 变量名，方法名首字母小写， 常量名全大写
3, 使用驼峰命名法 后面的单词首字母大写
4, 见名知意 (增强代码的可读性)
注： java 区分大小写（大小写敏感）
2.三种编程的命令规则
匈牙利命名法、驼峰命名法、帕斯卡命名法、（下划线命名法）
匈牙利命名法：会有简写的前缀
小驼峰命名法： 第一个单词首字母小写，其它单词首字母大写
帕斯卡命名法（大驼峰命名法）： 每个单词的首字母都大写
下划线命名法：用下划线分隔每个单词； 如：String student_name =“”
3.关键字（系统定义的标识符）
关键字： 被系统指定具有特殊意义的标识符
1699086098265)
4.注释
注释是什么？ 对写的代码进行描述(用我们熟悉的语言)
目的： 增强代码可读性
注释不会被编译和运行
注释分三类： 单行注释 ， 多行注释， 文档注释
单行注释： //
多行注释： /* 开头 */
文档注释： /** 开头 */
文档注释，可以用javadoc 生成对应的文档(html 文件)
https://blog.csdn.net/weixin_44434720/article/details/127804953
5.设置程序的作者
在idea中配置作者以及相关注释: file->setting->File and code Templates
/**
*@Author：doubleyong
*@Package：{PROJECT_NAME}
*@name：{DATE} {NAME}
*/
二、变量和表达式
1.变量的定义
变量： 变量是一个容器，操作系统给内存划分的一块空间;
作用：存储数据（临时）
2.变量的申明
-
第一种
数据类型 变量名; //开辟了一块空间
变量名 = 值； //把值 放到对应的变量空间里
注 ： = 是赋值符号， 把等号右边的值，赋给左边
-
第二种
数据类型 变量 = 值；
多个声明，用逗号隔开
数据类型 变量名 = 值 , 变量名2;
3.变量的使用
直接写变量名
注： 没有赋值的变量不能直接使用
报错：java: 可能尚未初始化变量height
4.数据类型
决定数据的类型与内存空间的大小
两大类： 基本类型（值存在栈中） 和 引用类型（值存在堆中）
变量的空间（栈中）
基本类型：8种
数字 ：
整数 ： byte ( 1个字节) , -128 到 127， 负2的7次方 到 正2的7次方 -1
short（2个字节）， 负2的15次方 到 正2的15次方 -1
int（4个字节） , 负2的31次方 到 正2的31次方 -1
long（8个字节） , 负2的63次方 到 正2的63次方 -1
小数 : float (单精度/浮点 ) 4字节 ， 小数点后面不超过8位
double (双精度) 8个字节， 小数点后面不超过16位
字符：
char : 每个字符占两个字节
布尔(只有两种情况)：
boolean 逻辑判断 true :真 false ：假
引用类型
**String(字符串)**
类
数组
接口 .....
不同类型的变量声明
//整数
byte num = 1;
short num2 =1;
int num3 = 1;
long num4 = 1L; //一般加大写的L , 说明是long类型
//浮点数
float num5 = 0.5f; //一般加小写的f, 说明float
double num6 = 0.5; //可以加小写的d， 也可以省略
// 字符 ，只能写一位，且需要用单引号包起来
char char1 = '男';
boolean result = false;
// 引用类型 String 字符串，它的值要用双引号包起来
String name = "Hello";
5.常量
在java中固定不变量就要常量
符号常量
有名称的常量，称为符号常量
常量定义
在变量的基础上加上final修饰符 (用final所修饰的变量就是常量)
final double PI = 3.14;
常量不可修改,
final 数据类型 常量名(全大写) = 值;
final 数据类型 常量名(全大写) ;
常量名 = 值;
注： 只允许赋值一次
final : 最终的
6.数据类型的转换
自动转换（隐式转换）
容量小 转 容量大
条件： 数据要兼容
// 自动转换 （小 转 大）
//byte -> int
byte num = 5;
int num2 =num;
//short -> int
short num3 = 3;
int num4 = num3;
// char -> int
char a = 'a';
// 字符 -> ascii -> 十进制 -> 2进制
// '0' => 48
// 'A' => 65
// 'a' => 97
int num5 = a;
System.out.println(num5);
// int -> double
int num6 = 6;
double dnum = num6;
System.out.println(dnum);
// int -> float
int num7 = 6;
float fnum = num6;
System.out.println(dnum);
强制转换（显示转换）
容量大 转 容量小
条件： 数据要兼容
语法： 数据类型 变量名 = (数据类型) 值;
// double -> int 将舍去小数部分
double d1 = 100.111;
int i1 = (int)d1;
System.out.println(i1);
// int -> char , 大转小 ，要强转
int A = 65;
char char1 = (char)A;
System.out.println(char1);
// int -> byte , 大转小， 可能会出现精度丢失
// 注： 将值超过byte的大小时，它会循环赋值( 128 转byte 结果为 -128)
// -128 - 127
int num = 133;
byte b = (byte)num;
System.out.println(b);
7.运算符
算术运算符
赋值运算符
一元运算符
逻辑运算符
位运算符
关系（比较）运算符
三元运算符
算术运算符
+, - , * , / , % ( 取模）
//+ : 当运算符两边，有一方是字符串，表示是字符串连接，
//否则进行相加运算(如果不是数字类型，则隐式进行转换)
// -, * , / ,% : 这几个符号都只能进行 运算， 不支持字符串类型
System.out.println( 9 %3);
System.out.println( 9/3);
System.out.println(9/6); // 结果 1 只有整数参与，小数部分舍去
System.out.println( 9/6.0); //结果 1.5 有小数
赋值运算符
赋值运算符包含： = ， += , -= , *= , /= , %=
int num = 6;
num += 5; //num = num+ 5
num -= 5; // num = num -5;
num *= 5; // num = num * 5;
num /= 5; //num = num / 5;
num %= 5; // num = num % 5;
System.out.println(num);
一元运算符
一元运算符： 运算符所需要的操作数的个数为1个;
二元运算符：运算符所需要的操作数的个数为2个;
三元运算符：运算符所需要的操作数的个数为3个;
一元运算符： ++ ，——
++ ： 表示 自增＋1 ；
-- ： 表示 自减－1 ；
当只有一条语句时，不管++加前,还是++再后都没有影响
当只有一条语句时，不管--加前,还是--再后都没有影响
在复合语言时，＋＋再前，表示时，使用＋１后的值 ， ＋＋再后，表示使用＋１之前的值
在复合语言时，－－再前，表示时，使用－１后的值 ，－－再后，表示使用－１之前的值
关系（比较）运算符
关系运算符有： > ,< , >= ,<= , ==, !=
结果为： boolean类型
逻辑运算符
逻辑运算符有：
并且 && 短路与， 有一个条件为false ，后面的条件将不再进行判断
或者 || 短路或， 有一个条件为true，后面的条件将不再进行判断
非！ 取反
位运算符：
&: 所有的条件都会进行判断
｜：所有条件都会进行判断
＾：异或
一般程序主要用逻辑运算符
位运算符
&: 所有的条件都会进行判断
｜：所有条件都会进行判断
＾：异或
~ : 取反
<<（左移） 乘２ （知道）
>> (右移) 除２ （知道）
三元运算符
语法： （条件表达式）？真的处理：假的处理；
9.面试题
＆ 与 ＆＆ 有什么区别
10.写博客
csdn , 开发者社区, 掘金 ， 简书， github
回顾：
- 变量
三要素 ： 数据类型 变量名 ＝ 值；
变量名 （标识符）
用户定义的 一些规范
系统被占用（关键字，保留字，常量）
-
数据类型
基本类型（值存在栈） byte, short , int ,long float , double, char , boolean引用类型（值存在堆）
String , 数组， 类， 接口．．．
-
类型的转换
自动转 （小转大，类型兼容）
强转 （数据类型）
-
运算符
运算符的优先级
-
&&: 逻辑与 || 逻辑或
-
&： 按位与 | ： 按位或
-
&&与＆
１．输出的结果是一样的
２．逻辑运算符有短路效果
注： 项目中一般实现的是逻辑运算符
三、程序三大结构
三大结构 分别是：
顺序结构：从上到下执行
选择结构：首先进行判断，只有符合一定的条件，程序才会被执行
循环结构：循环结构就是不断重复执行某些程序
1.选择结构
2.流程图
椭圆： 开始，结束
菱形： 判断
矩形： 执行语言
平行四边形： 输入，输出
3.if选择结构
3.1单分支
if(条件表达式)｛
//条件为真的处理
｝
3.2双分支
if(5>3){
// 这里是条件为真的处理
System.out.println("这是真的");
}else{
//条件为假
System.out.println("这是假的");
}
3.3多分支（else if）
多重if（else if ）
if(条件表达式){
//为真
}else if(条件表达式){
//为真
}
else if(条件表达式){
//为真
}
else if(条件表达式){
//为真
}else{
}
注： 多重if 与 多个if的区别
多重if 有一个条件为空后，其它的条件不再进行判断
多个if ，每个条件都会进行判断
int score = 90;
if(score>=90 &&score<=100){
System.out.println("A");
}
else if(score>=80 &&score<90){
System.out.println("B");
}
else if(score>=70 &&score<80){
System.out.println("C");
}
else if(score>=60 &&score<70){
System.out.println("D");
}
else {
System.out.println("E");
}
3.4嵌套if
// if 中可以嵌套if, 且可以是无限嵌套
// 嵌套的越多，阅读性会越差，最好不要超2级，最最好只用一级
3.5 if 使用场景
条件只有一个的，用单分支
条件有二个分支的，用双分支
条件有三个分支的，用多分支
条件不同时用嵌套;
3.6特殊情况的if用法
当if 代码块，和else 代码只有一行语句时, 可以省略花括号； 但是不鼓励这些写
如果变量是boolean, 可以直接写变量名
boolean result = false;
if(result){
System.out.println("结果为真");
}else{
System.out.println("结果为假");
}
4.switch选择结构
switch 选择结构 ，通常用于等值判断
语句格式
switch(算数表达式){
case 常量表达式1 :
语句块1
break;
case 常量表达式2 :
语句块2
break;
case 常量表达式3 :
语句块3
break;
default:
语句块;
}
switch 的注意事项
1. switch 的表达式类型
int(byte short int char ) String(java 7 开始) 枚举（enum）
注： 不支持long
2. case 中值
case 的值不能重复
case 的值要和switch 表达式中的类型匹配或兼容
3. break
表示结束当前的switch
可以省略
4. case 穿透问题
如果case 条件已经满足，之后判断判断就不在进行，会从上向下进行执行，直到遇到break为止
5. default (缺省/ 默认)
当所有的case 都不满足时，执行default中的语句块，可以省略，也可以放在最前面,建议放在最后
选择结构的使用场景
switch 主要用于等值判断
if 主要用于范围
5.变量作用域
变量有块级作用域，即{} 就表示一个块; 同一个花括号里的变量，是可以使用, 子块也可以使用
四、循环结构
- 为什么需要用循环?
(提高代码简洁度，可读性，可维护性)
- 什么时候使用循环？
大量，重复， 有规则
1.循环的特点
2.循环条件
条件初始值
条件的范围
条件的改变
3.循环操作
// 需求 ： 写10000遍，好好学习，天天向上
4.while
语法：
while(条件表达式){
// 循环体
}
特点： 先判断，再执行
5.do-while
需求： 考试不及格的同学，一直考试，直到及格为止
语法：
do{
//循环体
}while(条件件表达式);
特点：先执行，再判断 , 至少执行一次
流程图：
案例：
猜数字游戏
int num = 60;
Scanner sc = new Scanner(System.in);
int cai;
do{
System.out.println("请输入一个数字");
cai = sc.nextInt();
if(cai>num){
System.out.println("大了");
}else if(cai<num){
System.out.println("小了");
}
}while (cai!=num);
System.out.println("恭喜您，猜对了");
Scanner sc = new Scanner(System.in);
double score;
do{
System.out.println("请输入考试成绩");
score = sc.nextDouble();
}while (score<60);
System.out.println("恭喜您，及格了，你成绩为:"+score);
6.for
特点： 先判断，后执行
while(条件表达式){
// 循环体
}
语法：
for(表达式1; 表达2 ; 表达式3){
//循环体
}
表达1 ： 条件初始化
表达2： 条件的范围
表达3： 条件的改变
注： for循环中的表达式是可以省略的
表达式可以多个，用逗号隔开
for(int i=0,j=10; i<5 && j>5 ; i++,j--){
System.out.println("hello world");
}
// int i=0, j=10
// i<5 && j>5 成立 //System.out.println("hello world");
// i = 1 , j=9
// i<5 && j>5 成立 //System.out.println("hello world");
// i= 2, j =8
//i<5 && j>5 成立 //System.out.println("hello world");
// i =3 ,j=7
//i<5 && j>5 成立 //System.out.println("hello world");
// i = 4, j=6
//i<5 && j>5 成立 //System.out.println("hello world");
// i = 5 , j=5
// i<5 && j>5 不成立
//结束循环
7.无限循环（死循环）
//for的方式
for(;;){
System.out.println("hello world");
}
//while的方式
while(true){
}
8.break 与 continue
break :
- 作用范围：switch选择结构 和 循环结构 ( 包括： while , do-while , for ),
- 作用：用于跳出循环，用到此关键字，结束当前对应的循环（或者当前switch选择）；
continue :
- 作用范围：只能用于循环结构( 包括： while , do-while , for ),
- 作用： 结束本次循环，进行下一次循环
continue的示例：
// int sum = 0;
// for(int i=1; i<100; i++){
// if(i%2 == 0){
// sum+=i;
// }
// }
// int sum = 0;
// for(int i=1; i<100; i++){
// if(i%2!=0){
// continue;
// }
// sum+=i;
// }
int sum = 0;
for(int i=0; i<=100; i+=2){
sum+=i;
}
System.out.println(sum);
9.三个的区别(使用场景)
do-while ： 先执行，后判断 (次数不固定)
while: 先判断，后执行（次数不固定）
for: 先判断，后执行 (次数固定)
做题步骤
- 分析循环的条件和循环的操作
- 套进循环的语法结构
- 检查循环是否能够跳出（避免死循环）
五、双重循环
1.双重循环的定义
在一个循环中，嵌套另一个循环；叫做双重循环（循环的嵌套）
2.双重for循环的格式
外层和内层循环，都是任意循环
原理：外层循环一次，内层循环遍历一轮
遍历：从条件开始，到循环结束，整个循环，称为遍历
for(初始条件1;条件判断1;条件改变1){
// 循环语句1
for(初始条件2;条件判断2;条件改变2){
// 循环语句2
}
}
1.初始条件1；
2.条件判断1；
3.执行循环语句1；
4.初始条件2；
5.条件判断2；
6.执行循环语句2；
7.条件改变2；
8.重复执行5，6，7。直到条件判断2的结果为false；
9.执行条件改变1.
10.从2开始进行循环直到条件判断1为false
- 案例1：打印矩形:
打印矩形:(先循环行，再循环列)
********************
********************
********************
********************
System.out.println("行数");
Scanner sc = new Scanner(System.in);
int rows = sc.nextInt();
System.out.println("列 数");
int cols = sc.nextInt();
for (int i = 1;i<=rows;i++){
//行的内容
for (int j = 1; j <cols;j++){
System.out.print("*");
}
System.out.println("");
- 案例2：九九乘法表
\t:tab水平制表，相当于4个空格
//九九乘法表
for (int i = 1;i <= 9 ;i++ ){
//输出行的内容
for (int j = 1; j <= i ; j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println("");
}
案例3：打印星星
*
***
*****
*******
*****
*****
*****
*****
*
***
*****
*******
*****
***
*
- System.out.println与System.out.print的区别
System.out.println： 输出换行
System.out.print： 输出不换行
3.双重循环中使用break
正常情况break，跳出的是离他最近的循环
public static void main(String[] args){
for(int i = 0; i<3; i++){
System.out.println("i:"+i); // i:0 i:1 i:2
if(i==2){
break;
}
for(int j= 0 ;j<3; j++){
System.out.println("j"+j); // 0 1 2 0 1 2
}
}
}
break 标签：
flag1:
for(int i=0; i<3 ; i++){
System.out.println(i);
flag2:
for(int j = 0 ;j<3; j++){
if(j==2){
break flag1;
}
}
}
4.双重循环中使用continue
正常情况continue，结束这一次离他最近的循环
continue 标签
public static void main(String[] args){
flag:for(int i = 0; i<3; i++){
System.out.println("i:"+i); // 0 1 2
flag2:for(int j= 0 ;j<3; j++){
if(j==1){
continue flag;
}
System.out.println("j"+j); // 0 0 0
}
}
}
5.多重循环
多个循环的嵌套
注意：一般不超过三个循环（性能过低），如果超过时，就要进行代码优化。
六、数组
1.数组概念
案例需求
在需要统计我们班学生成绩的情况，例如计算平均成绩、找到最高成绩等。
假设该我们班有50名学生，用前面所学的知识，程序首先需要声明50个变量来分别记住每位学生的成绩，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。
// 先要有50个学生的成绩
int score1 = 88;
int score2 = 66;
...
// 有没有一种变量，可以存多个值
score1 = 77;
// 数组
-
数组概念
数组是一种容器，可以同时存放多个（同类型的数据）数据， 数据按照一定的顺序进行排列
在内存开辟一块连续的地址空间 -
数组特点：
1.数组的长度是固定
2.数组存储的数据类型必须相同
3.数组可以存储任意数据类型( 基本类型，引用类型都可以)
2.数组的术语
数组名
下标，从0开始
数据元素：数组中存储的值
3.定义数组
第一种：(推荐)
数据类型[] 数组名;
第二种:
数据类型 数组名[];
4.数组的赋值
静态初始化
数据类型[] 数组名 = {数据元素, 数据元素, 数据元素 … }；
数组的长度，由系统根据数据元素的个数来创建，且按照顺序进行存储
动态初始化
数据类型[] 变量名 = new 数据类型[ 长度 ];
// 动态初始化的长度，由用户指定 ； 数据有默认值
int[] scores = new int[3];
// 左边
int 数组存储的数据类型
[] 代表它是一个数组
scores 数组名
//右边
new 创建一个数组 分配内存
int 数据元素的类型为int
[] 说明是一个数组
3 说明数据的长度是3
注： new数组时， 会有默认值
整形基本数据类型 byte short int long默认值都为0
浮点型基本数据类型 float double 默认值为0.0
字符基本数据类型 char 默认值是 ‘ ’ 空格 unicode码为 \u0000
boolean 基本数据类型默认值为false
引用类型的默认值 ，都为null
[扩展]: unicode 编码
错误：
- java.lang.ArrayIndexOutOfBoundsException 数组下标越界
记录：
请你把自己遇到的所有关于 Exception结尾的错误，总结下来，并记录
ArrayIndexOutOfBoundsException : 数组下标超界
NullPointerException： 空指针错误
原因： 数组
5. 数组的内存图
- 二个对象
- 三个对象
6.For Each （增强for）
遍历每一个元素
for(数组中元素的数据类型 变量名 : 数组名){
// 变量名，指是数组中的具体元素
}
int[] arr = {1,2,3}
for(int i :arr[]){
System.out.println(to.String(arr))
}
7.数组的案例
7.1 数组的遍历
// 数组的遍历
// 把数组的每个元素取出来
int[] scores = {22,333,444,555,6666,5,6,67,78,89,90,90,67,78,89,90,90};
// 数组名.length属性，作用是获取数组的长度
// System.out.println(scores.length);
for(int i=0; i<scores.length;i++){
System.out.println(scores[i]);
}
// System.out.println(scores[0]);
// System.out.println(scores[1]);
// System.out.println(scores[2]);
// System.out.println(scores[3]);
// System.out.println(scores[4]);
7.2 求数组中的最大值
public static void main(String[] args){
int[] scores = {11,2,3,34,45,56,67,888};
int max= scores[0] ; //用一个变量来存最大值
// 将数组的第2个，到数组 最后，依次与max 进行比较，把大数，放到max
for(int i=1; i< scores.length;i++){
if(max< scores[i]){
max = scores[i];
}
}
System.out.println("最大值为"+max);
}
7.3 求平均数
注意： 数据类型
public static void main(String[] args){
double[] scores = {11,22}; //33 /2 = 16.5
// 求平均数
// 总数/ 个数 = 平均数
//1. 求和
double sum = 0;
for(double item:scores){
sum+=item;
}
//2.求平均
double avg = sum/scores.length;
System.out.println(avg);
}
7.4 产生随机数
Random r = new Random();
r.nextInt(数字) ; // 产生的是 0 - （数字-1）
10 -20 r.nextInt(11) + 10 ;
public static void main(String[] args){
Random r = new Random();
for (int i=0;i<10;i++){
System.out.println(r.nextInt(11) + 10); // 10- 20 // (0-10) +10
}
}
7.5 猜数字
public static void main(String[] args){
/*
* 思路：
* 1. 产生一个数字（随机数）
* 2. 用户猜 (放到循环里去猜，判断也在循环里 - while )
* 3. 提示： 大了，小了，正确了
* 4. 如果没有正确，
* 继续猜
* */
// 1-100
Random r = new Random();
int num = r.nextInt(100)+1; // 1 -100
Scanner sc = new Scanner(System.in);
int cai ;
while (true){
System.out.println("请输入你猜的数字");
cai = sc.nextInt();
if(cai>num){
System.out.println("大了");
}else if(cai<num){
System.out.println("小了");
}else{
System.out.println("恭喜您，猜对了");
break;
}
}
}
7.6 数组逆序
public static void main(String[] args){
// 将数据倒序 , 输入出
// 98，78，566，34，12
int[] scores = {12,34,566,78,89};
System.out.println("原数组");
for(int item:scores){
System.out.print(item+" ");
}
// 数组倒序
// 两个变量的交互，需要定义一个新的变量
// 思路： 第1位和最后一位，进行交换， 第2位和倒数第2位
// 1 2 3 4 5 5/2 = 2
// 5 2 3 4 1
// 5 4 3 2 1
int temp; //临时变量
for(int i = 0; i<scores.length/2;i++)
{
// i scores.length- 1 - i
temp = scores[i];
scores[i] = scores[scores.length-1-i];
scores[scores.length-1-i] = temp;
}
System.out.println("");
System.out.println("倒序操作后的数组");
for(int item:scores){
System.out.print(item+" ");
}
}
8. 数组的排序（了解）
两个变量进行交换 （ 需要定义一个新的变量）
升序： 从小到大
降序：从大到小
冒泡排序
原理： 两个相邻的元素进行比较
选择排序
原理: 选出最大值或者最小值； 依次和数组中后面每一个元素进行比较，根据条件交换
9.数组的扩容
思路：
- 创建一个新的数组，长度再旧数组的长度+1
- 将旧数组的值，放到新数组中
- 将新的值，放到新数组的最后一位
public class Demo10 {
//扩容
/*
* 1. 创建一个新数组 , 长度是旧数组的长度+1
* 2. 把旧数组的数据，依次放到新数组
* 3. 将新的元素放到新数组的最后一位
* */
public static void main(String[] args){
int[] scores = {23,34,6};
// 加数组添加一个元素 888
// 1. 创建一个新数组 , 长度是旧数组的长度+1
int[] newArr = new int[scores.length+1];
// 2. 把旧数组的数据，依次放到新数组
for(int i=0;i<scores.length;i++){
newArr[i] = scores[i];
}
//3. 将新的元素放到新数组的最后一位
newArr[newArr.length-1] = 888;
// 3.1 将新数组 赋值给 旧数组
scores = newArr;
//4 打印添加后的数组
for(int item:scores){
System.out.print(item+" ");
}
}
}
10.数组的缩容
删除数组中最后一个
public class Demo12 {
public static void main(String[] args){
int[] scores = {11,22,33,44,55,66};
// 删除33这元素
//1. 创建一个新数组
int[] newArr = new int[scores.length-1];
int delNum = 33;
//2. 查找要删除这个元素所在的下标
int index = -1;
for(int i=0;i<scores.length;i++){
if(scores[i]==delNum){
index = i;
break;
}
}
if(index==-1){
System.out.println("此元素不在数组中");
return;
}
// 给index之前的元素进行赋值
for(int i=0;i< index;i++){
newArr[i] = scores[i];
}
// 给index之后的元素进行赋值
for(int i=index+1;i< scores.length;i++){
newArr[i-1] = scores[i];
}
// 把新数组的地址值赋值给旧数组
scores = newArr;
// 打印综容后的数组
for(int item:scores){
System.out.print(item+" ");
}
}
}
11.数组的方法
Arrays 专门对数组进行相应的操作
Arrays.toString(arr) : 遍历
Arrays.sort(arr): 数组的排序， 默认升序， 会改变数组中元素的位置
Arrays.copy()
System.arraycopy
Arrays.copy 与 System.arraycopy的区别
12.二维数组（了解）
-
定义：
数组里的数据元素，又一个一维数组 , 这就是二维数组
-
申明二维数组
int[][] 数组名;
int 数组名[][];
int[] 数组名[];
- 二维的初始化
int[][] nums = new int[5][2]; // 第一个中括号，相当于外层一维数组长度， 第二中括号表示内层一维数据的长度
int[][] nums = new int[5][]; //内层的一维数据长度可以不写
int[][] nums = {{1,2,3},{4,5,6}}; //静态实始化，长度是由系统是计算的 ; 推荐这种简化的形式
int[][] nums = new int[][]{{1,2,3},{4,5,6}};
- 二维数据的访问:
二维数组名[外层一维所在的下标][内层一维数据的下标];
- 二维数据的内存图
- 二维数据的扩容和缩容
根据二维数组的定义和一维数组扩容、缩容的方法完成
java内存分配
一维数组一个对象的内存图
一维数组二个对象的内存图
一维数组三个对象的内存图
二维数组的内存图
二维数组扩容和缩容
- Java中的内存分配
. Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈存储局部变量( 变量 )
堆存储new出来的东西( 引用类型 )
方法区(后面讲)
本地方法区(和系统相关)
寄存器(给CPu使用)
栈内存的数据用完就立即释放
- 堆内存的特点：
-
每一个new 出来的对象 ， 都地址值
-
每个变量都有默认值
byte, short , int ,long 默认值 0
float, double 默认0.0
char ‘\u0000’
boolean false
引用类型 null
-
使用完毕后就会变成垃级， 但并不会立即进行回收，等垃级回收器空闲了，才进行回收
API
API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。
API使用步骤
1.打开帮助文档。
- 点击显示，找到索引，看到输入框。
- 你要找谁？在输入框里输入，然后回车。(如果输入类名称只有一个直接打开，如果多个则需要选择)
- 看包。java.lang下的类不需要导包，其他需要。
- 看类的解释和说明。
- 学习构造方法。
- 使用成员方法。
注：java.util.* java中工具类
java.lang.* 该包下的所有的java类 在使用时不需要导入包
equals 与 ==
”==" 既可以作用在基本数据类型中，也可以作用在引用数据类型中
**equals()**只能作用在引用数据类型(两个对象)，无法作用在基本数据类型
"== 作用在基本数据类型时比较的的是值是否相同，作用在引用数据类型时比较的是两个对象的地址值是否一致（是否指向相同对象)
equals()方法在不重写的情况下调用的是"=="也就是比较两个对象的地址值是否一致，但是equals()是可以重写的，如果重写后具体对比的含义根据重写规则而定
字符串与整型的转换
对应包装类.parseXX(字符串) ;
实现一个ATM 机
步骤：
-
使用数组存储用户的信息( 管理员，用户)
-
显示欢迎界面，并提供登录操作
-
输入用户名和密码，进行登录 ， 判断 否是管理员
-
如果是管理员
a: 管理员登录 ， 显示管理员的欢迎界面，及菜单选择
-
开卡 2 注销卡 3. 查看所有用户列表 4 冻结账号 5. 返回登录界面 6 退出系统
开卡
提示输入卡号 判断是这个卡号是否已经存在 不存在，进行提示输入密码 把这个新对象，加入到用户数组 (扩容 )注销卡：
提示输入卡号 这个卡号是否已经存在 卡号存在，记录它的下标位置 删除这个对象(缩容)查看所有用户列表
遍历数组，且进行输出冻结账号
提示输入卡号 这个卡号是否已经存在 卡号存在，记录它的下标位置 将对应下标位置的状态，改为冻结
-
-
否则认为是用户登录
判断用户数组中，是数据 是否与输入相等 相等，登录成功 显示菜单界面，欢迎xxxx , 1. 查看余额 2. 存钱 3. 取钱 4. 转账 5．退出 不相等，登录失败
import javax.jws.soap.SOAPBinding;
import java.util.Arrays;
import java.util.Scanner;
public class ATM {
public static void main(String[] args) {
boolean isExist, login = false,isFreeze;
String[] adminuser = {"1", "1"};
String[] user1 = {"a", "a", "1000", "正常"};
String[] user2 = {"b", "b", "2000", "冻结"};
String[] user3 = {"user3", "1", "3000", "正常"};
String[] user4 = {"user4", "1", "4000", "正常"};
String[][] userArr = {user1, user2, user3, user4};
Scanner sc = new Scanner(System.in);
while (true) {
//1.输入账号
System.out.println("请输入卡号");
String inputUser = sc.next();
System.out.println("请输入密码");
String inputPwd = sc.next();
//2.管理员登录
String newUser, newPwd;
if (inputUser.equals(adminuser[0]) && inputPwd.equals(adminuser[1])) {
//管理员登录成功
login = true;
boolean falg = true;
System.out.println("欢迎尊贵的ATM管理员！");
while (falg) {
System.out.println("请选择：1.开户 2.注销 3.查看 4.冻结 5.返回登录 6.退出 \t");
//功能选择
int choose = sc.nextInt();
switch (choose) {
default:
System.out.println( "无此选项！");
break;
//开卡
case 1:
//1.提示输入账号
System.out.println("输入您开卡号：");
while (true) {
isExist = false;
newUser = sc.next();
//2.判断卡号是否存在
for (String[] user : userArr) {
if (newUser.equals(user[0])) {
System.out.println("卡号已存在！请重新输入");
isExist = true;
break;
}
}
if (!isExist) {
break;
}
}
System.out.println("请输入密码：");
newPwd = sc.next();
//3.组一个用户
String[] u = {newUser, newPwd, "0", "正常"};
//3.1创建一个新数组
String[][] newArr = new String[userArr.length + 1][];
//3.2拷贝之前的数组
for (int i = 0; i < userArr.length; i++) {
newArr[i] = userArr[i];
}
newArr[newArr.length - 1] = u;
userArr = newArr;
System.out.println("开户成功");
break;
//注销卡
case 2:
System.out.println("请输入卡号：");
newUser = sc.next();
isExist = false;
for (String[] user : userArr) {
if (newUser.equals(user[0])) {//遍历判断是否存在该卡号
isExist = true;
int countUser = 0;
String[][] newArr1 = new String[userArr.length - 1][];
for (String[] needUser : userArr) {
if (!needUser[0].equals(newUser)) {//如果原数组卡号和输入卡号不相同，则是不需要注销的卡号，则放入新数组
newArr1[countUser] = needUser;
countUser++;
}
}
userArr = newArr1;
System.out.println("注销成功！");
break;
}
}
if (!isExist) {
System.out.println("卡号不存在！");
}
break;
//查看
case 3:
for (String[] i : userArr) {
for (String j : i) {
System.out.print(j + "\t");
}
System.out.println("");
}
break;
//冻结
case 4:
System.out.println("请输入卡号：");
newUser = sc.next();
int x1 = -1;
isExist = false;
//查找要改变这个元素所在的下标
for (String[] user : userArr) {
x1++;
if (newUser.equals(user[0])) {
isExist = true;
break;
}
}
if (!isExist) {
System.out.println("卡号不存在");
} else {
userArr[x1][3] = "冻结";
System.out.println("冻结成功");
}
break;
case 5:
falg = false;
break;
case 6:
System.out.println("正在退出登录！");
return;
}
}
} else {
//去用户数组查找
int y = -1;//循环次数
boolean falg =true;
isFreeze=false;
for (String[] itmp : userArr) {
y++;
if (inputUser.equals(itmp[0]) && inputPwd.equals(itmp[1])) {
if (userArr[y][3].equals("冻结")){
isFreeze=true;
System.out.println("账户已被冻结！");
break ;
}else {
//登录成功System.out.println("欢迎登录！");
while (falg) {
System.out.println("请选择业务：1.余额 2.存钱 3.取钱 4.转账 5.返回登录 6.退出\t");
int choose = sc.nextInt();
int money = Integer.parseInt(userArr[y][2]);
switch (choose) {
//1.查看余额
case 1:
System.out.println("您的余额有：" + money + "元");
continue;
//2.存钱
case 2:
System.out.println("存多少钱：");
int m1 = sc.nextInt();
String m2 = String.valueOf(m1 + money);
userArr[y][2] = m2;
System.out.println("您的余额有：" + m2 + "元");
break;
//3.取钱
case 3:
System.out.println("取多少钱：");
int m3 = sc.nextInt();
if (m3 > money) {
System.out.println("余额不足！");
System.out.println("您的余额为" + money + "元");
} else {
String m4 = String.valueOf(money - m3);
userArr[y][2] = m4;
System.out.println("您的余额有：" + m4 + "元");
}
break;
//4.转账
case 4:
while (true){
int y1 = 0;
System.out.println("请输入对方账户：");
String zuser = sc.next();
if (itmp[0].equals(zuser)){
System.out.println("不能给自己转账！");
continue;
}
isExist = false;
for (String[] itmp1 : userArr) {
y1++;
if (zuser.equals(itmp1[0])) {
isExist = true;
System.out.println("转多少钱：");
int m5 = sc.nextInt();
if (m5 > money) {
System.out.println("余额不足！请重新输入：");
} else {
String m6 = String.valueOf(money - m5);
userArr[y][2] = m6;
}
System.out.println("确定账户是否输入正确：" + zuser);
System.out.println("确认转账按1；取消按2");
int qr = sc.nextInt();
if (qr == 1) {
int money1 = Integer.parseInt(userArr[y1][2]);
String m7 = String.valueOf(m5 + money1);
userArr[y1][2] = m7;
System.out.println("转账成功！");
} else {
System.out.println("取消成功！");
}
}
}
if (!isExist) {
System.out.println("账户不存在！");
}
break;
}
break;
//5.退出
case 5:
falg = false;
break;
case 6:
return;
}
}
}
}
}
if (isFreeze){
continue;
}
if (!login){
System.out.println("账号或者密码错误！");
}else {
System.out.println("感谢使用！");
}
}
}
}
}