1、java基础
1. JDK和Eclipse
1.1 什么是JDK？
JDK：（Java Development Kit）Java开发库，JDK中包含：
1.一组开发工具：在JDK安装目录\bin，其中包含：例如编译工具(javac.exe)、运行工具(java.exe)、打包工具(jar.exe)等
2.基础类库：JDK安装目录\jre\lib\rt.jar，其中包含JDK自带的一些现成的Java类，可以直接使用
3.基础类库的源码：JDK安装目录\src.zip
什么是JDK
JDK(Java Development Kit): Java开发库，其实就是一个软件，JDK中包含：
- 一组开发工具：在JDK的安装目录下\bin目录下,其中包含:编译工具(javac.exe), 运行工具(java.exe), 打包工具(jar.exe)等
- 基础核心类库: 在JDK安装目录下\jre\lib\rt.jar, 其中包含了JDK自带的一些类, 我们可以直接使用!
- 基础类库的源代码: JDK安装目录下\src.zip
总之，要想开发、运行java程序，就必须要安装JDK软件。
1.2 Eclipse工作空间
**工作空间（workspace）：**是第一次打开Eclipse后所让选择的一个目录，该目录将来可以存放我们所创建的项目（包括文件及目录）。
需要注意的是，工作空间的目录所在的路径中最好不要包含中文和空格。更不能放在桌面。
1、启动程序后，出现如下界面:
关于工作空间的位置，可以直接修改位置，例如推荐如下写法：
D:/JavaDev/CGBCode2103_Training
D:/JavaDev/CGBCode2103_Basic
D:/JavaDev/CGBCode2103_Web
D:/JavaDevp/CGBCode2103_FW
D:/JavaDev/CGBCode2103_JT
3、关于切换工作空间
Eclipse切换工作空间可以选择菜单栏中选择 “File” => “switch workspace” => “Other…”，即可进入第一次启动Eclipse选择工作空间的界面。
另外，每个工作空间的环境配置不通用，可以根据自己的偏好进行设置。切换工作空间后之前的配置都需要重新来做（例如之前设置了字体大小或快捷键等都需要重新配置）
1.3 Eclipse常用快捷键
Java注释
Java中支持三种注释，这里介绍两种：
注释不会参与程序的执行,主要用于解释说明
单行注释：//注释内容 (快捷键：Ctrl+/)
取消单行注释： (快捷键：Ctrl+/)
多行注释: /* 注释内容 */ (先选中要注释的内容，再敲快捷键：Ctrl+Shift+/)
取消多行注释： (先选中注释符号的首尾,Ctrl+Shift+\)
对齐代码：Ctrl+a+i, 可以让代码对齐
代码格式化：选中所有代码（Ctrl+a）,再鼠标右键-->Source-->Format，也可以使用： Ctrl+Shift+f快捷键实现。
1、Eclipse编辑相关快捷键
01）【Ctrl+N】:新建(比如新建项目、新建类、新建文件等)
02）【Ctrl+1】:快速修复代码，给出修复方式(非常常用！)
03）【Ctrl+D】:删除光标所在的行
04）【Ctrl+Alt+↑】：复制当前行内容到上一行
【Ctrl+Alt+↓】: 复制当前行内容到下一行
提示：如果出现屏幕/桌面翻转（例如按 Ctrl+Alt+↓ 出现桌面翻转，再按 Ctrl+Alt+↑ 即可恢复），
将桌面恢复后，在桌面上右键点击 “图形选项” --> “快捷键” --> “禁用” 即可
05）【Alt+↑】：当前行和上面一行交换位置（特别实用，可以省去剪切再粘贴的麻烦了）
【Alt+↓】: 当前行和下面一行交换位置
06）【Alt+/】:内容辅助，对于记不全的类名、方法名或属性名，只需要写出一部分，通过Alt+/可以提示或补全剩余部分。
07）【Ctrl+/】:对光标所在的行进行注释(单行注释)
08）【Ctrl+shift+/】:将选中的文本进行注释(多行注释)
09）【Ctrl+Shift+F】:对选中的内容进行格式化
10）【Ctrl+A+I】:对当前文档进行格式化(缩进对齐)
11）【Ctrl+shift+O】:通过import引入类所在的包(见扩展内容)
12）【Ctrl+M】:将当前窗口最大化或还原
13）【Alt+Shift+R】: 重命名 (尤其是变量和类的Rename，比手工修改能节省很多麻烦
14）【Alt+Shift+L】:抽取本地变量(可以直接把一些多次出现的数字或字符串抽取成一个变量，尤其是多处调用的时候，还可以将方法的返回值抽取为本地变量。)
15）【Alt+shift+M】: 抽取方法 (这是重构里面最常用的方法之一了，可以将选中的代码抽取为一个单独的方法)
16）【Ctrl+Shift+X】：把当前选中的文本全部变味小写
【Ctrl+Shift+Y】：把当前选中的文本全部变为小写
17）【Ctrl+Shift+P】：定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)
2、常用编辑器快捷键
01）【Ctrl+C】:将选中的文本复制
02）【Ctrl+V】:将复制的文本粘贴到当前位置
03）【Ctrl+A】:将当前区域内的文本全部选中
04）【Ctrl+X】:将选中的文本剪切(剪切=复制+删除)
05）【Ctrl+S】:将当前文件保存
06）【Ctrl+Z】:撤销当前操作
07）【Ctrl+Y】:重复上一次操作
08）【Ctrl+F】:查找
以上快捷键在其他常用的文本编辑工具中同样适用（例如:Notepad++，Editplus，EverEdit…等）
3、查找搜索快捷键
【Ctrl+F】：查找搜索
【Ctrl+Shift+T】：打开类型，它可以打开当前eclipse的工作区中所有(打开的)工程中所有java文件，包括jar包中的类和接口，不用再为找不到类而痛苦。
【Ctrl+Shift+H】：在结构层次中打开类型
4、运行调试快捷键
Eclipse 中有如下一些和运行调试相关的快捷键。
【F11】：Debug运行最后一次执行的程序。
【Ctrl+F11】：运行最后一次执行的程序。
【Ctrl+Shift+B】：在当前行设置断点或取消设置的断点。
【F5】：跟踪到方法中，当程序执行到某方法时，可以按【F5】键跟踪到方法中。
【F6】：单步执行程序。
【F7】：执行完方法，返回到调用此方法的后一条语句。
【F8】：继续执行，到下一个断点或程序结束。
5、其他快捷键
main,Alt+/ ：可以生成main函数
sysou,Alt+/ ：可以生成打印语句
syst,Alt+/ ：也可以生成打印语句
1.4 Java程序编译及运行
编译期: 在eclipse中保存xxx.java文件后,经过编译,生成字节码文件(xxx.class)
运行期: 运行Java程序, JVM会加载.class文件, 并运行.class文件
结果: 在eclipse控制台输出 "HelloWorld"
2、基础语法:关键字+数据类型
2.1 标识符、关键字
2.1.1 标识符 identifier
标识符：可以简单的理解为一个名字。
public static void main(String[] args) {
int a=100;
int $233=88;
//int 233=88; 不能一数字开头
//int %abc=99;//不能包含%，#，&..等特殊符号
int A=233;//java语言是严格区分大小写的
//标识符在命是最好能做到见名知意
//声明一个变量保存成绩
double score=88;
//声明一个变量保存学生的名字
String name="张三";
//标识符不能和关键字或保留字相同
//int short=200;// 不能使用关键字
int _short=200;//包含关键字
}
在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。我们选择的名称就称为标识符，标识符不能完全随便定义，需要遵循以下规则：
1）标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含@、%、空格等其它特殊字符；
2）Java语言的标识符必须以字母、下画线（_）、美元符（$）开头，但不能以数字开头；
3）标识符是严格区分大小写的；
4）标识符的命名最好能反映出其作用，做到见名知意;
5）标识符不能是Java关键字和保留字，但可以包含关键字和保留字;
注意：此处的字母并不局限于26个英文字母，是可以包含中文字符、日文字符等（但不建议
2.1.2 关键字 keywords
Java语言中有一些具有特殊用途的单词被称为关键字（keyword），当定义标识符时，不要让标识符和关键字相同，否则将引起错误。例如，下面代码将无法通过编译。Java中一共包含 50+ 关键字和两个保留字，如下图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yzeRSCmh-1625196914689)(.\图片\image147.png)]
Java中所有的关键字都是小写的，例如：像TRUE、FALSE、NULL都不是Java关键字。
另外，“java”虽没有强调其是关键字，也不建议使用。
标识符不能是关键字
1) 用于定义数据类型的关键字
class interface byte short int long float double char boolean void
2) 用于定义数据类型值的关键字
true false null
3) 用于定义流程控制的关键字
if else switch case default while do for break continue return
4) 用于定义访问权限修饰符的关键字
private protected public
5) 用于定义类,函数,变量修饰符的关键字
abstract final static synchronized
6) 用于定义类与类之间关系的关键字
extends implements
7) 用于创建对象及引用对象和判断对象的关键字
new this super instanceof
8) 用于处理异常的关键字
try catch finally throw throws
9) 用于包的关键字
package import
10) 其他修饰符关键字
native strictfp translent volatile assert
2.2 变量 variables
2.2.1 变量的定义
什么是变量（Variable）：变量就是代指在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。
什么是变量: 变量就是代指在内存中开辟的一片存储空间。用于存放程序中的一些数据
内存 变量(内存中的一小块空间) 数据(存到变量中的数据)
冰箱 冰箱中的收纳盒 水果
如何定义变量: 变量类型 变量名 = 变量值;
例如: int score = 90;
int age = 20
double account = 3000.0;
2.2.2 变量的声明
1、变量声明
当需要使用一个变量时，必须对该变量进行声明
变量的声明包含两点：变量名和变量类型。
2、未经声明的变量不能使用
3、一条语句中声明多个同类型变量
如果多个变量的类型一样，可以在一条语句中声明，中间用逗号分隔。例如：
public static void main(String[] args) {
int a=1, b=2;
// 声明了两个整型变量，分别赋值为1和2。
int c, d=3;
// 声明了两个整型变量，d赋初值为3，c没有赋初值。
}
2.2.3 变量的命名
1、命名需要符合标识符语法要求
变量的命名必须符合Java标识符的规则：
1）可以由字母、数字、“_”和”$”符组成，但不能以数字开头；
2）命名变量时需要注意，Java是区分大小写，例如：int a, A; //a和A是两个名称
3）不能使用Java关键字和保留字，如：int、if、for、break等；
4）中文可以作为变量名，但不建议这样用
2、变量命名需见名知意，并且符合Java规范
1）Java 变量名的定义应符合“见名知意”；
2）同时，Java编程规范要求：变量的命名需采用“驼峰命名法”，即如果变量的名字由多个单词组成，除第一个单词外，其他单词的首字母大写，其余的字母小写，
例如：salary、studentName、studentParentName等。
2.2.4 变量的初始化
未经初始化的变量不能使用(及时)
Java语言规定, 变量在使用之前必须初始化, 即,变量在使用之前必须要赋值
形式一: 在声明的同时, 直接给变量赋值
变量类型 变量名称 = 变量值(初始值)
int personNum = 20;
double price = 99.0;
形式二: 在声明变量时不赋值, 后面使用时再赋值
int score;
score = 88;
score = score+10;
System.out.println(score);
2.2.5 变量的访问
1、可以对变量中的值进行存取、操作
变量是存放数据的空间，可以对其赋值、更改等操作；
要把对变量的操作理解为是对其所存储的数据的操作。
例如：
public static void main(String[] args) {
int a = 100;
a = a + 200; // 该条语句的含义为：将变量a中的值加上200所得结果再存入变量a
}
2、变量的操作必须与类型匹配
变量在声明时指定了类型，Java编译器会检测对该变量的操作是否与其类型匹配，如果对变量的赋值或者操作与其类型不匹配，会产生编译错误。
以上所诉实例：
//变量的声明---------------------
//变量的声明方式：变量类型 变量名=变量的值
int a = 3;//声明变量的同时给变量赋值
int b = 4;
int c = a + b;
//变量的声名方式2：变量类型 变量名
int age;//先声明变量
age=88;//再给变量赋值
//System.out.println(aga);//未经声明的变量无法使用
int b;
//System.out.println(b);//没有初始化的变量无法使用
//变量的命名------------
//变量需要有个见名知意的名字，而且要符合标识符的语法规范；
int a_$123;//可以由字符、$、数字、下划线组成，但不能包括特殊符号
//变量名要符合驼峰命名法（单词首字母要大写）
String stdudeName;//第二个单词开始首字母大写，也可以用中文，但不建议
//变量的访问--------
int a = 100;
System.out.println(a);
a = a + 200;
System.out.println(a);
//变量的操作必须与类型匹配------
double price2=66.6;
double price3=price2/2;
//int price3=price2/2;//double 可以使用，int不可以
2.3 基本数据类型
Java语言是强类型语言，对于每一种数据都定义了明确具体的数据类型，并且在内存中分配了不同大小的内存空间。
Java中数据类型分为两大类，一种是基本数据类型，另一种是**引用数据类型。**下面我们先来了解基本数据类型。
2.3.1 8种基本数据类型介绍
Java语言有8种基本数据类型，分别用于存储整数、浮点数、字符数据和布尔类型数据。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-no7nVMgH-1625196914717)(.\图片\image149.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EceCpXa1-1625196914720)(.\图片\image151.jpg)]
char类型（字符类型，不是字符串）
字符类型事实上是一个16位无符号整数，这个值是对应字符的编码,
Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位
字符直接量可以采用诸如：'中' 的形式，也可以采用16进制的表示形式，例如：'\u4e2d'
char c1 = 'A'; //c1中存的是 "A" 字符的编码，即65
char c2 = 'B'; //c2中存的是 "B" 字符的编码，即66
char c3 = 'a'; //c3中存的是 "a" 字符的编码，即97
char c4 = 'b'; //c4中存的是 "b" 字符的编码，即98
char c5 = '中'; //c5中存的是 "中" 字符的编码，即20013
char c6 = '\u4e2d';//c5中存的是 "中" 字符的编码，即20013
boolean类型（布尔类型）
1）boolean类型适用于逻辑运算，表示某个条件是否成立，一般用于程序的流程控制。(后面会讲解流程控制)
2）boolean类型只允许取值true或false，true表示条件成立，而false表示条件不成立。
3）boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小、相等等关系。
例如：
int age = 18;
boolean isChild = age<16; // isChild的值为false
System.out.println(isChild); // 输出false
2.3.2 练习:获取并输出最值
声明变量分别保存六种数值类型的最大值和最小值，并输出到控制台
package com.tedu;
//基本案例：输出6种数值的最大值和最小值
public class BasicTypeDemo {
public static void main(String[] args) {
// 1.获取byte类型的最大值和最小值
//Byte为byte的包装类型
System.out.println(Byte.MAX_VALUE);//127
System.out.println(Byte.MIN_VALUE);//-128
// 2.获取short类型的最大值和最小值
//Short为short的包装类型
System.out.println(Short.MAX_VALUE);//32767
System.out.println(Short.MIN_VALUE);//-32768
// 3.获取int类型的最大值和最小值
//Integer为int的包装类型
System.out.println(Integer.MAX_VALUE);//21.47亿
System.out.println(Integer.MIN_VALUE);//-21.47亿
// 4.获取long类型的最大值和最小值
//Long为long的包装类型
System.out.println(Long.MAX_VALUE);//922.33京
System.out.println(Long.MIN_VALUE);//-922.33京
// 5.获取float类型的最大值和最小值
//Float为float的包装类型
System.out.println(Float.MAX_VALUE);//最大值3.4028235E38
System.out.println(Float.MIN_VALUE);//最小正值1.4E-45
//最小值应该是-3.4028235E38
// 6.获取double类型的最大值和最小值
//Double为double的包装类型
System.out.println(Double.MAX_VALUE);//最大值
System.out.println(Double.MIN_VALUE);//最小正值
//最小值应该是最大值前加“-”号
}}
2.3.3 练习:计算圆的面积
提示：S(圆的面积)； C(圆的周长)
package com.tedu;
//求圆的面积和周长
public class BasicTypeDemo2 {
public static void main(String[] args) {
//定义变量保存圆的半径
double r=50;
//定义变量保存圆的圆周率
double p=3.14;
//输出圆的面积
System.out.println(p*r*r);
//输出圆的周长
System.out.println(2*p*r);
}}
2.3.4 练习:变量交换
在程序中，声明变量a值为3，声明变量b值为4，要求交换变量a、b的值
package com.tedu;
public class VarExchange {
public static void main(String[] args) {
int a=3;
int b=4;
//交换变量a,b的值
int c=a;
a=b;
b=c;
System.out.println(a+","+b);
}}
2.3.5 基本类型的直接量规则(5条)
所谓的直接量也叫做字面量，是指在Java中直接写出来的叫做直接量。例如：
int a = 100;
double b = 3.14;
上面写出来的100和3.14分别是整数直接量和浮点数直接量。
规则1：整数直接量默认是int类型
在Java中直接写出来的整数，默认的int类型。
int a = 100; //正确，直接给出的整数值是int类型
int b = 22 0000 0000; //编译错误，因为右边是int类型的值，但值超出了int范围。
long c1 = 22 0000 0000; //编译错误，因为右边是int类型的值，超出了int范围。
long c2 = 22 0000 0000L; //正确，右边的数值是long类型直接量
提示：如果要表示long类型直接量，需要以 L 或 l 结尾
规则2：在不超范围的前提下，可以使用整数直接量为byte、short、char类型赋值，系统会自动按对应的类型处理
例如：
byte a1 = 127; //正确, 系统会自动把127当成byte类型处理
byte a2 = 128; //编译错误，因为右侧的整数超出了byte类型的范围。
short b1 = 32000; //正确, 系统会自动把32000当成short类型处理
short b2 = 33000; //编译错误，因为右侧的整数超出了short类型的范围。
char c1 = 97; //正确, 系统会自动把97当成char类型处理
char c2 = 65535; //正确, 系统会自动把65535当成char类型处理
char c3 = 65536; //编译错误，因为右侧的整数超出了char类型的范围。
char f='中';
System.out.println(f-0);//f=20013
char g=65535;//没有超过char范围，可以将int字面量复制给char类型
//char g=65536;//错误，超过了char范围0~65535
规则3：浮点型直接量默认的double类型
例如:
double a = 3.14; //正确, 3.14为浮点型直接量, 默认是double类型
float b1 = 3.14; //错误, 3.14为double类型(占8字节), 左边是float类型无法赋值给float
float b2 = 3.14F; //正确, 3.14F为float类型直接量
规则4：三种直接量后缀（L、F、D）
大写L或小写l – 表示long类型
大写F或小写f – 表示float类型
大小D或者小写d – 表示double类型
long a1 = 22 0000 0000; //编译错误，因为右边是int类型，超出了int范围。
long a2 = 22 0000 0000L; //正确，右边的数值是long类型
float b1 = 3.14; //错误, 3.14为double类型(占8字节), 无法赋值给float
float b2 = 3.14F; //正确, 3.14F为float类型直接量
double c1 = 100; //正确, 因为int-->double, 是从小到大可以直接转换
double c2 = 100.0 //正确
double c3 = 100D; //正确
规则5：三种直接量前缀（0b、0、0x或\u）
0b – 二进制数值前缀
0 – 八进制数值前缀
0x – 十六进制数值前缀
System.out.println(0b110);//二进制数据，6
System.out.println(0110);//八进制数据，72
System.out.println(0x110);//十六进制数据，272
2.3.6 基本类型间的类型转换
1、基本类型间转换介绍
不同的基本类型直接可以相互转换：
1）自动类型转换（隐式类型转换）：从小类型到大类型可以自动完成转换。类型的大小关系如下图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tCt8zWjE-1625196914723)(.\图片\image155.png)]
2） 强制转换：从大类型到小类型需要强制转换符，格式为：
(需要转换成的类型)变量
但这样转换有可能会造成精度损失或者溢出
2、强制转换时的精度丧失和溢出
基本类型转换示例，注意强制转换时可能会造成的溢出和精度丢失。
a.例如：从小类型到大类型，自动完成转换：
int a = 100;
int b = 200;
long c = a + b; // 自动将int转换为long
b.例如：从大类型到小类型，需要强转：
long x = 1024L;
int i = (int) x; // 需加强制转换符,由于1024在int的范围内没有产生溢出
long y = 1024L * 1024 * 1024 * 4;
int j = (int) y; // 会产生溢出
System.out.println(j); // 结果为：0
double pi = 3.1415926535897932384;
float f = (float) pi; // 会造成精度的损失
System.out.println(f); // 结果为：3.1415927
package com.tedu;
//基本类型之间的相互转换
public class BasicTypeDemo4 {
public static void main(String[] args) {
//小转大：自动转换
int a=100;
int b=200;
long c=a+b;
//大转小：强制转
//强转格式：（需要转换为的类型）变量
byte e=(byte)a;
byte f=(byte)b;
System.out.println(e);
System.out.println(f);
}
}
3、byte、char、short转换为 int
byte、char、short 三种类型实际存储的数据都是整数，在实际使用中遵循如下规则：
1）int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。
2）byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。
byte g=10;
byte h=100;
g=(byte)(g+h);//括号中g,h转换成int类型，所以最后结果是int类型
4、数值运算时的自动转换
多种基本类型参与的表达式运算中，运算结果会自动的向较大的类型进行转换：
double a1=100*3.14;
long distance = 10000 * 365 * 24 * 299792458L;
// 由于有long型的直接量参与，整个表达式的结果为long
double change = 800 - 599.0;
// 由于有double型的直接量599.0参与，整个表达式的结果为 double
double persent1 = 80 / 100;
// 结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double型，将0转换为0.0
double persent2 = 80.0 / 100;
// 结果为0.8，右边表达式有double型直接量参与，运算结果为double型
2.3.7 基本类型的运算规则(5条)
规则1:运算结果的类型，与参与运算的较大类型保持一致
例如：
4 +3.0 int/double //结果是7.0(double类型)
4 - 3.0 int/double //结果是1.0(double类型)
4 * 3.0 int/double //结果是12.0(double类型)
4 / 2.0 int/double //结果是2.0(double类型)
4 / 3 int/int //结果是1(int类型)
规则2:byte，short，char三种比int小的整数，运算时会自动转成 int
例如：
byte a = 3;
byte b = 4;
byte c = a+b; //编译错误! a、b运算时和最终的结果都是int类型
byte d = (byte) (a+b); //正确, 将运算结果强转为byte类型
规则3:整数运算溢出
例如:
int a4=Integer.MAX_VALUE+1;
int a5=Integer.MIN_VALUE-1;//2147483647 溢出
System.out.println(a4);//-2147483648 溢出
System.out.println(a5);//2147483647 溢出
整数运算，可以理解为是时钟转圈，超出范围不出错，而是转到一个错误的结果！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z1PrRnWq-1625196914724)(.\图片\image157.jpg)]
规则4:浮点数运算不精确
System.out.println(0.1 + 0.2); //0.30000000000000004
System.out.println(0.2 - 0.1); //0.1
System.out.println(0.1 * 0.2); //0.020000000000000004
System.out.println(0.2 / 0.1); //2.0
System.out.println(0.3 - 0.1); //0.19999999999999998
System.out.println(0.3 / 0.1); //2.9999999999999996
Java中浮点数没有办法是用二进制进行精确表示
不过Java中也提供了方法进行精确运算，后面讲解
规则5:浮点数的特殊值
Infinity 无穷大
NaN (Not a Number) 非数字，当运算无法返回正确的结果时，将会返回NaN
例如：
System.out.println( 3.14 / 0 ); //Infinity,浮点数除以零结果都是无穷大
System.out.println( 0.0 / 0.0 ); //NaN
System.out.println( Math.sqrt( -6 ) ); //NaN
2.3.8 练习:牛郎织女
牛郎织女星相距：16.4 光年
光速：299792458 米/秒
喜鹊身长：0.46 米
牛郎织女相会，需要多少只喜鹊?
public static void main(String[] args) {
//1光年是多少米
long ly = 299792458L*60*60*24*365;
//16.4光年是多少米
double d = 16.4*ly; // double * long 是 double
//喜鹊数量
double r = d/0.46;
//Math.ceil(r) 对 r 向上取整
//35345.345 --> 35346.0 double类型的结果
//double 转成 long 整数类型
lon n = (long) Math.ceil(r);
System.out.println(n);
}
2.4 引用数据类型
2.4.1 引用类型简介
引用数据类型包括类、接口、数组类型，这些会在后续的课程中进行讲解。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EkPlVwAe-1625196914725)(C:\Users\Administrator\Desktop\图片\image159.png)]
2.4.2 String类简介
通过String类可以定义一个字符串。所谓的字符串就是指一组连续的字符组成的串。字符串中可以包含任意字符，这些字符必须包含在一对双引号（""）之内，例如：
"HelloWorld"
"Student"
"abc"
"123abc"
在使用String类之前，首先需要对String类进行初始化，可以通过如下两种形式：
//方式一：直接赋值
String str1 = "abcdef";
//方式二：使用new的方式
String str2 = new String("abcdef");
3、运算符+数组
3.1 运算符
3.1.1 运算符介绍
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a3mXpHPp-1625196914726)(C:\Users\Administrator\Desktop\图片\image161.jpg)]
/=
package com.tedu;
/*
* 演示java的各种运算符
*/
public class YunSuanFuDemo {
public static void main(String[] args) {
// 1.算数运算符
System.out.println(100+20);//120
System.out.println(100-20);//80
System.out.println(100/20);//5
System.out.println(100*20);//2000
//取余(%)
System.out.println(20%3);//2,商是6,余数2
//2.比较运算符
int a=40;
int b=30;
int c=20;
System.out.println(a==b);//false(假)
System.out.println(a!=b);//true(真)
System.out.println(a>=b);//true(真)
System.out.println(a>b);//true(真)
System.out.println(a<=b);//false(假)
System.out.println(a<b);//false(假)
//3.逻辑运算符(&&,||),两边必须是布尔值
//&&:两边都是true,结果才是true,只要有一个是false,结果就是false
//||:两边都是false,结果才是false,只要有一个是true，结果就是true
//两者都有短路效果:&&左边如果是false，右边不会执行;
//||左边是true，右边不会执行
System.out.println(a>b&&b<c);//false
System.out.println(a>=b&&b>=c);//true
System.out.println(a>b||b<c);//true
System.out.println(a>=b||b>=c);//true
System.out.println(a<=b||b<=c);//false
//!:对当前结果取反，(只能对布尔值取反),true取反就是false，false取反就是true
System.out.println(a>b&&!(b<c));//true
System.out.println(!(a<=b)||b<=c);//true
//4.自增自减运算符（++/--）
//++:在当前变量的基础上自增1（加1）
//i++:先访问(使用)i的值，再给i加1;
//++i:先给i加1，再访问(使用)i的值。
//--:在当前变量的基础上自减1（减1）
//i--:先访问(使用)i的值，再给i减1;
//--i:先给i减1，再访问(使用)i的值。
int i=5;
System.out.println(i++);//5；只对i访问一次，所以是5
System.out.println(i);//6；
// 5.三目运算符，格式：布尔表达式 ? 值1 : 值2
// 如果表达式结果是true,则返回值1，否则返回值2
int x = 7;
int y = 9;
int z = x > y ? x : y;// x>y是true,返回x,x>y是false,则是返回y;
System.out.println(z);
x = 123;
y = 456;
String str =x*y>500000 ? "YES" : "NO";
System.out.println(str); //NO
//6.复合赋值运算符
//+= 可以再相加的同时请赋值
int n = 10;
//n= n+5;
n = 10;n += 5;System.out.println(n);//和n=n+5效果相同
n = 10;n -= 5;System.out.println(n);//和n=n-5效果相同
n = 10;n *= 5;System.out.println(n);//和n=n*5效果相同
n = 10;n /= 5;System.out.println(n);//和n=n/5效果相同
n = 10;n %= 5;System.out.println(n);//和n=%/5效果相同
案列题：自增运算解析过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nFmiWC7q-1625196914727)(C:\Users\Administrator\Desktop\图片\003-自增运算解析过程.png)]
3.1.2 加号"+"的使用
1、如果加号 “+” 两边都是数值，加号会作为运算符使用，进行求和运算。
System.out.println( 100+23 ); //123
2、如果加号 “+” 两边包含char类型的值，在计算之前，char会被提升成为int，然后再计算。（char类型字符和int类型数字之间的对照关系表参照：ASCII、Unicode码表）
System.out.println( 'A'+1 ); //65+1
System.out.println('a'+1);//97+1
System.out.println( '中'+1 ); //20013+1
System.out.println('国'+1);//22269+1
3、如果加号 “+” 两边只要有一个String类型的值，加号会变为拼接符。任何数据类型和字符串通过 “+” 拼接时，都会拼接成字符串。
System.out.println( "A"+1 ); //A1
System.out.println( "中"+1 ); //中1
//加号可以做拼接符，将任意数据和字符串拼接
String name = "张三";
String age = "28";
String addr = "北京韩店去";
System.out.println(name+","+age+","+addr);
System.out.println("HelloWorld"+10+20+30);//HelloWorld102030
System.out.println("HelloWorld"+(10+20+30));//HelloWorld60
System.out.println("a"+1+2+3);//a123
System.out.println(1+2+"a"+3);//3a3
System.out.println(1+2+3+"a");//6a
3.1.3 练习:判断平年闰年
闰年条件:·
a) 年份能被4整除, 但不能被100整除
b) 或年份能被400整除
满足上面任何一个条件则为闰年, 其余则为平年。
可以通过if…else实现
也可以通过三目运算符实现
public class YunSuanFuDemo4 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//提示用户输入年份，并接受年份
System.out.println("请输入您的年份:");
int year = sc.nextInt();
//判断年份是平年还是闰年
String str="";
if((year%4==0 && year%100!=0) || year%400==0){//判断year是不是闰年
//if括号内的布尔值为true,就会执行当前代码块
str = "闰年";
}else{
//if括号内的布尔值为flase，就会执行当前代码块
str = "平年";
}
//输出判断结果
System.out.println("您输入的年份是:"+str);
/*或者用三目运算符：String year2 = (year%4==0 && year%100!=0) || year %400==0?"闰年":"平年";
System.out.println("您输入的年份是:"+year2);
*/
}}
3.1.4 练习:求最大值
运行程序，允许用户在控制台输入三个整数，并接受用户的输入。
比较三个整数，将其中的最大值输出到控制台上。
public class YunSuanFuDemo5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//提示用户输入三个整数，用空格隔开
System.out.println("请依次输入3个整数，并用空格隔开");
int num1 = sc.nextInt();
int num2 = sc.nextInt();
int num3 = sc.nextInt();
//判断num1和num2的大小，返回较大值
//布尔表达式 ? 值1 : 值2
//比较num1比num2大，就返回num1，否则就返回num2
int max=num1>num2 ? num1 : num2;
//比较max比num3的值，就返回max,否则就返回num
max=max>num3 ? max : num3;
System.out.println("您输入的最大值是："+max);
}
3.2 数组
3.2.1 什么是数组
数组是编程语言中最常见的一种数据结构，可用于存储多个数据，是指一组数据的集合。
数组中的每个数据被称为元素，数组里可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致，例如使用一个int类型数组保存某个学生的各科成绩，这样就避免了定义多个变量保存成绩的麻烦。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i9IZwtPL-1625196914729)(C:\Users\Administrator\Desktop\图片\image163.png)]
通常可通过数组元素的索引（下标）来访问数组元素，包括为数组元素赋值和取出数组元素的值。
3.2.2 数组的定义(声明)
Java语言支持两种语法定义(声明)数组：
int[] arr1;//类型[] 数组名称; //推荐
int arr2[];//类型 数组名称[];
推荐使用第一种方式（类型[] arr1;），因为第一种方式很容易理解这是定义一个变量，其中数据类型为类型[]，变量名为 arr1。而且这种方式具有更好的可读性。
第二种方式（类型 arr2[];）来自于 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够更快的理解Java语言。
定义数组只是定义了一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，只有对数组进行初始化后才可以访问数组中的元素。
3.2.3 数组的初始化(为数组中的元素赋值)
Java语言中数组必须先初始化，然后才可以使用。所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。
数组初始化有如下两种方式：
1）静态初始化：初始化时由从程序员指定每个数组元素的初始值，由系统决定数组长度。
2）动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
1、静态初始化
类型[] 变量名 = new 类型[]{元素1,元素2...元素N};
//或下面简化版的方式(注意这种方式只能用定义变量的同时并给变量赋值)
类型[] 变量名 = {元素1,元素2...元素N};
======================================================================
//>>静态初始化:由程序员指定数组的元素,由系统决定数组长度
//>>静态初始化方式1:
int[] arr3 = new int[]{11,22,33,44};
//>>静态初始化(简写形式)
int[] arr4 = {11,22,33,44};
2、动态初始化
类型[] 变量名 = new 类型[长度];
//动态初始化:由程序员指定数组长度,由系统为数组元素设置默认值
int[] arr5 = new int[5];
一旦数组完成初始化，数组在内存中所占的空间将被固定下来，所以数组的长度将不可改变。
3.2.4 如何访问数组
可以通过数组元素的索引（下标/角标）来访问数组元素，包括为数组元素赋值和取出数组元素的值。
访问到数组元素后，就可以把一个数组元素当成一个普通的变量使用了。包括为该变量赋值和取出该变量的值，这个变量的类型就是定义数组时方括号（[]）前的类型。
//访问格式:数组名称[下标值]
//数组的访问
//可以通过数组的下标(角标)来访问数组的元素
//数组的下标从0开始,0表示第一个元素,1表示第2各元素.....
//下标n表示第n+1个元素,访问格式:数组名称[下标值]
int[] arr6 = {75,85,92,56,90};
System.out.println(arr6[0]);//访问第1各元素,下标是0---75
System.out.println(arr6[1]);//访问第2各元素,下表是1---85
System.out.println(arr6[2]);//访问第3各元素,下标是2---92
System.out.println(arr6[3]);//访问第4各元素,下表是3---56
System.out.println(arr6[4]);//访问第5各元素,下标是4---90
// System.out.println(arr6[5]);//访问第6各元素,数组下标越界异常
=================================================================
//定义一个整数型数组，可以存储4个元素
int[] arr1 = new int[4];
//给arr1数组中的前两个元素赋值
arr1[0] = 70; //将70存入下标为0的位置
arr2[1] = 85; //将85存入下标为1的位置
//输出arr1数组中的4个元素（包括后两个未赋值的元素）
System.out.println( arr[0] ); //输出 70
System.out.println( arr[1] ); //输出 85
System.out.println( arr[2] ); //输出 0
System.out.println( arr[3] ); //输出 0
3.2.4.1 数组图解
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJJAVlEv-1625196914730)(C:\Users\Administrator\Desktop\图片\数组图解.png)]
3.2.5 数组的长度
//数组的长度
//length:通过这个属性可以访问数组的长度,不能改变长度
//一旦数组初始化完成,数组长度就固定了,不能再改变
//允许长度为0的数组
int[] arr8 = {11,22,33,44,55,66};
System.out.println(arr8.length);//输出长度为:6
//最大下标值=数组长度-1
3.3 数组的遍历
通过数组元素的下标可以获取数组中的每个元素，但如果数组中的元素较多，通过下标获取元素的方式太过繁琐。此时可以通过循环访问数组中的每个元素。
通过循环访问数组中的元素称之为遍历数组。
//数组的遍历:通过循环依次取出数组中的每一个元素
iint[] arr1 = {22,44,77,33,88,99};
//将数组的元素累加到sum上
int sum = 0;
for(int i = 0;i<arr1.length;i++) {
System.out.println(arr1[i]);
sum += arr1[i];
}
System.out.println("数组中元素的和为:"+sum);
=================================================================
//循环初始化;声明一个长度为50的int数组,通过循环为数组的元素设置随机值
int[] arr2 = new int[50];//长度为50的数组,默认值都是0;
//new Random().nextInt(100);
//遍历数组,为数组中的每一个元素设置一个随机值
for(int i = 0; i<arr2.length;i++){
arr2[i] = new Random().nextInt(100);
System.out.print(arr2[i]+" ");
// 对下面的数组进行遍历,求数组中的最大值
int[] arr = {22,44,77,33,88,99};
/*
* 思路:定义一个变量(max),和数组中的每一个元素比较,将二者中的较大值赋给max
* 直到循环结束,max就是数组中的最大值
* int max=0;
*/
int max=0;
for( int i=0;i<arr.length;i++){
//三目运算符
//max = max>arr[i]?max:arr[i];
//使用if分支比较两个数值
if(max<arr[i]){
max = arr[i];
}
System.out.println(max);
3.4 数组工具类Arrays
Arrays类是JDK提供的操作数组的工具类，包含操作数组的各种方法。
3.4.1 Arrays.toString方法
toString(array)：将数组中的所有元素转成字符串进行拼接，元素与元素拼接时，中间用逗号间隔，并且两端用方括号([])括起来。
代码示例：
int[] arr = {22,44,77,33,88,99};
//直接输出数组名称(会输出地址值,而不是数组中的数字)
System.out.println(arr);//[I@4f8e5cde
//Arrays.toString方法可以直接将数组中的元素以字符串的形式输出
String str = Arrays.toString(arr);
System.out.println(str);//[22, 44, 77, 33, 88, 99]
====================================================================
//定义一个整数型数组，可以存储10个元素
int[] arr1 = new int[10];
//for循环遍历数组，为数组中的每个元素赋值
for( int i=0;i< 10;i++) {
arr1[i] = i+1;
}
//使用Arrays.toString方法打印数组中的所有元素的值
System.out.println( Arrays.toString( arr1 ) ); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3.4.2 Arrays.copyOf方法
copyOf(originalArr，length)： 将数组(originalArr)复制到另一个指定长度(length)的数组中并返回复制的数组。
关于copyOf使用场景:现在我们操作一个数组中的元素,但又不想改变原数组,可以先对原数组进行复制,
代码示例：
int[] arr = {22,44,77,33,88,99};
//这不是复制(克隆)数组
int[] arr2 = arr;
=================================================================
/*copyOf方法:假设现有一个数组是arr,长度是arr.length
1)copyOf(arr,len),如果len等于原数组的长度,将会返回一个新数组,
新数组和原数组内容一模一样
2)copyOf(arr,len),如果len小于原数组的长度,将会复制原数组中前len个元素
3)copyOf(arr,len),如果len大于原数组的长度,将会返回一个长度为len的新数组,
其中前arr.length个元素是原数组的内容,剩余的则是默认值
*/
int[] arr = {22,44,77,33,88,99};
//复制arr数组,复制到一个长度为4的新数组中
int[] newArr1 = Arrays.copyOf(arr, 4);
System.out.println(Arrays.toString(newArr1));
//复制arr数组,复制到一个长度为6的新数组中
int[] newArr2 = Arrays.copyOf(arr, 6);
System.out.println(Arrays.toString(newArr2));
//复制arr数组,复制到一个长度为6的新数组中
int[] newArr3 = Arrays.copyOf(arr, 10);
System.out.println(Arrays.toString(newArr3));
3.4.3 Arrays.sort方法
sort(array)：根据数组中元素的自然顺序进行升序排列，排序直接对原数组产生影响
该方法没有返回值
代码示例：
int[] arr5 = {88, 11, 67, 123, 99};
//对数组中的所有元素升序排序，
Arrays.sort( arr5 );
System.out.println( Arrays.toString( arr5 ) );//[11,67,88,99,123]
====================================================================
int[] arr6 = {88, 11, 67, 123, 99};
//对数组中从第2个到第4个元素升序排序
Arrays.sort( arr6, 1, 3 );
System.out.println( Arrays.toString( arr6 ) );//[88,11,67,123,99]
3.4.4 案例:考试成绩统计
现有张三同学的五次英语考试成绩如下:
int[] arr = { 95, 88, 69, 74, 83 };
现要求求出张三五次成绩的总和、平均分、历史最高成绩和最低成绩
public static void main(String[] args) {
//某位同学的五次考试成绩
int[] arr = { 95, 88, 69, 74, 83 };
int sum=0;
//求五次考试成绩总和
for(int i=0;i<arr.length;i++){
sum+=arr[i];//sum=sum+arr[i];
}
System.out.println("五次考试成绩总和:"+sum);
//求五次考试成绩的平均分
double avg=sum*1.0/arr.length;
System.out.println("五次考试成绩的平均分:"+avg);
//使用sort方法对arr数组中的数值进行排序(从小到大)
Arrays.sort(arr);
//求五次考试成绩的最高分
System.out.println(arr[arr.length-1]);
//求五次考试成绩的最低分
System.out.println(arr[0]);
}
4 、流程控制:分支+循环
4.1 流程控制
4.1.1 流程控制概述
第一种:顺序结构
所谓的顺序结构就是程序代码从上往下逐行执行，中间没有任何判断和跳转。
默认所有的代码都是按照顺序结构来执行的
第二种:分支结构
1）if语句：根据布尔表达式或布尔值作为条件进行判断，从而实现分支控制
2）switch语句：通过多个整数值进行匹配，从而实现分支控制。
第二种:循环结构
如果由某一行代码或者某些行代码需要重复的执行若干次,这样的结构叫循环结构
1）for循环：大部分情况下可以代替while循环、do while循环。
2）while循环：先判断，根据判断结果再决定是否执行循环体
3）do while循环：先执行一次循环体，再判断，根据判断结果再决定是否执行循环体
4.2 分支结构
4.2.1 if分支结构
if语句使用布尔表达式或者布尔值作为分支条件进行分支控制，常见的有如下三种形式：
第一种形式：
if ( 布尔表达式 ) {
//代码...
}
//如果if后面的表达式为true,就会执行if后面大括号{}里面的代码
if(布尔表达式) //if和else后面的大括号可以省略
//代码1 如果if后面的表达式为true的话,没有大括号只会执行第一行代码
//代码2 第二行以及后的代码不会执行
第二种形式：
if ( 布尔表达式 ) {
//代码...
}else{
//代码....
}
//如果if后面的表达式为true,就会执行if后面大括号{}里面的代码
//如果表达式为false,就会执行else大括号{}后面的代码
第三种形式：
if ( 布尔表达式1 ) {
//代码...
}else if(布尔表达式2){
//代码....
}else if(布尔表达式3){
//代码....
}
else if(布尔表达式n){
//代码....
}
...
else{
//代码..
}
//如果if后面的表达式1为true,就会执行if后面大括号{}里面的代码
//如果else if后面的表达式2 为true,就会执行else if后面大括号{}里面的代码
...
//如果上面的条件都不满足,最后就会执行else大括号{}后面的代码
4.2.2 if练习1:判断年龄段
根据用户输入的年龄判断用户所属的群体
package com.tedu;
import java.util.Scanner;
/*
* 根据年龄判断年龄段
* 青年人：20(包括) ~ 40(不包括)
* 中年人：40(包括) ~ 60(不包括)
* 老年人：60(包括)以上
*/
public class IfDemo1 {
public static void main(String[] args) {
System.out.println("请输入您的年龄:");
byte age = new Scanner(System.in).nextByte();
if (age >= 20 && age < 40) {
System.out.println("您属于:青年人!");
} else if (age >= 40 && age < 60) {
System.out.println("您属于:中年人!");
} else if (age >= 60) {
System.out.println("您属于:老年人!");
} else if (age >= 0 && age < 18) {
System.out.println("您属于:青少年!");
} else {
System.out.println("您输入的年龄有误!");
}
}
}
4.2.3 switch分支结构(了解)
switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch case 语句结构如下：
switch( expression ){
case value1 :{
//语句
break; }//可选
case value2 :{
//语句
break;} //可选
// 可以有任意数量的case语句
...
default : {//可选
{ //语句
}
switch case 语句有如下规则：
1 switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7，switch 开始支持字符串 String 类型。
2 switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
3 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句，当遇到break 语句时，switch 语句终止。
4 程序跳转到 switch 语句后面的语句执行。case 语句不是必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
5 switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 只有在没有 case 语句的值和变量值相等时执行。default 分支不需要break 语句。
6 case value:后面的大括号可以省略
4.2.4 switch练习1:ATM机
实现一个模拟ATM机系统，根据用户输入的代码，打印不同的操作
package com.tedu;
import java.util.Scanner;
public class ATMquqian2 {
public static void main(String[] args) {
//模拟简易存取款机
//声明一个扫描器,获取用户输入
Scanner sc = new Scanner(System.in);
System.out.println( "欢迎使用达内存取款系统!" );
System.out.println( "请输入您的操作: 1-查询余额, 2-存钱, 3-取钱, 4-退出" );
//获取用户输入的操作代码
int num = sc.nextInt();
switch (num){
case 1:
System.out.println("查询余额");
break;
case 2:
System.out.println("存钱");
break;
case 3:
System.out.println("取钱");
break;
case 4:
System.out.println("退出");
break;
default:
System.out.println("您的输入有误,请重新输入");
}
}
}
package com.tedu;
import java.util.Scanner;
public class ATMquqian {
public static void main(String[] args) {
//定义一个变量,用于记录账户 金额
double balance = 3000;
//模拟简易存取款机
//声明一个扫描器,获取用户输入
Scanner sc = new Scanner(System.in);
System.out.println( "欢迎使用达内存取款系统!" );
System.out.println( "请输入您的操作: 1-查询余额, 2-存钱, 3-取钱, 4-退出" );
//获取用户输入的操作密码
int num = sc.nextInt();
switch(num){
case 1:
System.out.println("您的账余额为:"+balance);
break;
case 2:
System.out.println("请放入您的钞票...(输入存入的金额):");
double save = sc.nextDouble();
balance+=save;
System.out.println("存钱成功,账户余额为:"+balance);
break;
case 3:
System.out.println("请输入您的取钱金额:");
double get = sc.nextDouble();
if(balance-get>=0){
balance-=get;
System.out.println("取钱成功,您的账户余额为:"+balance);
}else{
System.out.println("您的账户余额不足");
}
break;
case 4:
System.out.println("请收好您的卡片,谢谢使用");
break;
default:
System.out.println("您的输入有误,请重新输入");
}
}
}
4.3 循环结构
顺序结构的程序语句只能被执行一次。如果想要重复的执行某一的操作，就需要使用循环结构。
4.3.1 for循环
for循环是更加简洁的循环语句，大部分情况下，for循环可以代替while循环、do while循环。for循环语法格式如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vYFW9mIJ-1625196914732)(C:\Users\Administrator\Desktop\图片\image165.jpg)]
关于 for 循环有以下几点说明：
1）最先执行初始化步骤，且只执行一次。这里可以声明一种类型，也可以同时初始化一个或多个循环控制变量，也可以是空语句。
2）其次，检测循环条件（是一个布尔表达式）的值。如果为 true，循环体被执行；如果为false，循环从图中的2–3步中终止，开始执行循环语句后面的语句。
3）在执行一次循环体后，再执行更新部分，也就是更新循环控制变量。
4）再次检测布尔表达式。重复执行2~3步骤。（当第二步中的布尔表达式为false时，停止循环）
for( 初始化; 循环条件; 更新) {
//循环体
}
...
//打印1-100之间的所有整数的和,用空格隔开
for(int i=0;i<100;i++){//用i++和++i没有区别
System.out.print(i+1+" ");
}
//第01次执行:先执行int i =0;(这一部分只执行一次),在执行 i<100(true),执行大括号里面的内容(循环体),最后执行i++(此时i=1)
//第02次执行:执行 i<100(true),再执行循环体,最后执行i++(此时i=2)
//第03次执行:执行 i<100(true),再执行循环体,最后执行i++(此时i=3)
...
//第099次执行:执行 i<100(true),再执行循环体,最后执行i++(此时i=99)
//第100次执行:执行 i<100(true),再执行循环体,最后执行i++(此时i=100)
//第101次执行:执行 i<100(false),循环结束
...
//求1-100之间所有的整数值的和,并输出到控制台
int sum = 0;
for(int i=1;i<=100;i++){//1,2,3,4....99,100
sum = sum+i;//sum+=i;
}
System.out.println("1-100之间所有的整数值的和:"+sum);
4.3.2 while循环
//new Random().nextInt();--返回int范围内的一个随机整数
//new Random().nextInt(n);--返回0~n范围内的一个随机整数,包括0但不包括n
//new Random().nextDouble();--返回0.0~1.0范围内的一个随机整数,包括0但不包括1
while是最基本的循环，它的结构为：
while( 布尔表达式 ) { //循环体 //更新 } //只要布尔表达式为 true，循环体就会不断重复的执行下去。直到布尔表达式为false，才会终止执行循环体。 //对于 while 语句而言，如果不满足条件，则不能进入循环。 ...... //示例：输出 0~10之间的所有整数 public static void main(String args[]) { int x = 1; while( x <= 10 ) { System.out.println( x ); x++; } } //执行过程解析 //第01次执行:i=1,i<=10(true),执行循环体(i=2) //第02次执行:i=2,i<=10(true),执行循环体(i=3) //第03次执行:i=3,i<=10(true),执行循环体(i=4) //... //第009次执行:i=9,i<=10(true),执行循环体(i=10) //第10次执行:i=10,i<=10(true),执行循环体(i=11) //第11次执行:i=11,i<=10(false),循环结束 ....... //
4.3.3 while练习:猜数字游戏
猜数字游戏：产生一个随机整数，由用户猜数字，程序从控制台获取用户猜的数字，并给出提示（大了、小了、猜对了）直到猜对了方可结束程序。
//获取一个0~100之间的一个随机整数
int num = new Random().nextInt(100);
while(true){//死循环
System.out.println(num);
//提示用户输入一个1~100之间的整数
System.out.println("请输入你猜得数(0~100之间的整数):");
int n = new Scanner(System.in).nextInt();
if(n>num){//大了
System.out.println("太大了!");
}else if(n<num){//小了
System.out.println("太小了!");
}else{
System.out.println("猜中了!");
break;//用来结束循环
}
}
4.3.4 do while循环(了解)
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//循环体
}while( 布尔表达式 );
........
//循环输出0~10之间的所有整数
int i= 1;
do{
System.out.println(i);
i++;
}while(i<=10);
关于do…while循环：
1）由于布尔表达式在循环体的后面，所以循环体在检测布尔表达式之前已经执行了一次。
2）接着检测布尔表达式的值。只要后面每判断一次布尔表达式的值为true，就会执行一次循环体。直到检测到布尔表达式的值为false，才会终止执行循环体。
5、API:Object+字符串
5.3 String
5.3.1 String概述及特点
String 类代表字符串，在开发中，字符串（String）操作也是最常见的操作。
字符串具有如下特点：
-
所有的字符串字面值（例如 “abc”）都是String类的对象实例
-
字符串是常量，字符串本身在创建之后不能更改(不是变量(或引用)不可变)
-
字符串是由多个字符组成的一串数据，可以看成一个字符数组。
5.3.2 String对象的创建
方式一：String s1 = “abc” 通过字符串直接量的形式创建字符串
方式二：String s2 = new String(“abc”); 通过new的形式创建字符串
5.3.3 String类上的常用方法1_判断功能
boolean equals(Object anObject)
//常用于判断两个字符串内容是否相等（区分大小写），如果相等则返回true，否则返回false；
String str1 = "abc";
String str2 = "Abc";
str1.equals(str2)
boolean equalsIgnoreCase(String anotherString)
//判断两个字符串内容是否相等（不区分大小写），如果相等则返回true，否则返回false；
boolean contains(CharSequence s)
//判断当前字符串是否包含指定的字符串（区分大小写），如果包含则返回true，否则返回false；
String str1 = "abc";
String str2 = "ab";
str1.contains(str2)
boolean startsWith(String prefix)
//判断当前字符串是否以指定的字符串开头，若是则返回true，否则返回false；
String str1 = "hello";
String str2 = "hel";
str1.startsWith(str2)
boolean startsWith(String prefix, int startIndex)
//判断当前字符串的指定位置是否以指定的字符串开头，若是则返回true，否则返回false；
String str1 = "hello";
String str2 = "llo";
str1.startsWith(str2,2)
boolean endsWith(String suffix)
//判断当前字符串是否以指定的字符串结尾，若是则返回true，否则返回false；
示例1：测试 equals、equalsIgnoreCase、contains 方法:
// 测试equals,equalsIgnoreCase,contains方法
String str1 = new String("hello java");
String str2 = new String("hello java");
String str3 = new String("Hello java");
//1)equals方法用于比较两个字符串内容是否形同(区分大小写)
//==判断字符串判断的不是字符串内容,判断的是字符串的地址值
System.out.println(str1==str2);//false
System.out.println(str1.equals(str2));//true
System.out.println(str1.equals(str3));//false
System.out.println(str1.equalsIgnoreCase(str3));//true
====================================================================
//2)contains方法用于判断当前字符串是否包含传过来的字符串
System.out.println(str1.contains("java"));//true
System.out.println(str1.contains("Java"));//false
System.out.println(str1.contains("Jv"));//false
示例2：测试 startsWith, endsWith方法:
//测试startsWith方法
String str4 = "welcome to tedu";
System.out.println(str4.startsWith("wel"));//true
System.out.println(str4.startsWith("come"));//false
System.out.println(str4.startsWith("come",3));//true
//测试endWith方法
System.out.println(str4.endsWith("tedu"));//true
System.out.println(str4.endsWith("ted"));//false
5.3.4 常用方法2_获取功能
int length() //返回此字符串的长度。该长度字符串中包含的字符数。
char charAt(int index) //返回指定索引处的 char 值。
int indexOf(int ch|String str)
//返回指定字符或字符串在此字符串中第一次出现处的索引(下标)。
int indexOf(int ch|String str, int fromIndex)
//返回指定字符或字符串在此字符串中第一次出现处的索引，从指定的索引开始。
int lastIndexOf(int ch|String str)
//返回指定字符或字符串在此字符串中[最后一次]出现处的索引。
int lastIndexOf(int ch|String str, int fromIndex)
//返回指定字符或字符串在此字符串中[最后一次]出现处的索引，从指定的索引开始。
String substring(int beginIndex)
//从指定索引处(包含头)开始截取，一直到字符串结尾，返回一个新的字符串
String substring(int beginIndex, int endIndex)
//从指定索引处(包含头)开始截取，一直到指定索引处(不包含尾)结束，返回一个新的字符串
示例1：测试 length、charAt、substring 方法：
// 测试length,charAt,substring方法
String str1 = "welcome to tedu";
//length方法--返回当前字符串的长度
System.out.println(str1.length());//15
//charAt方法--返回指定下标处的字符
System.out.println(str1.charAt(14));//u
//substring(begin)--从下标begin出开始截取,截取到末尾
System.out.println(str1.substring(5));//me to tedu
//substring(begin,end)--从下标begin出开始截取,截取到下标end处(不包含end处
System.out.println(str1.substring(5, 10));//me to
示例2:测试indexOf,lastIndexOf方法
//测试indexOf,lastIndexOf方法
String str2 = "hello helen henry";
//获取"he"第一次出现的位置
System.out.println(str2.indexOf("he"));//0
//获取"he"从下标3之后第一次出现的位置
System.out.println(str2.indexOf("he",3));//6
//获取"he"最后一次出现的位置
System.out.println(str2.lastIndexOf("he"));//12
//获取"he"从下标10处最后一次出现的位置---从下标10处向前看"he"最后出现的位置
System.out.println(str2.lastIndexOf("he",10));//6
5.3.5 常用方法3_其他
String replace(char oldChar, char newChar)
//返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String[] split(String regex)
//根据给定规则拆分此字符串。
String trim()
//去除此字符串两端的空格
示例：测试 replace、split、trim方法：
//测试replace,split,trim方法
String tel = "180-1892-3456";
//去掉tel中的横杠(-)--用空字符串替换横杠
System.out.println(tel.replace("-", ""));//18018923456
//用横杠对tel字符串进行切割
String[] arr= tel.split("-");//{"180","1892","3456"}
System.out.println(Arrays.toString(arr));
//去除str3两端的空格
String str3=" a bcd e ";
System.out.println(str3.trim());
返回指定字符或字符串在此字符串中[最后一次]出现处的索引。
int lastIndexOf(int ch|String str, int fromIndex)
//返回指定字符或字符串在此字符串中[最后一次]出现处的索引，从指定的索引开始。
String substring(int beginIndex)
//从指定索引处(包含头)开始截取，一直到字符串结尾，返回一个新的字符串
String substring(int beginIndex, int endIndex)
//从指定索引处(包含头)开始截取，一直到指定索引处(不包含尾)结束，返回一个新的字符串
**示例1：测试 length、charAt、substring 方法：**
```java
// 测试length,charAt,substring方法
String str1 = "welcome to tedu";
//length方法--返回当前字符串的长度
System.out.println(str1.length());//15
//charAt方法--返回指定下标处的字符
System.out.println(str1.charAt(14));//u
//substring(begin)--从下标begin出开始截取,截取到末尾
System.out.println(str1.substring(5));//me to tedu
//substring(begin,end)--从下标begin出开始截取,截取到下标end处(不包含end处
System.out.println(str1.substring(5, 10));//me to
示例2:测试indexOf,lastIndexOf方法
//测试indexOf,lastIndexOf方法
String str2 = "hello helen henry";
//获取"he"第一次出现的位置
System.out.println(str2.indexOf("he"));//0
//获取"he"从下标3之后第一次出现的位置
System.out.println(str2.indexOf("he",3));//6
//获取"he"最后一次出现的位置
System.out.println(str2.lastIndexOf("he"));//12
//获取"he"从下标10处最后一次出现的位置---从下标10处向前看"he"最后出现的位置
System.out.println(str2.lastIndexOf("he",10));//6
5.3.5 常用方法3_其他
String replace(char oldChar, char newChar)
//返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String[] split(String regex)
//根据给定规则拆分此字符串。
String trim()
//去除此字符串两端的空格
示例：测试 replace、split、trim方法：
//测试replace,split,trim方法
String tel = "180-1892-3456";
//去掉tel中的横杠(-)--用空字符串替换横杠
System.out.println(tel.replace("-", ""));//18018923456
//用横杠对tel字符串进行切割
String[] arr= tel.split("-");//{"180","1892","3456"}
System.out.println(Arrays.toString(arr));
//去除str3两端的空格
String str3=" a bcd e ";
System.out.println(str3.trim());
467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
