尚硅谷Java零基础全套视频教程(宋红康2023版，java入门自学必备)_宋红康java课件2023

尚硅谷Java零基础全套视频教程(宋红康2023版，java入门自学必备)

开发环境：jdk17 + idea2022

第一阶段：Java基本语法

一、Java语言概述

01、Java新版视频教程简介

02、课程目录说明

03、Java基础全栈学习路线

04、抽茧剥丝话Java

05、Java工程师全程学习路线

06、计算机硬件的介绍

6.1 计算机组成：硬件+软件

6.2 CPU、内存与硬盘

6.3 输入设备：键盘输入

金山打字通

07、常见的DOS命令

DOS（Disk Operating System，磁盘操作系统）是Microsoft公司在Windows之前推出的一个操作系统，是单用户、单任务（即只能执行一个任务）的操作系统。现在被Windows系统取代。

进入DOS操作窗口：
按下Windows+R键盘，打开运行窗口，输入cmd回车，进入到DOS的操作窗口。

常用指令：
操作1：进入和回退

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	列出当前目录下的文件以及文件夹
cd 目录	进入指定单级目录。
cd 目录1\目录2\...	进入指定多级目录。cd atguigu\JavaSE
cd ..	回退到上一级目录。
cd \ 或 cd /	回退到盘符目录。
操作2：增、删
操作	说明
md 文件目录名	创建指定的文件目录。
rd 文件目录名	删除指定的文件目录（如文件目录内有数据，删除失败）
操作3：其它
操作	说明
cls	清屏。
exit	退出命令提示符窗口。
← →	移动光标
↑ ↓	调阅历史操作命令
Delete和Backspace	删除字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

08、不同编程语言的介绍

8.1 计算机语言是什么

就是人与计算机交流的方式。人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

计算机语言有很多种。如：C 、C++、Java、Go、JavaScript、Python，Scala等。

8.2 计算机语言简史

高级语言独立于机器，有一定的通用性；计算机不能直接识别和执行用高级语言编写的程序，需要使用编译器或者解释器，转换为机器语言才能被识别和执行

高级语言按照程序设计方法的不同，又分为：面向过程的语言、面向对象的语言。

• 1.C、Pascal、Fortran面向过程的语言
• 2.C++面向过程/面向对象
• 3.Java跨平台的纯面向对象的语言
• 4.C#、Python、JavaScript、Scala…

8.3 计算机语言排行榜

TIOBE （https://www.tiobe.com/tiobe-index/）流行编程语言排行，每月更新

网传的编程语言鄙视链：

09、Java相关历史

10、JDK的选择和下载

path 路径从上往下识别

11、 HelloWorld

11.1 开发步骤

Java程序开发三步骤：编写、编译、运行。

• 将 Java 代码编写到扩展名为 .java 的源文件中
• 通过 javac.exe 命令对该 java 文件进行编译，生成一个或多个字节码文件
• 通过 java.exe 命令对生成的 class 文件进行运行
  

HelloWorld

cmd  复制路径  右击粘贴
1

新建文件，后缀为 .java

内容
编码格式 – ANSI

// 类  类名{}
class HelloChina{

}
1
2
3
4

cmd

C:\Users\stu>e:

E:\>cd E:\z_teach\javacode\chapter01

E:\z_teach\javacode\chapter01>javac HelloWorld.java

1
2
3
4
5
6

结果

cmd

E:\z_teach\javacode\chapter01>java HelloChina
错误: 在类 HelloChina 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application
1
2
3
4

内容

class HelloChina{
	public static void main(String[] args){
	
	}
}
1
2
3
4
5

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java

E:\z_teach\javacode\chapter01>java HelloChina

E:\z_teach\javacode\chapter01>
1
2
3
4
5

内容

class HelloChina{
	public static void main(String[] args){
		System.out.println("hello,world!!");
		System.out.println("你好,中国!!");
	}
}
1
2
3
4
5
6

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java

E:\z_teach\javacode\chapter01>java HelloChina
hello,world!!
你好,中国!!
1
2
3
4
5

内容

class HelloChina{
	public static void main(String[] args){
		System.out.println("hello,world!!");
		System.out.println("你好,中国!!");
	}
}

class  Lin{

}


