尚硅谷Java入门视频教程第二章——Java基本语法
尚硅谷Java入门视频教程第二章
- 第一章复习
-
- 课后习题
- Java语言概述
- 第2章：Java基本语法
-
- 2.1 关键字和保留字
- 2.2 标识符(Identifier)
- 2.3 变量
-
- 2.3.1 变量基本概念
- 2.3.2 变量分类——按数据类型
-
- 1. 整数类型：byte \ short \ int \ long
- 2. 浮点类型：float \ double
- 3. 字符类型：char
- 4. 布尔类型：boolean
- 引用数据类型——String
- 2.3.3 基本数据类型之间的运算规则
- 2.3.4 变量之进制
- 2.4 运算符
-
- 2.4.1 算术运算符
- 2.4.2 赋值运算符
- 4.2.3 比较运算符
- 4.2.4 逻辑运算符
- 2.4.5 位运算符
- 2.4.6 三元运算符
- 运算符优先级
- 2.5 程序流程控制
-
- 2.5.1 顺序结构
- 2.5.2 分支语句1：if-else结构
-
- java随机数生成
- 2.5.3 分支语句2：switch-case结构
- 2.5.4 循环结构1：for循环
- 2.5.5 循环结构2：while循环
- 2.5.6 循环结构3：do-while循环
- 2.5.7 嵌套循环(多重循环)
- 2.5.8 特殊关键字的使用：break、continue
- 项目一：家庭收支记账软件
第一章复习
课后习题
- JDK,JRE和JVM的关系是什么？
JDK = JRE + 开发工具集（例如Javac编译工具等）
JRE = JVM + Java SE标准类库 - 为什么要配置path环境变量？如何配置？
配置path环境变量原因：为了在各个路径下都可以调用java相关指令
配置方法：计算机->属性->高级系统设置->环境变量->新建系统变量->变量名（JAVA_HOME），值（jdk安装路径，bin的上一级）->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定 - 常用的Windows命令行操作有哪些？
cd：切换路径、md：创建文件夹、rd：删除文件夹、del：删除文件等 - 创建如下类，使得运行可以产生如下输出：
新建java文件：ChairMan.java
public class ChairMan{
public static void main(String[] args){
System.out.println("姓名：主席");
System.out.println();
System.out.println("性别：男");
System.out.println("家庭住址：北京");
}
}
- 编译和运行上述代码的指令
-
先切换到文件所在目录
-
编译：编译是发生的错误一般为语法错误
javac ChairMan.java
出现错误：ChairMan.java:3: 错误: 编码GBK的不可映射字符
问题解决：编译时增加编码选项
javac -encoding utf-8 ChairMan.java -
运行：运行时出错一般是运行时问题
java ChairMan
Java语言概述
-
基础知识：
- 软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为：系统软件和应用软件。
系统软件：windows、mac os、linux、android、ios…
应用软件：word、ppt…
人机交互方式：图形化界面 vs 命令行方式
应用程序 = 算法 + 数据结构 - 常用DOS命令：cd：切换路径、md：创建文件夹、rd：删除文件夹、del：删除文件等
- 计算机语言的发展迭代史
第一代：机器语言
第二代：汇编语言
第三代：高级语言-面向过程与面向对象 - Java语言版本迭代（重要时间节点）
1996年，发布JDK 1.0
1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本 - Java语言应用领域：
Java Web开发：后台开发
大数据开发
Android应用程序开发：客户端开发 - Java语言特点
面向对象：两个基本概念（类、对象），三大特性（封装、继承、多态）
健壮性：①去除了c语言中的指针，② 自动垃圾回收机制（仍然会出现内存溢出、内存泄露）
跨平台性：Write once , Run Anywhere——JVM
- 软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为：系统软件和应用软件。
-
开发环境搭建
- JDK,JRE和JVM的关系是什么？
JDK = JRE + 开发工具集（例如Javac编译工具等）
JRE = JVM + Java SE标准类库 - JDK下载、安装
下载：官网
安装：注意问题：安装软件的路径中不能包含中文、空格 - 为什么要配置path环境变量？如何配置？
配置path环境变量原因：为了在各个路径下都可以调用java相关指令
配置方法：计算机->属性->高级系统设置->环境变量->新建系统变量->变量名（JAVA_HOME），值（jdk安装路径，bin的上一级）->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定
- JDK,JRE和JVM的关系是什么？
-
第一个Java程序
步骤：
将 Java 代码编写到扩展名为 .java 的文件中；
通过 javac 命令对该 java 文件进行编译javac ChairMan.java；
通过 java 命令对生成的 class 文件进行运行java ChairMan。
-
注释与API文档
- 注释：Comment
分类：
单行注释：//
多行注释：/* */
文档注释 (java特有)：/** */
特点：
对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行；
多行注释里面不允许有多行注释嵌套；
文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。 - Java API文档
API （Application Programming Interface,应用程序编程接口）是 Java 提供的基本编程接口。习惯上将语言提供的类库都称为API。
API文档：针对于类库如何使用的说明书 - 良好的编程风格
- 注释：Comment
-
常用Java开发工具
- 文本编辑工具：
记事本、UltraEdit、 EditPlus、TextPad、 NotePad - Java集成开发环境（IDE)：
JBuilder、NetBeans、Eclipse、MyEclipse、IntelliJ IDEA
- 文本编辑工具：
第2章：Java基本语法
2.1 关键字和保留字
- 关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串
特点：关键字中所有字母都为小写
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
- Java保留字：
现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字，如goto 、const等
2.2 标识符(Identifier)
-
标识符：
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧：凡是自己可以起名字的地方都叫标识符。 -
定义合法标识符规则: 不遵守，编译失败
- 由26个英文字母大小写，0-9 ，_或 $ 组成；
- 数字不可以开头；
- 不可以使用关键字和保留字，但能包含关键字和保留字；
- Java中严格区分大小写，长度无限制；
- 标识符不能包含空格。
-
Java中的名称命名规范：不遵守，编译可以通过，但建议遵守
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz(大坨峰)
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz(小坨峰)
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
2.3 变量
2.3.1 变量基本概念
- 变量的概念：
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值 - 变量的作用：用于在内存中保存数据
- 使用变量注意：
- Java中每个变量必须先声明，再赋值，后使用
编译错误① ：使用前未定义
class VaribleTest{
public static void main(String[] args){
//编译错误:使用前myNumber未定义
System.out.println(myNumber);
//变量的声明
int myNumber;
//变量的赋值
myNumber = 1001;
//变量的使用
System.out.println(myNumber);
}
}
编译错误② ：使用前仅声明，未赋值
class VaribleTest{
public static void main(String[] args){
//变量的声明
int myNumber;
//编译错误:使用myNumber前仅声明，未赋值
System.out.println(myNumber);
//变量的赋值
myNumber = 1001;
//变量的使用
System.out.println(myNumber);
}
}
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对{ }内
- 变量只有在其作用域内才有效；出作用域，变量失效。
- 同一个作用域内，不能定义重名的变量
2.3.2 变量分类——按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。
-
变量按照数据类型划分：
- 基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean - 引用数据类型：（后续补充）
类：class
接口：interface
数组：array
- 基本数据类型：
-
变量在类中声明的位置（后续补充）
成员变量 vs 局部变量
1. 整数类型：byte \ short \ int \ long
1. Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
2. java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’(输出结果中不带L/l)
3. java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
class VaribleTest1{
public static void main(String[] args){
//1. 整型：byte(1字节 = 8bit) \ short(2字节) \ int(4字节) \ long(8字节)
//① byte范围：-128 ~ 127
byte b1 = 12;
byte b2 = -128;
//b2 = 128;//编译不通过
System.out.println(b1);
System.out.println(b2);
// ② 声明long型变量，必须以"l"或"L"结尾
// ③ 通常，定义整型变量时，使用int型。
short s1 = 128;
int i1 = 1234;
long l1 = 3414234324L;
System.out.println(l1);
}
}
2. 浮点类型：float \ double
- 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
（float表示的数值范围比long还大——float有指数位） - 浮点型常量有两种表示形式：
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 512E2 100E-2 - float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。 - Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
class VaribleTest1{
public static void main(String[] args){
// 2. 浮点型：float(4字节) \ double(8字节)
// ① 浮点型，表示带小数点的数值
// ② float表示的数值范围比long还大
double d1 = 123.3;
System.out.println(d1+1);
// ③ 定义float类型变量时，变量要以“f”或“F”结尾
//float f1 = 12.3;//编译不通过
float f1 = 12.3F;
System.out.println(f1);
// ④ 通常，定义浮点型变量时，使用double型
}
}
3. 字符类型：char
- char 型数据用来表示通常意义上“字符”(2字节)
- Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
- 字符型变量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n’表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。 - char类型是可以进行运算的。因为它都对应有Unicode码
class VaribleTest1{
public static void main(String[] args){
// 3. 字符型： char(1字符=2字节)
// ① 定义char型变量，通常使用一对'',内部只能写一个字符
char c1 = 'a';
//c1 = 'AB';//编译不通过
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = 'ス';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
char c5 = '\n';//换行符
c5 = '\t';//制表符
System.out.print("hello" + c5);
System.out.println("world");
char c6 = '\u0043';
System.out.println(c6);
}
}
- 编码方式：字符与计算机内部的表示的对应方式
ASCII 码 -> Unicode 编码 -> UTF-8
class ReviewTest{
public static void main(String[] args){
char c1 = 'a';
char c2 = 97;//开发中非常少见，将其认为ASCII码，输出为ACSII码对应的字符
System.out.println(c2);//a
char c3 = 5;//ASCII码
char c4 = '5';//字符‘5’
int i1 = (int)c4;//将字符对应的ASCII妈转换为int型
System.out.println(i1);//53
}
}
4. 布尔类型：boolean
- boolean 类型用来判断逻辑条件，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句； - boolean类型数据只允许取值true和false，无null
不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。———《java虚拟机规范 8版》
class VaribleTest1{
public static void main(String[] args){
//4.布尔型：boolean
//① 只能取两个值之一：true 、 false
//② 常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if(isMarried){
System.out.println("你就不能参加\"单身\"party了！\\n 很遗憾");
//System.out.println("你就不能参加"单身"party了！\\n 很遗憾");//编译错误
}else{
System.out.println("你可以多谈谈女朋友！");
}
}
}
引用数据类型——String
- String不是基本数据类型，属于引用数据类型，翻译为：字符串
- 使用方式与基本数据类型一致。声明String类型变量时，使用一对""，例如：String str = “abcd”
- String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+，运算的结果仍然是String类型
/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型
*/
class StringTest {
public static void main(String[] args) {
String s1 = "Hello World!";
System.out.println(s1);
String s2 = "a";
String s3 = "";
//char c = '';//编译不通过
//***********************
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;// +：连接运算
boolean b1 = true;
String info1 = info + b1;// +：连接运算
System.out.println(info1);
//***********************
//练习1
char c = 'a';//97 A:65
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//练习2
//* *
System.out.println("* *");//* *
System.out.println('*' + '\t' + '*');//93 //char+char+char ASCII码加法
System.out.println('*' + "\t" + '*');//* * //char+str+char 连接运算
System.out.println('*' + '\t' + "*");//51* //char+char+str ASCII码加法+连接运算
System.out.println('*' + ('\t' + "*"));//* * //char+(str+char)=char+str 连接运算
//***********************
//String str1 = 123;//编译不通过
String str1 = 123 + "";
System.out.println(str1);//"123"
//int num1 = str1;//编译不通过
//int num1 = (int)str1;//"123"//编译不通过
int num1 = Integer.parseInt(str1);
System.out.println(num1);//123
}
}
2.3.3 基本数据类型之间的运算规则
前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
boolean类型不能与其它数据类型运算。
- 自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
class VariableTest2 {
public static void main(String[] args) {
byte b1 = 2;
int i1 = 129;
//编译不通过
//byte b2 = b1 + i1;
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);
float f = b1 + i1;
System.out.println(f);
short s1 = 123;
double d1 = s1;
System.out.println(d1);//123.0
//***************特别地*********************
char c1 = 'a';//97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4);
short s2 = 10;
//char c2 = c1 + s2;//编译不通过
byte b2 = 10;
//char c3 = c1 + b2;//编译不通过
//short s3 = b2 + s2;//编译不通过
//short s4 = b1 + b2;//编译不通过
//****************************************
}
}
- 强制类型转换：自动类型提升运算的逆运算。
需要使用强转符：()
注意点：强制类型转换，可能导致精度损失。
class VariableTest3 {
public static void main(String[] args) {
double d1 = 12.9;
//精度损失举例1
int i1 = (int)d1;//截断操作
System.out.println(i1);//12
//没有精度损失
long l1 = 123L;
short s2 = (short)l1;
//精度损失举例2
int i2 = 128;
byte b = (byte)i2;
System.out.println(b);//-128
}
}
- 变量运算规则两个特殊情况：
① 使用long声明变量有时候不加L也可以通过编译，是因为java会默认将其转换为int类型，但当不加L且超过int的表示范围时，仍然会报错。
float类型必须加F，不加一定会报错。
② 整型常量，默认类型为int型；浮点型常量，默认类型为double型。因此在定义变量接受运算结果时，应采用int/double。
class VariableTest4 {
public static void main(String[] args) {
//1.编码情况1：
long l = 123213;
System.out.println(l);
//编译失败：过大的整数
//long l1 = 21332423235234123;
long l1 = 21332423235234123L;
//****************
//编译失败
//float f1 = 12.3;
float f1 = (float)12.3;
//2.编码情况2：
//整型常量，默认类型为int型
//浮点型常量，默认类型为double型
byte b = 12;
//byte b1 = b + 1;//编译失败
//float f1 = b + 12.3;//编译失败
}
}
2.3.4 变量之进制
- 所有数字在计算机底层都以二进制形式存在。 对于整数，有四种表示方式：
- 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
- 十进制(decimal)：0-9 ，满10进1。
- 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
- 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0
- 二进制：
-
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位
-
二进制的整数有如下三种形式：
原码：直接将一个数值换成二进制数。最高位是符号位
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
负数的补码：其反码加1。 -
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码+1
特殊补码：
int型的128（0000 0000 0000 0000 0000 0000 1000 0000）强制转换为byte型时会变成-128（1000 0000）。
由于int型最高位符号位（0000 0000 0000 0000 0000 0000 1000 000）丢失，只保留了数值位，但转换为byte型后，保留的数值位的最高位变成了符号位（1000 0000），因此变为了-128。 -
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
-
2.4 运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 包括算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符。
2.4.1 算术运算符
注意点：
- (前)++ :先自增1，后运算
(后)++ :先运算，后自增1 - (前)-- :先自减1，后运算
(后)-- :先运算，后自减1 - 连接符： + ：只能使用在String与其他数据类型之间使用。
/*
运算符之一：算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {
public static void main(String[] args){
//除号： /
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//2
int result2 = num1 / num2 * num2;
System.out.println(result2);//10
double result3 = num1 / num2;
System.out.println(result3);//2.0
double result4 = num1 / num2 + 0.0;//2.0
double result5 = num1 / (num2 + 0.0);//2.4
double result6 = (double)num1 / num2;//2.4
double result7 = (double)(num1 / num2);//2.0
System.out.println(result4);
System.out.println(result5);
System.out.println(result6);
System.out.println(result7);
//%:取余运算
//结果的符号与被模数的符号相同
//开发中，尝使用%来判断能否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);//2
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);//-2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);//2
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);//-2
//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);//11, 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);//11, 10
int a3 = 10;
++a3;//a3++;
int b3 = a3;
//注意点：
short s1 = 10;
//s1 = s1 + 1;//编译失败
//s1 = (short)(s1 + 1);//正确的
s1++;//自增1不会改变本身变量的数据类型
System.out.println(s1);
//问题：
byte bb1 =127;
bb1++;
System.out.println("bb1 = " + bb1);//-128
//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
int a4 = 10;
int b4 = --a4;
System.out.println("a4 = " + a4 + ", b4 = " + b4);//9, 9
int a5 = 10;
int b5 = a5--;
System.out.println("a5 = " + a5 + ", b5 = " + b5);//9, 10
}
}
练习题：
随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。
class AriExer {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;//int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为：" + bai);
System.out.println("十位为：" + shi);
System.out.println("个位为：" + ge);
}
}
2.4.2 赋值运算符
-
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值。 -
扩展赋值运算符： +=, -=, *=, /=, %=
-
运算的结果不改变数据类型
-
开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 2;
方式二：num += 2; (推荐) -
开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 1;
方式二：num += 1;
方式三：num++; (推荐)
/*
运算符之二：赋值运算符
= += -= *= /= %=
*/
class SetValueTest {
public static void main(String[] args) {
//赋值符号：=
int i1 = 10;
int j1 = 10;
int i2,j2;
//连续赋值
i2 = j2 = 10;
int i3 = 10,j3 = 20;
//*********************
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);//2
short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//结论：不会改变变量本身的数据类型
System.out.println(s1);
//开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
//方式一：num = num + 2;
//方式二：num += 2; (推荐)
//开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
//方式一：num = num + 1;
//方式二：num += 1;
//方式三：num++; (推荐)
//练习1
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1
//练习2
int m = 2;
int n = 3;
n *= m++; //n = n * m++;//先运算，后+1
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
//练习3
int n1 = 10;
n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
System.out.println(n1);//32
}
}
4.2.3 比较运算符
- 比较运算符的结果是boolean类型
- 区分 == 和 =
- > \ < \ >= \ <= ：只能使用在数值类型的数据之间
- ==：不仅可以使用在数值类型的数据之间，还可以使用在其他引用类型变量之间。
/*
运算符之三：比较运算符
== != > < >= <= instanceof
结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =
*/
class CompareTest {
public static void main(String[] args) {
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1);//true
}
}
4.2.4 逻辑运算符
- 逻辑运算符操作的都是boolean类型的变量，得到的结果也是boolean类型。
- 区分& 与 &&
相同点1：& 与 && 的运算结果相同
相同点2：当符号左边是true时，二者都会执行符号右边的运算
不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
开发中，推荐使用&& - 区分：| 与 ||
相同点1：| 与 || 的运算结果相同
相同点2：当符号左边是false时，二者都会执行符号右边的运算
不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
开发中，推荐使用||
/*
运算符之四：逻辑运算符
& && | || ! ^
说明：
1.逻辑运算符操作的都是boolean类型的变量
*/
class LogicTest {
public static void main(String[] args) {
//区分& 与 &&
//相同点1：& 与 && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是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：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中，推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);
boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);
}
}
练习1：
练习2：
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
//if(y == true)
if((z++ == 42)&&(y = true))z++;//((先比较，后增1 -> T,z：43)&&(赋值语句:与= true -> T)) - > T -> z：44
if((x = false) || (++z == 45)) z++;//((F)||(先增1，再比较 -> z:45, T)) -> T -> z: 46
System.out.println("z = " + z);//46
}
}
2.4.5 位运算符
- 位运算符操作的都是整型的数据
- << ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
面试题：最高效方式的计算2 * 8 ？
2 << 3 或 8 << 1 - 没有<<<
- 细节问题：
/*
运算符之五：位运算符 （了解）
结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1
*/
class BitTest {
public static void main(String[] args) {
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
//方式一：定义临时变量的方式
//推荐的方式
int temp = num1;
num1 = num2;
num2 = temp;
//方式二：好处：不用定义临时变量
//弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
//num1 = num1 + num2;
//num2 = num1 - num2;
//num1 = num1 - num2;
//方式三：使用位运算符
//有局限性：只能适用于数值类型
//num1 = num1 ^ num2;
//num2 = num1 ^ num2;
//num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
- 例题1：如何求一个0-255范围内的整数的十六进制值。如：60的十六进制形式为3C
/*
如何求一个0-255范围内的整数的十六进制值。如：60的十六进制形式为3C
*/
class BitTest2{
public static void main(String[] args) {
int i1 = 60;
int i2 = i1 & 15;//15的二进制只有最低四位为1111，因此按位相与后只保留i1的最低四位的值
String j = (i2>9)?(char)(i2-10+'A')+"":i2+"";//+""是将结果变成字符串，防止字符之间进行运算
int temp = i1 >>> 4;
i2 = temp & 15;
String k = (i2>9)?(char)(i2-10+'A')+"":i2+"";
System.out.println(k+""+j);
}
}
2.4.6 三元运算符
- 格式: (条件表达式)? 表达式1 : 表达式2
- 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的(可以用同种类型接收 )。
④ 三元运算符可以嵌套使用 - 凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。 - 三元运算符与if-else的联系与区别：
1）三元运算符可简化if-else语句
2）三元运算符要求必须返回一个结果。
3）if后的代码块可有多个语句 - 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
- 说明
/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用
3.
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
class SanYuanTest {
public static void main(String[] args) {
//获取两个整数的较大值
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max);
double num = (m > n)? 2 : 1.0;
//(m > n)? 2 : "n大";//编译错误
//**************************
n = 12;
String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
System.out.println(maxStr);
//*****************************
//获取三个数的最大值
int n1 = 12;
int n2 = 30;
int n3 = -43;
int max1 = (n1 > n2)? n1 : n2;
int max2 = (max1 > n3)? max1 : n3;
System.out.println("三个数中的最大值为：" + max2);
//不建议
//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
//System.out.println("三个数中的最大值为：" + max3);
//该写成if-else:
if(m > n){
System.out.println(m);
}else{
System.out.println(n);
}
}
}
运算符优先级
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
2.5 程序流程控制
- 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
- 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
- 顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。 - 分支结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。 - 循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
- 顺序结构
2.5.1 顺序结构
Java中定义成员变量时采用合法的前向引用。如：
2.5.2 分支语句1：if-else结构
- if-else的三种情况：
-
一分支执行，一分支不执行
-
两分支二选一
-
多选一
-
/*
分支结构中的if-else（条件判断结构）
一、三种结构
第一种：
if(条件表达式){
执行表达式
}
第二种：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
第三种：n选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
...
else{
执行表达式n
}
*/
class IfTest {
public static void main(String[] args) {
//举例1
int heartBeats = 79;
if(heartBeats < 60 || heartBeats > 100){
System.out.println("需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age < 18){
System.out.println("你还未成年");
}else{
System.out.println("你已经成年了");
}
//举例3
if(age < 0){
System.out.println("您输入的数据非法");
}else if(age < 18){
System.out.println("青少年时期");
}else if(age < 35){
System.out.println("青壮年时期");
}else if(age < 60){
System.out.println("中年时期");
}else if(age < 120){
System.out.println("老年时期");
}else{
System.out.println("你是要成仙啊~~");
}
}
}
- Scanner的使用：
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：- 导包：import java.util.Scanner;
- Scanner的实例化:Scanner scan = new Scanner(System.in);
- 调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
//1.导包：import java.util.Scanner;
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//2.Scanner的实例化
Scanner scan = new Scanner(System.in);
//3.调用Scanner类的相关方法
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄：");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否相中我了呢？(true/false)");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
System.out.println("请输入你的性别：(男/女)");
String gender = scan.next();//"男"
char genderChar = gender.charAt(0);//获取索引为0位置上的字符
System.out.println(genderChar);
}
}
注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException,导致程序终止。
- If-else练习题
1.岳小鹏参加Java考试，他和父亲岳不群达成承诺，如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断。
/*
说明：
1. else 结构是可选的。
2. 针对于条件表达式：
> 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
> 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
> 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/
import java.util.Scanner;
class IfTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入岳小鹏期末成绩：(0-100)");
int score = scan.nextInt();
if(score == 100){
System.out.println("奖励一辆BMW");
}else if(score > 80 && score <= 99){
System.out.println("奖励一台iphone xs max");
}else if(score >= 60 && score <= 80){
System.out.println("奖励一个 iPad");
}else{
System.out.println("什么奖励也没有");
}
}
}
- 编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出。
/*
说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
import java.util.Scanner;
class IfTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scan.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(num1 + "<" + num2 + "<" + num3);
else if (num3 <= num1)
System.out.println(num3 + "<" + num1 + "<" + num2);
else
System.out.println(num1 + "<" + num3 + "<" + num2);
}
}
}
- 练习：判断输出结果
①输出atguigu
②输出 x is 4
③ b ==false:b
b=false:c
java随机数生成
如何获取一个随机数：10-99
(int)(Math.random() * 90 + 10)//[0.0, 1.0) -> [0.0, 90.0) -> [10.0,100.0) -> [10, 99]
公式[a, b]：
(int)(Math.random * (b - a + 1) + a)
2.5.3 分支语句2：switch-case结构
- 格式
- 说明：
- 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。 - break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
- switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增) - case 之后只能声明常量，不能声明范围。
- break关键字是可选的。
- default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
- 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
class SwitchCaseTest {
public static void main(String[] args) {
int number = 5;
switch(number){
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;
}
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;
}
//**************如下的两种情况都编译不通过*********************
//情况一: switch表达式不可以为boolean类型
/*
boolean isHandsome = true;
switch(isHandsome){
case true:
System.out.println("我好帅啊~~~");
break;
case false:
System.out.println("我好丑啊~~~");
break;
default:
System.out.println("输入有误~~~");
}
*/
//情况二：case常量不可以为表达式
/*
int age = 10;
switch(age){
case age > 18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
*/
}
}
- 例题
- 对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
class SwitchCaseTest1 {
public static void main(String[] args) {
/*
int score = 78;
switch(score){
case 0:
case 1:
case 2:
...
case 100:
}
*/
/*
int score = 78;
if(score >= 60){
}else{
}
*/
int score = 78;
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;
}
//更优的解决方案：
switch(score / 60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}
}
}
- 编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。
/*
2 15: 31 + 15
5 7: 31 + 28 + 31 + 30 + 7
....
说明:break在switch-case中是可选的
*/
import java.util.Scanner;
class SwitchCaseTest2{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年的month：");
int month = scan.nextInt();
System.out.println("请输入2019年的day：");
int day = scan.nextInt();
//定义一个变量来存储总天数
int sumDays = 0;
switch(month){
case 12:
sumDays = 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
}
}
- 从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
/*
说明：
1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。
*/
import java.util.Scanner;
class SwitchCaseExer {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入year：");
int year = scan.nextInt();
System.out.println("请输入month：");
int month = scan.nextInt();
System.out.println("请输入day：");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumDays = 0;
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//sumDays += 28;
//判断year是否是闰年
if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
sumDays += 29;
}else{
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
}
}
2.5.4 循环结构1：for循环
- 循环结构：在某些条件满足的情况下，反复执行特定代码的功能
- 循环语句分类：
for 循环
while 循环
do-while 循环 - 循环语句的四个组成部分：
- 初始化部分(init_statement)
- 循环条件部分(test_exp) ：boolean类型
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
- for循环
- 语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分)｛
③循环体部分;
｝
- 执行过程：
①-②-③-④-②-③-④-②-③-④-…-②
- 说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、for循环的结构
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
*/
class ForTest {
public static void main(String[] args) {
/*
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!");
*/
for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
System.out.println("Hello World!");
}
//i:在for循环内有效。出了for循环就失效了。
//System.out.println(i);
//练习：
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b');
}
//输出结果：abcbcbc
System.out.println();
//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
//int sum;//编译错误，变量在使用之前必须先赋值
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
//System.out.println("总和为：" + sum);
}
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
- 例题
- 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”
class ForTest1 {
public static void main(String[] args) {
for(int i = 1;i <= 150;i++){
System.out.print(i + " ");
if(i % 3 == 0){
System.out.print("foo" + " ");
}
if(i % 5 == 0){
System.out.print("biz" + " ");
}
if(i % 7 == 0){
System.out.print("baz" + " ");
}
System.out.println();
}
}
}
- 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
/*
说明：break关键字的使用：一旦在循环中执行到break，就跳出循环
*/
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数（一定在1-较小数之间）
int min = (m <= n)? m : n;
for(int i = min;i >= 1;i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为：" + i);
break;
}
}
//获取最小公倍数（一定在较大数-m*n之间）
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;
}
}
}
}
2.5.5 循环结构2：while循环
- 语法格式
①初始化部分
while(②循环条件部分)｛
③循环体部分; ④迭代部分;
}
- 执行过程：
①-②-③-④-②-③-④-②-③-④-…-② - 说明：
- 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换
区别：for循环和while循环的初始化条件部分的作用范围不同。
/*
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
*/
class WhileTest{
public static void main(String[] args) {
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用。
System.out.println(i);//101
}
}
2.5.6 循环结构3：do-while循环
- 语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
- 执行过程：
①-③-④-②-③-④-②-③-④-…② - 说明：
do-while循环至少执行一次循环体。
/*
do-while循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、do-while循环结构：
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
*/
class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
//*************体会do-while至少执行一次循环体***************
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");
number2--;
}while(number2 > 10);
}
}
- 循环结构综合例题
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
/*
说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break
*/
import java.util.Scanner;
class ForWhileTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
for(;;){//while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break，跳出循环
break;
}
}
System.out.println("输入的正数个数为：" + positiveNumber);
System.out.println("输入的负数个数为：" + negativeNumber);
}
}
2.5.7 嵌套循环(多重循环)
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 假设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
外层循环控制行数，内层循环控制列数。 - 例题
- 打印如下的图形：菱形1
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
class ForForTest{
public static void main(String[] args){
for(int i = 1; i <= 5; i++){
for(int j = 1; j <= 5-i; j++){
System.out.print(" ");
}
for(int k = 1; k <= i; k++){
System.out.print("* ");
}
System.out.println();
}
for(int i = 1; i <= 4; i++){
for(int j = 1; j <= i; j++){
System.out.print(" ");
}
for(int k = 1; k <= 5 - i; k++){
System.out.print("* ");
}
System.out.println();
}
}
}
- 九九乘法表
/*
嵌套循环的应用1：
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
class NineNineTable {
public static void main(String[] args) {
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + i*j + " ");
}
System.out.println();
}
}
}
- 输出100以内所有的质数
/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数是：2
*/
class PrimeNumber{
public static void main(String[] args){
int flag;//设置标志位，判断是否为质数
int count = 0;
for(int i = 2;i <= 100;i++){
flag = 0;
for(int j = 2;j < i;j++){
if(i % j == 0){
flag = 1;//若能被其他数整除，则不是质数，改变标志位
break;//主要出现能被其他数整除的情况，就不是质数，不用继续判断
}
}
if(flag == 0){
System.out.println(i);
count++;
}
}
System.out.println("100以内的所有质数共有" + count +"个。");
}
}
优化：内部循环只需要比较到根号i即可（<=Math.sqrt(i)）
/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumber1 {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二：对本身是质数的自然数是有效的。
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的。
}
}
//
if(isFlag == true){
//System.out.println(i);
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
}
}
2.5.8 特殊关键字的使用：break、continue
- break 语句
break语句用于终止某个语句块的执行
{ ……
break;
……
}
-
continue 语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
-
break/continue语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;//continue label 2;
……
}
}
}
- break和continue关键字的使用异同
| 使用范围 | 循环中使用的作用(不同点) | 相同点 | |
|---|---|---|---|
| break | switch-case \ 循环结构中 | 结束当前循环 | 关键字后面不能声明执行语句 |
| continue | 循环结构中 | 结束当次循环 | 关键字后面不能声明执行语句 |
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
break;//123
//continue;//123567910
//System.out.println("今晚迪丽热巴要约我！！！");//编译错误
}
System.out.print(i);
}
System.out.println("\n");
//******************************
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环。
//continue;
//break label;//结束指定标识的一层循环结构//123
continue label;//结束指定标识的一层循环结构当次循环//123123123
}
System.out.print(j);
}
System.out.println();
}
}
}
- 求质数的另一种解法（用continue）
/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
public static void main(String[] args) {
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
continue label;
}
}
//能执行到此步骤的，都是质数
count++;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));
}
}
项目一：家庭收支记账软件
主函数：
class FamilyAccount{
public static void main(String[] args){
boolean isFlag = true;
String details = "收支\t账户金额\t收支金额\t说 明\n";
int balance = 1000;//记录当前账户总金额
while(isFlag){
System.out.println("-----------------家庭收支软件-----------------");
System.out.println(" 1 收支明细");
System.out.println(" 2 登记收入");
System.out.println(" 3 登记支出");
System.out.println(" 4 退 出");
System.out.println();
System.out.print(" 请选择(1-4):");
char selection = Utility.readMenuSelection();
switch(selection){
case '1':
//System.out.println("1 收支明细");
System.out.println("-----------------当前收支明细记录-----------------");
System.out.println(details);
System.out.println("--------------------------------------------------\n");
break;
case '2':
//System.out.println("2 登记收入");
//读取收入信息
System.out.print("本次收入金额:");
int income = Utility.readNumber();
System.out.print("本次收入说明:");
String incomeInfo = Utility.readString();
//更新账户信息
balance += income;
details += "收入\t" + balance + "\t\t" + income + "\t\t" + incomeInfo + "\n";
System.out.println("---------------------登记完成----------------------\n");
break;
case '3':
//System.out.println("3 登记支出");
//读取支出信息
System.out.print("本次支出金额:");
int expendture = Utility.readNumber();
System.out.print("本次支出说明:");
String expendtureInfo = Utility.readString();
if(expendture > balance){
System.out.println("支出超过账户总金额，支出失败！");
}else{
//更新账户信息
balance -= expendture;
details += "支出\t" + balance + "\t\t" + expendture + "\t\t" + expendtureInfo + "\n";
}
System.out.println("---------------------登记完成----------------------\n");
break;
case '4':
//System.out.println("4 退 出");
System.out.print("确认是否退出(Y/N):");
char isExit = Utility.readConfirmSelection();
if(isExit == 'Y'){
isFlag = false;
}
break;
}
}
}
}
工具类：
import java.util.Scanner;
/**
Utility工具类：
将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
*/
public class Utility {
private static Scanner scanner = new Scanner(System.in);
/**
用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1);
c = str.charAt(0);
if (c != '1' && c != '2' && c != '3' && c != '4') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。
*/
public static int readNumber() {
int n;
for (; ; ) {
String str = readKeyBoard(4);
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。
*/
public static String readString() {
String str = readKeyBoard(8);
return str;
}
/**
用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
*/
public static char readConfirmSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
private static String readKeyBoard(int limit) {
String line = "";
while (scanner.hasNext()) {
line = scanner.nextLine();
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}