class Yu{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java
1

结果

12.、HelloWorld总结

13、注释

内容

/*
这是多行注释，可以声明多行注释的信息

1、Java中的注释的种类：
单行注释、多行注释、文档注释（Java特有）

2、单行注释、多行注释的作用：
①对程序中的代码进行解释说明
②对程序进行调试

3、注意：
① 单行注释和多行注释声明的信息不参与编译。换句话说，编译后声明的字节码文件中不包含单行注释和多行注释的信息
② 多行注释不能嵌套使用

4、文档注释
文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
*/

/**
这是我的第一个java程序

@author davina
@version 1.0
*/

public class CommentTest{
	/**
	这是main方法，格式是固定的
	*/
	/**
	这是main方法，格式是固定的（多行注释）
	*/
	public static void main(String[] args){
		//这是输出语句
		System.out.println("hello,world");
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

运行

E:\z_teach\javacode\chapter01>javadoc -d mydoc -author -version CommentTest.java
1

结果

14、 Java API文档

•下载API文档：

• 在线看：https://docs.oracle.com/en/java/javase/17/docs/api/index.html
• 离线下载：https://www.oracle.com/java/technologies/javase-jdk17-doc-downloads.html

15、Java核心机制：JVM

15.1 Java语言的优缺点

15.1.1 优点

跨平台性

面向对象性：
面向对象编程支持封装、继承、多态等特性，让程序更好达到高内聚，低耦合的标准。
健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制

15.1.2 缺点

• 语法过于复杂、严谨，对程序员的约束比较多，与python、php等相比入门较难。但是一旦学会了，就业岗位需求量大，而且薪资待遇节节攀升。
• 一般适用于大型网站开发，整个架构会比较重，对于初创公司开发和维护人员的成本比较高（即薪资高），选择用Java语言开发网站或应用系统的需要一定的经济实力。
• 并非适用于所有领域

15.2 JVM功能说明

JVM（Java Virtual Machine ，Java虚拟机）：是一个虚拟的计算机，是Java程序的运行环境。JVM具有指令集并使用不同的存储区域，负责执行指令，管理数据、内存、寄存器。

15.2.1 功能1：实现Java程序的跨平台性

我们编写的Java代码，都运行在JVM 之上。正是因为有了JVM，才使得Java程序具备了跨平台性。

使用JVM前后对比：

15.2.2 功能2：自动内存管理(内存分配、内存回收)

•Java程序在运行过程中，涉及到运算的数据的分配、存储等都由JVM来完成
•Java消除了程序员回收无用内存空间的职责。提供了一种系统级线程跟踪存储空间的分配情况，在内存空间达到相应阈值时，检查并释放可被释放的存储器空间。
•GC的自动回收，提高了内存空间的利用效率，也提高了编程人员的效率，很大程度上减少了因为没有释放空间而导致的内存泄漏。

16、章节案例

案例1：个人信息输出

内容

class PersonalInfo{
	public static void main(String[] args){
		System.out.println("姓名：康师傅");
		System.out.println();  //换行
		System.out.println("性别：男");
		System.out.println("家庭住址：北京程序员聚集地：回龙观");
	} 
}
1
2
3
4
5
6
7
8

结果

E:\z_teach\javacode\chapter01>javac PersonalInfo.java

E:\z_teach\javacode\chapter01>java PersonalInfo
姓名：康师傅

性别：男
家庭住址：北京程序员聚集地：回龙观

E:\z_teach\javacode\chapter01>
1
2
3
4
5
6
7
8
9

案例2：输出：心形

结合\n(换行)，\t(制表符)，空格等在控制台打印出如下图所示的效果。

方式一：
//方式一：

class Exercise2{
	public static void main(String[] args){
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("*");
		System.out.print("\t");
		//System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("I love java");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");
		
		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("    ");
		System.out.print("*");

	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

方式二：

class Exercise3{

	public static void main(String[] args){                                                                                                   
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("*"+"\t\t"+"*"+"\t\t\t\t"+"I love Java"+"\t\t\t\t"+"*"+"\t\t\t"+"*"+"\n");
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");

		System.out.print("\t\t"+"*"+"\t\t\t\t\t\t\t\t\t\t"+"*"+"\t\t"+"\n");

		System.out.print("\t\t\t"+"*"+"\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("\t\t\t\t"+"*"+"\t\t\t\t\t\t"+"*"+""+"\t"+"\n");
		System.out.print("\t\t\t\t\t"+"*"+"\t\t\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t"+"*"+"\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t\t"+"*"+"\n");


	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

17、随堂复习与企业真题

17.1、随堂复习

17.1.1、java基础全程的学习内容

神书：《Java核心技术》、《effective java》、《java编程思想》

17.1.2、软件开发相关内容

没有最好的语言，只有在特地场景下相对来说，最适合的语言

17.1.3、java概述

17.1.4、Java环境的搭建

17.1.5、代码

17.1.6、常见问题

17.1.7、API文档

17.1.8、练习

17.2、企业真题

1、一个“.java”源文件中是否可以包括多个类？有什么限制（明*数据）
一个源文件中可以声明多个类，最多只有一个类使用public 进行声明。

但是一个源文件只能有一个public的类

2、java的优势（）

• 跨平台型
• 安全性高
• 简单性
• 高性能
• 面向对象性
• 健壮性

3、常用的几个命令行操作都有哪些（至少4个）

4、java中是否存在内存溢出、内存泄漏？如何解决？举例说明（拼）**
存在
不能

5. 如何看待Java是一门半编译半解释型的语言

二、变量与运算符

01、关键字、保留字

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）HelloWorld案例中，出现的关键字有 class、public 、 static 、 void 等，这些单词已经被Java定义好了。

特点：全部关键字都是小写字母。
关键字比较多，不需要死记硬背，学到哪里记到哪里即可。

官方地址

说明：
1.关键字一共50个，其中const和goto是保留字(reserved word)。
2.true，false，null不是关键字，是字面量，表示特殊的布尔值和空值，可以当做关键字来看待

保留字 ：const、goto

02. 标识符( identifier)

• 凡是自己可以起名字的地方都叫标识符。
• 比如：类名、变量名、方法名、接口名、包名、常量名

2.1、标识符的命名规则（必须遵守的硬性规定）：

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

2.2、标识符的命名规范

• 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang、com.atguigu.bean

• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等

• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName

• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

class IdentifierTest{
	public static void main(String[] args){
		
		int abc = 12;
		int age = 16;  //age:标识符
		
		char gender = '男';
	}
	
	public static void main1(String[] args){
	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

03. 变量（重点）

3.1、为什么需要变量

变量是程序中不可或缺的组成单位，最基本的存储单元。

3.2、初识变量

变量的概念：

• 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
• 变量的构成包含三个要素：数据类型、变量名、存储的值
• Java中变量声明的格式：数据类型 变量名 = 变量值

class VariableTest{
	public static void main(String[] args){
		
		//定义变量的方式1
		char gender; 	//过程1：变量的声明
		gender = '男';	//过程2：变量的赋值（或初始化）
		
		gender = '女';	
		
		//定义变量的方式2：声明与初始化合并
		int age = 10;
		
		System.out.println("Hello World!");
		System.out.println(age);
		System.out.println("age = " + age);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.3、 Java中变量的数据类型

Java中变量的数据类型分为两大类：

• 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。
• 引用数据类型：包括数组、 类、接口、枚举、注解、记录。
  

3.4、变量的使用

04. 基本数据类型介绍

4.1 整数类型：byte、short、int、long

4.2 浮点类型：float、double

/*
测试整型和浮点型变量的使用

*/
class VariableTest1{
	public static void main(String[] args){
		
		//1、测试整型变量的使用
		// byte(1字节 = 8bit) \ short(2字节 ) \ int(4字节) \ long(8字节)
		
		byte b1 = 12;
		byte b2 = 127;
		
		// byte b3 = 128;   //编译不通过，因为超出了byte的存储范围
		
		short s1 = 1234;
		
		int i1 = 123234123;
		//①声明long类型变量时，需要提供后缀，后缀为‘l’或'L'
		long l1 = 123123123L;	
		
		//②开发中，定义整型变量时，无特殊情况，通常声明为int类型
		
		
		//2、测试浮点型变量的使用
		// float \ double
		double d1 = 12.3;
		//①声明float类型变量时，需要提供后缀，后缀为‘f’或'F'
		float f1 = 12.3f;
		
		System.out.println("f1 = " + f1);
		
		//②开发中，定义浮点型变量时，无特殊情况，通常声明为double类型,因为精度更高
		
		//③ float 类型表数范围大于long类型的，但是精度不高
		
		//测试浮点型变量的精度，
		//浮点型变量的精度不高，需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。
		//测试1：
		System.out.println(0.1 + 0.2);
		
		//测试2：
		float ff1 = 123123123f;
		float ff2 = ff1 + 1;
		System.out.println(ff1);
		System.out.println(ff2);
		System.out.println(ff1 == ff2);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

java 计算金额时，使用 BigDecimal类替换，可以实现任意精度的数据的运算

4.2.1 关于浮点型精度的说明

• 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。
• 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

4.2.2 应用举例

案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

class FloatDoubleExer{
	public static void main(String[] args){
		
		//定义圆周率变量
		double pi = 3.14;
		
		//定义三个圆的半径
		double radius1 = 1.2;
		double radius2 = 2.5;
		double radius3 = 6;
		
		//计算面积
		double area1 = pi * radius1 * radius1;
		double area2 = pi * radius2 * radius2;
		double area3 = pi * radius3 * radius3;
		
		//输出
		System.out.println("圆1的半径为： " + radius1 + "，面积为：" + area1);
		System.out.println("圆2的半径为： " + radius2 + "，面积为：" + area2);
		System.out.println("圆3的半径为： " + radius3 + "，面积为：" + area3);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

**案例2：**小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

// ℃ = (℉ - 32) / 1.8

public class Exercise2 {
    public static void main(String[] args) {
        double hua = 80;
        double she = (hua-32)/1.8;
        System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
    }
}
1
2
3
4
5
6
7
8
9

4.3、字符类型：char

char使用的是Unicode字符集，包含了世界范围的所有字符

class CharTest{
	public static void main(String[] args){
		
		//形式1：使用单引号(' ')括起来的单个字符。
		char c1 = 'a'; 
		char c2 = '中'; 
		char c3 = '1';
		char c4 = '%';
		char c5 = 'Y';
		
		//编译不通过
		//char c6 = '';
		//char c7 = 'ab';
		
		//形式2：直接使用 Unicode值来表示字符型常量
		char c8 = '\u0036';
		System.out.println(c8);	
		
		//形式3：使用转义字符‘\’
		char c9 = '\n';  // '\n'表示换行符
		char c10 = '\t';
		System.out.println("hello" + c9 + "world");	
		
		//形式4:使用具体字符对应的数值（比如ASCII码）
		char c11 = 97;
		System.out.println(c11);	// a 
		
		char c12 = '1';
		char c13 = 1; //两者不相等
	}
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4.4、布尔类型：boolean

boolean类型数据只有两个值：true、false

boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

• if条件控制语句；
• while循环控制语句；
• for循环控制语句；
• do-while循环控制语句；

class BooleanTest{
	public static void main(String[] args){		
		// 布尔类型：boolean
		boolean bo1 = true;
		boolean bo2 = false;
		
		//boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
		boolean isMarried = true;
		if(isMarried){
			System.out.println("很遗憾，不能参加单身派对了");
		}else{
			System.out.println("可以多谈几个男朋友或女朋友");
		}
		
		//不谈boolean类型占用空间的大小，都是，真正在内存中分配的话，使用的是4个字节		
	}
}	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

05、基本数据类型变量间运算规则

1、在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。
2、转换的方式有两种：
自动类型提升
强制类型转换

5.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型

/*

取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

特别的：
	byte,short,char数据类型的变量进行算术运算时，结果按照int类型处理。
*/

class VariableTest3{
	public static void main(String[] args){
		
		int i1 = 10;
		int i2 = 11;
		
		long l1 = i1;
		
		float f1 = l1;
		
		byte b1 = 12;
		int i3 = b1 + i1;
		
		//编译不通过
		//byte b2 = b1 + i1;
		
		//特殊情况1：byte,short之间运算
		byte b3 = 12;
		short s1 = 10;
		//编译不通过
		//short s2 = b3 + s1;
		i3 = b3 + s1;
		
		byte b4 = 10;
		int i4 = b3 + b4;
		
		//特殊情况2：char
		char c1 = 'a';
		//编译不通过
		//char c2 = c1 + b3;
		int i5 = c1 + b3;

		//**************************************
		//练习1
		long l2 = 123L;
		long l3 = 123;  //理解为：自动类型提升
		
		//long l4 = 123123123123; //123123123123理解为int类型，因为超出了int范围，所以报错
		long l5 = 123123123123L; //此时的123123123123L就是使用8个字节存储的long类型的值
		
		//练习2
		float f2 = 12.3F;
		//float f3 = 12.3; //不满足自动类型提升的规则（double --> float ）,所以报错
	
		//练习3
		//规定1：整型常量，规定是int类型
		byte b5 = 10;
		//byte b6 = b5 + 1;
		int i11 = b5 + 1;
		
		//规定2：浮点型常量，规定是double类型
		double d2 = b5 + 12.3;
		
		//练习4：为什么不允许变量名是数字开头。为了"自洽"
		/*
		int 123L = 12;
		long l6 = 123L;
		*/		
	}
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

5.2 强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。
转换格式：
数据类型1 变量名 = (数据类型1)被强转数据值; //()中的数据类型必须<=变量值的数据类型

当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

class VariableTest4{
	public static void main(String[] args){
		
		double d1 = 12; //自动类型提升
		
		//编译不通过
		//int i1 = d1;
		
		int i2 = (int)d1;
		System.out.println(i2);
		
		long l1 = 123;
		
		//编译不通过
		//short s1 = l1;
		
		short s2 = (short)l1;
		System.out.println(s2);
		
		//练习
		int i3 = 12;
		float f1 = i3; //自动类型提升
		System.out.println(f1); // 12.0
		
		float f2 = (float)i3; //编译可以通过，省略()而已

		//精度损失的例子1
		double d2 = 12.9;
		int i4 = (int)d2;
		System.out.println(i4);
		
		//精度损失的例子2
		int i5 = 128;
		byte b1 = (byte)i5;
		System.out.println(b1); //-128
	
		//实际开发举例
		byte b2 = 12;
		method(b2);
		
		long l2 = 12L;
		//编译不通过
		//method(l2);
		method((int)l2);
	}
	
	public static void method(int num){	//int num = b2; 自动类型提升
		System.out.println("num = " + num);
	} 
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

5.3 基本数据类型与String的运算

5.3.1 字符串类型：String

String不是基本数据类型，属于引用数据类型
使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
声明方式与基本数据类型类似。例如：String str = “尚硅谷”;

class StringTest{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1");
		System.out.println(str1);
		
		
		String str2 = "";
		String str3 = "a";	
	}
}	
1
2
3
4
5
6
7
8
9
10
11

5.3.2 运算规则

/*
测试强制类型转换

*/
class StringTest{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1");
		System.out.println(str1);
		
		
		String str2 = "";
		String str3 = "a";	
		
		
		//测试连接运算
		int num1 = 10;
		boolean b1 = true;
		String str4 = "hello";
		
		System.out.println(str4 + b1); //hellotrue
		
		String str5 = str4 + b1;
		String str6 = str4 + b1 + num1;
		System.out.println(str6); //hellotrue10
		
		//如何将String 类型转换为基本数据类型
		String str7 = "abc"; //不能考虑转换为基本数据类型
		
		int num2 = 10;
		String str8 = num2 + ""; "10"
		//编译不通过
		//int num3 = (int)str8;
		
		//使用Integer类
		int num3 = Integer.parseInt(str8);
		System.out.println(str8);
	}
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

5.3.3 案例与练习

案例：公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用true表示，单身用false表示）、联系方式等等。

class StringExer{
	public static void main(String[] args){	
		
		String name = "莉莉";
		int age = 18;
		char gender = '女';
		double weight = 99.1;
		boolean isMarried = false;
		String phoneNumber = "1234567890";
		
		System.out.println("姓名: " + name + "，年龄：" + age + "，性别： " + gender + "，体重： " + weight + "，婚姻状况：" + isMarried + "，联系方式： " + phoneNumber);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

06、进制的认识

• 二进制（binary）（以0B、0b开头）、十进制、八进制（以0开头）、十六进制（以0x、0X开头）的声明方式
• 二进制的理解
• 正数：原码、反码、补码三码合一
• 负数：原码、反码、补码不相同。
• 计算机的底层是以补码的方式存储数据的
• 熟悉：二进制与十进制之间的转换
• 了解：二进制与八进制、十六进制之间的转换

07、运算符（Operator）（重点）

7.1 算术运算符

7.1.1 基本语法

++ 或 – 不会改变数据类型

class AriTest {
	public static void main(String[] args){	
	
	//-------------------------------------------------------------------------------
		// 除法：/
		int m1 = 12;
		int n1 = 5;
		int k1 = m1 / n1;  
		System.out.println(k1);  //2 
		
		System.out.println(m1 / n1 * n1); //10 
		
		//取模（或取余） ： %
		int i1 = 12;
		int j1 = 5;
		System.out.println(i1 % j1); //2 
		
		//开发中，经常用来判断某个数num1能整除另外一个数num2。 num1 % num2 == 0 
		//比如判断num1是否是偶数： num1 % num2 == 0 
		
		//取模后，结果与被模数符号相同
		int i2 = -12;
		int j2 = 5;
		System.out.println(i2 % j2); //-2 
		
		int i3 = 12;
		int j3 = -5;
		System.out.println(i3 % j3); //2 
		
		int i4 = -12;
		int j4 = -5;
		System.out.println(i4 % j4); //-2 
		

	//-------------------------------------------------------------------------------
		//(前)++：先自增1，再运算
		//(后)++：先运算，再自增1
		int a1 = 10;
		int b1 = ++a1;	
		System.out.println("a1 = " + a1 + ", b1 = " + b1);  // a1 = 11,b1 = 11
		
		int a2 = 10;
		int b2 = a2++;	
		System.out.println("a2 = " + a2 + ", b2 = " + b2); // a2 = 11,b2 = 10
		
		//练习1
		int i = 10;
		// i++;
		++i;
		System.out.println("i = " + i); // 11
		
		//练习2
		short s1 = 10;
		
		//方式1
		/*
		//编译不通过
		//s1 = s1 + 1;
		s1 = (short)(s1 + 1);
		System.out.println(s1);
		*/
		
		//方式2 
		s1++;
		System.out.println(s1);
		
	//-------------------------------------------------------------------------------
		//(前)--：先自减1，再运算
		//(后)--：先运算，再自减1
		
		//+：连接符，只适用于String与其他类型的变量间的运算，而且运算结果也是String类型
	}	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

7.1.2 案例与练习

案例1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

class AriExer {
	public static void main(String[] args){	
		
		int num = 153;
		int ge = num % 10; // 个位
		int shi = num / 10 % 10; //十位
		int bai = num / 100; //百位
		
		System.out.println("个位是: " + ge);
		System.out.println("十位是: " + shi);
		System.out.println("百位是: " + bai);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

案例2：
为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

class AriExer1 {
	public static void main(String[] args){	
		int num = 89;
		int day = num / 24; 
		int hour = num % 24;
		
		System.out.println("共奋战: " + day + "天零" + hour + "小时");	
	}
}
1
2
3
4
5
6
7
8
9

额外案例1

System.out.println("5 + 5= " + 5 + 5);  // 5 + 5= 55
System.out.println("5 + 5= " + (5 + 5)); // 5 + 5= 10
1
2

** 额外案例2**

byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128
1
2
3

** 额外案例3**

int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j); //10
1
2
3

** 额外案例4**

int i = 2;
int j = i++;
System.out.println(j);  //2

int k = 2;
int z = ++k;
System.out.println(z);  //3

int m = 2;
m = m++; 
System.out.println(m);  //2
1
2
3
4
5
6
7
8
9
10
11

7.2 赋值运算符

7.2.1 基本语法

= 、+=、 -=、*=、 /=、%=

/*
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。


*/	

class SetValueTest {
	public static void main(String[] args){
		int i = 5;
		
		long l = 10; //	自动类型提升
		
		byte b = (byte)i; //强制类型转换
	
		//操作方式1
		int a1 = 10;
		int b1 = 10;
		
		//操作方式2：连续赋值
		int a2;
		int b2;
		//或合并：int a2,b2;
		a2 = b2 = 10;
		
		System.out.println(a2 + "," + b2);
		
		
		//操作方式3：
		//int a1 = 20;
		//int b1 = 20;
		int a2 = b2 = 20;		
		System.out.println(a3 + "," + b3);
		
	//-------------------------------------------------------------------------------
		// += 的使用
		int m1 = 10;
		m1 += 5; 
		// 类似于 m1 = m1 + 5;
		System.out.println(m1);
		
		byte by1 = 10;
		by1 += 5;  //by1 = by1 + 5; 会编译报错，改为 by1 = (byte)(by1 + 5); 
		System.out.println(by1);
		
		int m2 = 1;
		m2 *= 0.1;  //m2 = (int)(m2 * 0.1)
		System.out.println(m2);
		
		//练习1：如何实现一个变量的值增加2 
		//方式1
		int n1 = 10;
		n1 = n1 + 2;
		
		//方式2(推荐）
		int n2 = 10;
		n2 += 2;
		
		//练习2：如何实现一个变量的值增加1 
		//方式1
		int i1 = 10;
		i1 = i1 + 1;
		
		//方式2
		int i2 = 10;
		i2 += 1;
		
		//方式3：(推荐）
		int i3 = 10;
		i3++; // ++i3;
	}
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

7.3 比较(关系)运算符

•比较运算符的结果都是boolean型，也就是要么是true，要么是false。
•> < >= <= ：只适用于基本数据类型（除boolean类型之外）
== != ：适用于基本数据类型和引用数据类型
•比较运算符“==”不能误写成“=”

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7.4 逻辑运算符

逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值

public class LogicTest {
	public static void main(String[] args) {	
	
		/*
		区分：& 和 &&
		
		–相同点：两个符号表达的都是且的关系，如果符号左边是true，则二者都执行符号右边的操作
		–不同点：& ： 如果符号左边是false,则继续执行符号右边的操作
  && ：如果符号左边是false,则不再继续执行符号右边的操作

–建议：开发中，推荐使用 && 
		*/
		
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		
		if(b1 & (num1++ >0)){
			System.out.println("床前明月光");
		}else{
			System.out.println("我叫郭德纲");
		}
		System.out.println("num1 = " + num1);
		
		
		
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		
		if(b2 && (num2++ >0)){
			System.out.println("床前明月光");
		}else{
			System.out.println("我叫郭德纲");
		}
		System.out.println("num2 = " + num2);
	}
}	
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

区分“|”和“||”：
— 相同点：如果符号左边是false，则二者都执行符号右边的操作
— 不同点：| ： 如果符号左边是true，则继续执行符号右边的操作
|| ：如果符号左边是true，则不再继续执行符号右边的操作
建议：开发中，推荐使用 ||

/*
	1. 定义类 LogicExer
	2. 定义 main方法
	3. 定义一个int类型变量a,变量b,都赋值为20
	4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
	5. 输出a的值,bo1的值
	6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
	7. 输出b的值,bo2的值
*/

public class LogicExer {
        public static void main(String[] args) {
            int a,b;
            a = b = 20;

            boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);

            System.out.println("a = " + a + ",bo1 = " + bo1);

            boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);

            System.out.println("b = " + b + ",bo2 = " + bo2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7.5 位运算符

/*
位运算符

1、 <<   >>  >>>     &   \   ^   ~

2、说明
①<<   >>  >>>     &   \   ^   ~    针对数值类型的变量或常量进行运算，运算结果也是数值
②<<  每向左移动一位，相当于原数据*2。（正数、负数都适用）
  >>  每向右移动一位，相当于原数据/2。    【注意】如果不能整除，向下取整。
 >>>   往右移动后，左边空出来的位直接补0。（正数、负数都适用）
 &    对应位都是1才为1，否则为0。
*/

class BitTest{
    public static void main(String[] args) {
        int num1 = 7;
        System.out.println("num1 << 1 : " + (num1 << 1));  //num1 << 1 : 14
        System.out.println("num1 << 2 : " + (num1 << 2)); // num1 << 2 : 28
        System.out.println("num1 << 3 : " + (num1 << 3)); // num1 << 3 : 56
        System.out.println("num1 << 28 : " + (num1 << 28)); //num1 << 28 : 1879048192
        System.out.println("num1 << 29 : " + (num1 << 29)); //num1 << 29 : -536870912   过犹不及

        int num2 = -7;
        System.out.println("num2 << 1 : " + (num2 << 1));  //num2 << 1 : -14
        System.out.println("num2 << 2 : " + (num2 << 2)); // num2 << 2 : -28
        System.out.println("num2 << 3 : " + (num2 << 3)); // num2 << 3 : -56

        //面试题：高效计算 2 * 8
        // 2 << 3 或 8 << 1


        //69>>4  类似于  69/2的4次 = 69/16 =4
        System.out.println(69 >> 4);  //4

        System.out.println(62 >>> 3); //7

        System.out.println(5 & 3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

//如何交换两个int型变量的值？String呢？
 class BitExer {
    public static void main(String[] args) {
        int m = 10;
        int n = 5;

        System.out.println("m = " + m + ", n = " + n);

        //（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
        //int temp = m;
        //m = n;
        //n = temp;

        //实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
        //m = m + n; //15 = 10 + 5
        //n = m - n;//10 = 15 - 5
        //m = m - n;//5 = 15 - 10

        //实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
        m = m ^ n;
        n = m ^ n; //(m ^ n) ^ n
        m = m ^ n;

        System.out.println("m = " + m + ", n = " + n);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

7.6 条件运算符

7.6.1 基本语法

条件运算符格式：
(条件表达式)? 表达式1:表达式2
说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
要求表达式1和表达式2为同种或兼容的类型

7.6.2 案例

class ConditionTest{
    public static void main(String[] args) {

        String info = (2 > 10)?  "表达式1" : "表达式2";
        System.out.println(info);

        double result = (2 > 1)? 1 : 2.0;
        System.out.println(result);

        //练习1：获取两个数中的较大值
        int m = 10;
        int n = 20;

        int max = (m > n)? m : n;
        System.out.println("较大值为：" + max);

        //练习2：获取三个数中的较大值
        int i = 20;
        int j = 30;
        int k = 50;

        int temp = (i > j)? i : j;
        int  finalMax = (temp > k)? temp : k;
        System.out.println("较大值为：" + finalMax);

        int finalMax1 = (((i > j)? i : j) > k)? ((i > j)? i : j) : k;
        System.out.println("较大值为：" + finalMax1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/*
  练习：今天是周2，10天以后是周几？
 */
class ConditionExer{
    public static void main(String[] args) {

        int week = 2;

        week += 10;

        week %= 7;

        System.out.println("今天是周2，10天以后是周" + ((week == 0)? "日" : week) );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7.6.3 与if-else的转换关系

凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立

开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高

7.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。

开发建议：
1.不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。
2.不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如： (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

三、流程控制语句

01、顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转

package testOne;

public class StatementTest {
    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        System.out.println("x = " + x);
        System.out.println("y = " + y);

        //对x、y的值进行修改
        x++;
        y = 2 * x + y;
        x = x * 10;
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

02、分支语句

• 根据条件，选择性地执行某段代码。
• 有if…else和switch-case两种分支语句

2.1 if-else条件判断结构

2.1.1 基本语法

结构1：单分支条件判断：if

格式：

if(条件表达式)｛
  	语句块;
｝
1
2
3

说明：条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或 布尔变量。

结构2：双分支条件判断：if…else
格式：

if(条件表达式) { 
  	语句块1;
}else {
  	语句块2;
}
1
2
3
4
5

结构3：多分支条件判断：if…else if…else
格式：

if (条件表达式1) {
  	语句块1;
} else if (条件表达式2) {
  	语句块2;
}
...
}else if (条件表达式n) {
 	语句块n;
} else {
  	语句块n+1;
}
1
2
3
4
5
6
7
8
9
10
11

说明：一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构

当条件表达式之间是“互斥”关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓。
当条件表达式之间是“包含”关系时，“小上大下 / 子上父下”，否则范围小的条件表达式将不可能被执行。

2.1.2 应用举例

案例1：成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则提示需要做进一步的检查。

public class IfElseTest1 {
    public static void main(String[] args){
        int heartBeats = 89;

        if(heartBeats < 60 || heartBeats > 100){
            System.out.println("你需要做进一步的检查");
        }

        System.out.println("体检结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11

案例2：定义一个整数，判定是偶数还是奇数

public class IfElseTest2 {
    public static void main(String[] args){
        int a = 10;

        if(a % 2 == 0) {
            System.out.println(a + "是偶数");
        } else{
            System.out.println(a + "是奇数");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

案例3：
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为(80，99]时，奖励一辆山地自行车；
当成绩为[60,80]时，奖励环球影城一日游；
其它时，胖揍一顿。

说明：默认成绩是在[0,100]范围内

public class IfElseTest3 {
    public static void main(String[] args) {

        int score = 67;//岳小鹏的期末成绩
        //写法一：默认成绩范围为[0,100]
        if(score == 100){
            System.out.println("奖励一辆跑车");
        }else if(score > 80 && score <= 99){    //错误的写法：}else if(80 < score <= 99){
            System.out.println("奖励一辆山地自行车");
        }else if(score >= 60 && score <= 80){
            System.out.println("奖励环球影城玩一日游");
        }
        //else{
        //	System.out.println("胖揍一顿");
        //}


        //写法二：
        // 默认成绩范围为[0,100]
        if(score == 100){
            System.out.println("奖励一辆跑车");
        }else if(score > 80){
            System.out.println("奖励一辆山地自行车");
        }else if(score >= 60){
            System.out.println("奖励环球影城玩一日游");
        }else{
            System.out.println("胖揍一顿");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2.1.3 if…else嵌套

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构。

执行的特点：
（1）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

案例4：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。

import java.util.Scanner;

public class StatementTest {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        System.out.println("输入第1个整数： " );
        int num1 = in.nextInt();
        System.out.println("输入第2个整数： " );
        int num2 = in.nextInt();
        System.out.println("输入第3个整数： ");
        int num3 = in.nextInt();

        if(num1 >= num2){
            if (num3 >= num1){
                System.out.println(num2 + "," + num1 + "," + num3);
            }else if(num3 <= num2){
                System.out.println(num3 + "," + num2 + "," + num1);
            }else {
                System.out.println(num2 + ',' + num3 + ',' + num1);
            }
        }else {
            if (num3 >= num2){
                System.out.println(num2 + "," + num3 + "," + num1);
            }else if(num3 <= num1){
                System.out.println(num3 + "," + num1 + "," + num2);
            }else {
                System.out.println(num1 + ',' + num3 + ',' + num2);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2.1.4 练习

练习1：

对下列代码，若有输出，指出输出结果

int x = 4;
int y = 1;
if (x > 2) {
       if (y > 2) 
            System.out.println(x + y);
       System.out.println("atguigu");
} else
       System.out.println("x is " + x);
1
2
3
4
5
6
7
8

练习2：

boolean b = true;
//如果写成if(b=false)能编译通过吗？如果能，结果是？
if(b == false) 	 //建议：if(!b)
	System.out.println("a");
else if(b)
	System.out.println("b");
else if(!b)
	System.out.println("c");
else
	System.out.println("d");
1
2
3
4
5
6
7
8
9
10

练习3：

定义两个整数，分别为small 和 big，如果第一个整数small大于第二个整数big，就交换。输出显示small和big变量的值。

    public static void main(String[] args) {
        int small = 10;
        int big = 30;

        if(small > big){
            int tmp = small;
            small = big;
            big = tmp;
        }
        System.out.println(small + " 、 "+ big);
    }
1
2
3
4
5
6
7
8
9
10
11

练习4：

小明参加期末Java考试，通过考试成绩，判断其Java等级，成绩范围[0,100]

• 90-100 优秀
• 80-89 好
• 70-79 良
• 60-69 及格
• 60以下 不及格

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("小明的期末Java成绩是： ");
        int score = scan.nextInt();

        if (score < 0 || score > 100) {
            System.out.println("你的成绩是错误的");
        }else if(score >= 90){
            System.out.println("你的成绩属于优秀");
        }else if (score >= 80) {
            System.out.println("你的成绩属于好");
        } else if (score >= 70) {
            System.out.println("你的成绩属于良");
        } else if (score >= 60) {
            System.out.println("你的成绩属于及格");
        } else {
            System.out.println("你的成绩属于不及格");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

练习5：

编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”

    public static void main(String[] args) {
        int a = 20;
        int b = 90;
        if(a + b >= 50){
            System.out.println("hello world!");
        }
    }
1
2
3
4
5
6
7

练习6：

编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

    public static void main(String[] args) {
    
        double num1 = 21.0;
        double num2 = 19.0;

        if (num1 > 10.0 && num2 < 20.0){
            System.out.println(num1 + num2);
        }else {
            System.out.println(num1 * num2);
        }
    }
1
2
3
4
5
6
7
8
9
10
11

练习7：判断水的温度

如果大于95℃，则打印“开水”；
如果大于70℃且小于等于95℃，则打印“热水”；
如果大于40℃且小于等于70℃，则打印“温水”；
如果小于等于40℃，则打印“凉水”。

    public static void main(String[] args) {
        int waterTemperature = 62;
        if (waterTemperature > 95){
            System.out.println("开水");
        }else if (waterTemperature >70){
            System.out.println("热水");
        }else if (waterTemperature > 40){
            System.out.println("温水");
        }else {
            System.out.println("凉水");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

2.2 switch-case 选择结构

2.2.1 基本语法

语法格式

switch(表达式){
    case 常量值1:
        执行语句1;
        //break;
    case 常量值2:
        执行语句2;
        //break; 
    // ...
   [default:
        执行语句n+1;
        break;
   ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行流程图

执行过程

• 第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。
• 第2步：执行完此case的执行语句以后，
  • 情况1：如果遇到break,则执行break并跳出当前的switch-case结构
  • 情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。—>case穿透 … 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

public class SwitchCaseTest {
    public static void main(String[] args) {

        int num = 1;
        switch (num){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
             default:
                 System.out.println("other");
                 break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class SwitchCaseTest2 {
    public static void main(String args[]) {
        String season = "summer";
        switch (season) {
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            default:
                System.out.println("季节输入有误");
                break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用注意点：

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
• case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；
• 同一个switch语句，所有case子句中的常量值互不相同；
• break语句用来在执行完一个case分支后使程序跳出switch语句块；
• 如果没有break，程序会顺序执行到switch结尾；
• default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

2.2.2 if-else语句与switch-case语句比较

• 结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。
• 开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。
• 细节对比：
  • if-else语句优势
    • if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。
    • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。
  • switch语句优势
    • 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。
    • 使用switch可以利用穿透性，同时执行多个分支，而if…else没有穿透性。

2.2.3 案例

案例1
使用switch-case实现：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

public class SwitchCaseTest {
    public static void main(String[] args) {

        int score = 99;

        switch (score/60){
            case 0:
                System.out.println("不及格");
                break;
            case 1:
                System.out.println("及格");
                break;
            default:
                System.out.println("输入的成绩有误");
                break;
        }
    }
}



switch(score / 10){
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("不及格");
				break;
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
				System.out.println("及格");
				break;
			default:
				System.out.println("输入的成绩有误");
				break;
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

案例2
编写程序：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。

import java.util.Scanner;

public class SwitchCaseTest {



    public static void main(String[] args) {

        //1、使用scanner，从键盘获取2023年的month、day
        Scanner scan = new Scanner(System.in); //阻塞式方法

        System.out.println("请输入2023年的月份");
        int month = scan.nextInt();

        System.out.println("请输入2023年的天：");
        int day = scan.nextInt();


        //2、使用switch-case 实现分支结构
        int sumDay = 0; //记录总天数

        //方式1，不推荐，冗余
/*        switch (month){
                case 1:
                    sumDay = day;
                    break;
                case 2:
                    sumDay = 31 + day;
                    break;
                case 3:
                    sumDay = 31 + 28 + day;
                    break;
                case 4:
                    sumDay = 31 + 28 + 31 + day;
                    break;
                case 5:
                    sumDay = 31 + 28 + 31 + 30 + day;
                    break;
                case 6:
                    sumDay = 31 + 28 + 31 + 30 + 31 + day;
                    break;
                case 7:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + day;
                    break;
                case 8:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + day;
                    break;
                case 9:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + day;
                    break;
                case 10:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + day;
                    break;
                case 11:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + 31 + day;
                    break;
                case 12:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + 31 + 30 + day;
                    break;
            }*/

        //方式2
        switch (month){
            case 12:
                sumDay += 30;
            case 11:
                sumDay += 31;
            case 10:
                sumDay += 30;
            case 9:
                sumDay += 31;
            case 8:
                sumDay += 31;
            case 7:
                sumDay += 30;
            case 6:
                sumDay += 31;
            case 5:
                sumDay += 30;
            case 4:
                sumDay += 31;
            case 3:
                sumDay += 28;
            case 2:
                sumDay += 31;
            case 1:
                sumDay += day;
                break;
        }

            System.out.println("2023年" + month + "月" + day + "日，是当前的第" + sumDay + "天");

            scan.close(); //为了防止内存泄漏
    }
}




/*

import java.util.regex.Pattern;
import java.util.regex.Matcher;


//使用正则表达式进行日期校验
        public class DateValidator {

            private static final String DATE_PATTERN = "^(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])-(19|20)\\d\\d$";

            public static boolean isValidDate(String date) {
                Pattern pattern = Pattern.compile(DATE_PATTERN);
                Matcher matcher = pattern.matcher(date);
                return matcher.matches();
            }

            public static void main(String[] args) {
                String date = "2023-06-23";
                boolean isValid = isValidDate(date);
                System.out.println(" isValid: " + isValid);
            }
        }   */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

2.2.4 练习

练习1
从键盘输入星期的整数值，输出星期的英文单词

import java.util.Scanner;

public class SwitchCaseExer1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入星期值：");
        int weekday = input.nextInt();

        switch (weekday){
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("你输入的星期值有误！");
                break;
        }
        input.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

练习2
使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e. 其它的输出 “other”。

public class SwitchCaseExer2 {
    public static void main(String[] args) {
        char word = 'c';
        switch (word){
            case 'a':
                System.out.println('A');
                break;
            case 'b':
                System.out.println('B');
                break;
            case 'c':
                System.out.println('C');
                break;
            case 'd':
                System.out.println('D');
                break;
            case 'e':
                System.out.println('E');
                break;
             default:
                 System.out.println("other");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

练习3

编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：

score>=90           等级:  A
70<=score<90        等级:  B    
60<=score<70        等级:  C
score<60            等级:  D

方式一：使用if-else
方式二：使用switch-case:  score / 10:   0 - 10
1
2
3
4
5
6
7
8
9

import java.util.Scanner;

public class SwitchCaseExer3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入学生成绩：");

        int score = input.nextInt();
        char grade;//记录学生等级

/*        if (score >= 90){
            grade = 'A';
        }else if (score >= 70){
            grade = 'B';
        }else if (score >= 60){
            grade = 'C';
        }else {
            grade = 'D';
        }*/


//方式2：
        switch(score / 10){
            case 10:
            case 9:
                grade = 'A';
                break;
            case 8:
            case 7:
                grade = 'B';
                break;
            case 6:
                grade = 'C';
                break;
            default :
                grade = 'D';
        }

        System.out.println("学生成绩为" + score + ",对应的等级为" + grade);
        input.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

练习4
编写一个程序，为一个给定的年份找出其对应的中国生肖。中国的生肖基于12年一个周期，每年用一个动物代表：rat、ox、tiger、rabbit、dragon、snake、horse、sheep、monkey、rooster、dog、pig。

提示：2022年：虎 2022 % 12 == 6

import java.util.Scanner;

/**
 * @author davina
 * @create 18:20
 */

public class SwitchCaseExer4 {
    public static void main(String[] args) {
        //从键盘输入一个年份
        Scanner input = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = input.nextInt();
        input.close();

        //判断
        switch (year % 12) {
            case 0:
                System.out.println(year + "是猴年");
                break;
            case 1:
                System.out.println(year + "是鸡年");
                break;
            case 2:
                System.out.println(year + "是狗年");
                break;
            case 3:
                System.out.println(year + "是猪年");
                break;
            case 4:
                System.out.println(year + "是鼠年");
                break;
            case 5:
                System.out.println(year + "是牛年");
                break;
            case 6:
                System.out.println(year + "是虎年");
                break;
            case 7:
                System.out.println(year + "是兔年");
                break;
            case 8:
                System.out.println(year + "是龙年");
                break;
            case 9:
                System.out.println(year + "是蛇年");
                break;
            case 10:
                System.out.println(year + "是马年");
                break;
            case 11:
                System.out.println(year + "是羊年");
                break;
            default:
                System.out.println(year + "输入错误");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

练习5：押宝游戏
随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了

提示：随机数 Math.random()产生 [0,1)范围内的小数
如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

import java.util.Scanner;

public class SwitchCaseExer5 {
    public static void main(String[] args) {
        //1、随机产生3个1-6的整数
        int a = (int)(Math.random()*6 + 1);
        int b = (int)(Math.random()*6 + 1);
        int c = (int)(Math.random()*6 + 1);

        //2、押宝
        Scanner input = new Scanner(System.in);
        System.out.print("请押宝（豹子、大、小）：");
        String ya = input.next();
        input.close();

        //3、判断结果
        boolean result = false;
        //switch支持String类型
        switch (ya){
            case "豹子": result = a == b && b == c; break;
            case "大": result = a + b + c > 9; break;
            case "小": result = a + b + c <= 9; break;
            default:System.out.println("输入有误！");
        }

        System.out.println("a,b,c分别是：" + a +"," + b +"," + c );
        System.out.println(result ? "猜中了" : "猜错了");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

03、循环语句

• 根据循环条件，重复性的执行某段代码。

• 有for、while、do-while

• 三种循环语句。

• 补充：JDK5.0 提供了foreach循环，方便的遍历集合、数组元素。

• 理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。

• 循环结构分类：

  • for 循环
  • while 循环
  • do-while 循环

• 循环结构四要素：

  • 初始化部分
  • 循环条件部分
  • 循环体部分
  • 迭代部分

3.1 for循环

3.1.1 基本语法

语法格式：
for (①初始化部分; ②循环条件部分; ④迭代部分)｛
③循环体部分;
｝
执行过程：①-②-③-④-②-③-④-②-③-④-…-②

3.1.2 应用举例

案例1：使用for循环重复执行某些语句
题目：输出5行HelloWorld

public class ForTest1 {
    public static void main(String[] args) {
/*        需求1：控制台输出5行Hello World!
        写法1：
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");*/

        //写法2：
        for(int i = 1;i <= 5;i++){
            System.out.println("Hello World!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class ForTest2 {
	public static void main(String[] args) {
        int num = 1;
        for(System.out.print("a");num < 3;System.out.print("c"),num++){
            System.out.print("b");

        }
    }
}
1
2
3
4
5
6
7
8
9

案例2 累加
题目：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和

public class ForTest3 {
	public static void main(String[] args) {
        int count = 0;//记录偶数的个数
        int sum = 0;//记录偶数的和

        for(int i = 1;i <= 100;i++){

            if(i % 2 == 0){
                System.out.println(i);
                count++;
                sum += i;
            }	
        }
        System.out.println("偶数的个数为：" + count);	
        System.out.println("偶数的总和为：" + sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例3：结合分支结构使用
题目：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 111 + 333 + 555

public class ForTest4 {
	public static void main(String[] args) {
		//定义统计变量，初始化值是0
		int count = 0;
		
		//获取三位数，用for循环实现
		for(int x = 100; x < 1000; x++) {
			//获取三位数的个位，十位，百位
			int ge = x % 10;
			int shi = x / 10 % 10;
			int bai = x / 100;
			
			//判断这个三位数是否是水仙花数，如果是，统计变量++
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
                System.out.println("水仙花数：" + x);
				count++;
			}
		}
		
		//输出统计结果就可以了
		System.out.println("水仙花数共有"+count+"个");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

案例5： 结合break的使用
说明：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。

import java.util.Scanner;

//输入两个正整数m和n，求其最大公约数和最小公倍数
public class ForTest1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入正整数m: ");
        int m = input.nextInt();
        System.out.println("请输入正整数n: ");
        int n = input.nextInt();

        //获取m和n中的较小值
        int min = (m < n)? m : n;

        //需求1：最大公约数
        //方式1：
        int result = 1;
        for (int i = 1; i <= min; i++) {
            if (m % i == 0 && n % i == 0){
                //System.out.println(i);
                result = i;
            }
        }
        System.out.println(result);

        //方式2：推荐
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println(i);
                break; //一旦执行就跳出当前循环
            }
        }


        //需求2：最小公倍数
        int max = (m > n)? m : n;
        for (int i = max; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0 ){
                System.out.println(i);
                break;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

说明：

• 1、我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。
• 2、小结：如何结束一个循环结构？
  • 结束情况1：循环结构中的循环条件部分返回false
  • 结束情况2：循环结构中执行了break。
• 3、如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环

3.2 while循环

3.2.1 基本语法

语法格式：
①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
}
执行过程：①-②-③-④-②-③-④-②-③-④-…-②

图示：

说明：

• while(循环条件)中循环条件必须是boolean类型。
• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
• for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。
• for循环与while循环的区别：初始化条件部分的作用域不同。

3.2.2 应用举例

需求1：遍历50次hello world
需求2：遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）

public class WhileTest {
    public static void main(String[] args) {

        //需求1：遍历50次hello world
        int i = 1;
        while (i <= 50){
            System.out.println("hello world!!");
            i++;
        }

        //需求2：遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）
        int j = 1;

        int count = 0;//记录偶数的个数
        int sum = 0; //记录偶数的总和

        while (j <= 100){
            if (j % 2 == 0){
                System.out.println(j);
                count++;
                sum += j;
            }
            j++;
        }
        System.out.println("偶数的个数为：" + count);
        System.out.println("偶数的总和为：" + sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

案例3：猜数字游戏
随机生成一个100以内的数，猜这个随机数是多少？

从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。

提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.random() * (b - a + 1) + a)

import java.util.Scanner;

public class WhileTest1 {
    public static void main(String[] args) {

        //1、生成一个[1,100]范围的随机整数
        int random = (int) (Math.random() * 100) + 1;

        //2、使用scanner，从键盘获取数据
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入1-100范围内的一个整数：");
        int guess = scan.nextInt();

        //3、声明一个变量，记录猜的次数
        int guessCount = 1;

        //3、使用循环结构，进行多次循环的对比和获取数据
        while (random != guess){

            if (guess > random){
                System.out.println("你输入的数据大了");
            }else if (guess < random){
                System.out.println("你输入的数据小了");
            }
            System.out.println("请输入1-100范围内的一个整数：");
            guess = scan.nextInt();
            guessCount++;
        }

        System.out.println("恭喜你！猜对了");
        System.out.println("共猜了" + guessCount + "次");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

案例4：折纸珠穆朗玛峰
世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

public class WhileTest2 {

    public static void main(String[] args) {

        //1、声明珠峰的高度，纸的默认厚度
        double paper = 0.1; //单位：毫米
        double zf = 8848860; //单位：毫米

        //2、定义一个变量，记录折纸的次数
        int count = 0;

        //3、通过循环结构，不断调整纸的厚度（当纸的厚度超过珠峰高度时，停止循环）
        while (paper <= zf){
            paper *= 2;
            count++;
        }
        System.out.println("paper的高度为：" + (paper / 1000) + ",超过了珠峰的高度" + (zf / 1000));
        System.out.println("共折纸" + count + "次");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.3 do-while循环

3.3.1 基本语法

语法格式：
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
**执行过程：**①-③-④-②-③-④-②-③-④-…-②
图示：

说明：

• 结尾while(循环条件)中循环条件必须是boolean类型
• do{}while();最后有一个分号
• do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
• 循环的三个结构for、while、do-while三者是可以相互转换的。

3.3.2 应用举例

案例1：
遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）

public class DoWhileTest {
    public static void main(String[] args) {

        //需求1：遍历1-100的偶数，并计算所有偶数的和、偶数的个数
        int i = 1;
        int count = 0;  //记录偶数的个数
        int sum = 0;    //记录偶数的总和
        do {
            if (i % 2 == 0){
                System.out.println(i);
                count++;
                sum += i;
            }
            i++;
        }while (i <= 100);
        System.out.println("偶数的个数为：" + count);
        System.out.println("偶数的总和为：" + sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

案例2：体会do-while至少会执行一次循环体

class DoWhileTest2 {
	public static void main(String[] args) {
        //while循环:
		int num1 = 10;
		while(num1 > 10){
			System.out.println("hello:while");
			num1--;
		}

		//do-while循环:
		int num2 = 10;
		do{
			System.out.println("hello:do-while");
			num2--;
		}while(num2 > 10);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

案例3：ATM取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。

=ATM
1、存款
2、取款
3、显示余额
4、退出
请选择(1-4)：

import java.util.Scanner;

public class DoWhileTest1 {
    public static void main(String[] args) {
        //1、定义一个变量，记录银行账户余额
        double balance = 0.0;

        boolean flag = true; //控制循环的结束

        Scanner input = new Scanner(System.in); //实例化scanner

        do {
            //2、声明ATM收款界面
            System.out.println("=========ATM========");
            System.out.println("1、存款" );
            System.out.println("2、取款" );
            System.out.println("3、显示余额" );
            System.out.println("4、退出" );
            System.out.println("请选择(1-4)：");

            //3、使用scanner获取用户的选择
            int selection = input.nextInt();

            switch (selection){
                //4、根据用户的选择，决定执行存款、取款、显示余额、退出的操作
                case 1:
                    System.out.println("请输入存款的金额：");
                    double money1 = input.nextDouble();
                    if (money1 > 0){
                        balance += money1;
                    }
                    break;
                case 2:
                    System.out.println("请输入取款的金额：");
                    double money2 = input.nextDouble();
                    if (money2 > 0 && money2 <= balance){
                        balance -= money2;
                    }else {
                        System.out.println("输入的数据有误或余额不足");
                    }
                    break;
                case 3:
                    System.out.println("显示金额为：" + balance);
                    break;
                case 4:
                    flag = false;
                    System.out.println("感谢使用，欢迎下次光临");
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }while (flag);

        //关闭资源
        input.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

3.4 对比三种循环结构

三种循环结构都具有四个要素：

• 循环变量的初始化条件
• 循环条件
• 循环体语句块
• 循环变量的修改的迭代表达式

从循环次数角度分析

• do-while循环至少执行一次循环体语句。
• for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。

如何选择

• 遍历有明显的循环次数（范围）的需求，选择for循环
• 遍历没有明显的循环次数（范围）的需求，选择while循环
• 如果循环体语句块至少执行一次，可以考虑使用do-while循环
• 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

3.5 "无限"循环

3.5.1 基本语法

语法格式：

• 最简单"无限"循环格式：while(true) , for(;
  声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/422162