第一章复习

课后习题

1. JDK,JRE和JVM的关系是什么？
   JDK = JRE + 开发工具集（例如Javac编译工具等）
   JRE = JVM + Java SE标准类库
2. 为什么要配置path环境变量？如何配置？
   配置path环境变量原因：为了在各个路径下都可以调用java相关指令
   配置方法：计算机->属性->高级系统设置->环境变量->新建系统变量->变量名（JAVA_HOME），值（jdk安装路径，bin的上一级）->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定
3. 常用的Windows命令行操作有哪些？
   cd：切换路径、md：创建文件夹、rd：删除文件夹、del：删除文件等
4. 创建如下类，使得运行可以产生如下输出：
   
   新建java文件：ChairMan.java

public class ChairMan{public static void main(String[] args){System.out.println("姓名：主席");System.out.println();System.out.println("性别：男");System.out.println("家庭住址：北京");}
}

1. 编译和运行上述代码的指令

• 先切换到文件所在目录

• 编译：编译是发生的错误一般为语法错误
  javac ChairMan.java
  出现错误：ChairMan.java:3: 错误: 编码GBK的不可映射字符
  
  问题解决：编译时增加编码选项
  javac -encoding utf-8 ChairMan.java

• 运行：运行时出错一般是运行时问题
  java ChairMan
  

Java语言概述

• 基础知识：

  1. 软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为：系统软件和应用软件。
     系统软件：windows、mac os、linux、android、ios…
     应用软件：word、ppt…
     人机交互方式：图形化界面 vs 命令行方式
     应用程序 = 算法 + 数据结构
  2. 常用DOS命令：cd：切换路径、md：创建文件夹、rd：删除文件夹、del：删除文件等
  3. 计算机语言的发展迭代史
     第一代：机器语言
     第二代：汇编语言
     第三代：高级语言-面向过程与面向对象
  4. 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以来变化最大的版本
  5. Java语言应用领域：
     Java Web开发：后台开发
     大数据开发
     Android应用程序开发：客户端开发
  6. Java语言特点
     面向对象：两个基本概念（类、对象），三大特性（封装、继承、多态）
     健壮性：①去除了c语言中的指针，② 自动垃圾回收机制（仍然会出现内存溢出、内存泄露）
     跨平台性：Write once , Run Anywhere——JVM

• 开发环境搭建

  1. JDK,JRE和JVM的关系是什么？
     
     JDK = JRE + 开发工具集（例如Javac编译工具等）
     JRE = JVM + Java SE标准类库
  2. JDK下载、安装
     下载：官网
     安装：注意问题：安装软件的路径中不能包含中文、空格
  3. 为什么要配置path环境变量？如何配置？
     配置path环境变量原因：为了在各个路径下都可以调用java相关指令
     配置方法：计算机->属性->高级系统设置->环境变量->新建系统变量->变量名（JAVA_HOME），值（jdk安装路径，bin的上一级）->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定

• 第一个Java程序
  步骤：
  将 Java 代码编写到扩展名为 .java 的文件中；
  通过 javac 命令对该 java 文件进行编译javac ChairMan.java；
  通过 java 命令对生成的 class 文件进行运行java ChairMan。
  

• 注释与API文档

  1. 注释：Comment
     分类：
     单行注释：//
     多行注释：/* */
     文档注释 (java特有)：/** */
     特点：
     对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行；
     多行注释里面不允许有多行注释嵌套；
     文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
  2. Java API文档
     API （Application Programming Interface,应用程序编程接口）是 Java 提供的基本编程接口。习惯上将语言提供的类库都称为API。
     API文档：针对于类库如何使用的说明书
  3. 良好的编程风格
     

• 常用Java开发工具

  1. 文本编辑工具：
     记事本、UltraEdit、 EditPlus、TextPad、 NotePad
  2. 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 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
  技巧：凡是自己可以起名字的地方都叫标识符。

• 定义合法标识符规则: 不遵守，编译失败

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

• Java中的名称命名规范：不遵守，编译可以通过，但建议遵守

  1. 包名：多单词组成时所有字母都小写：xxxyyyzzz
  2. 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz(大坨峰)
  3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz(小坨峰)
  4. 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

2.3 变量

2.3.1 变量基本概念

• 变量的概念：
  内存中的一个存储区域
  该区域的数据可以在同一类型范围内不断变化
  变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
• 变量的作用：用于在内存中保存数据
• 使用变量注意：

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);}
}

1. 使用变量名来访问这块区域的数据
2. 变量的作用域：其定义所在的一对{ }内
3. 变量只有在其作用域内才有效；出作用域，变量失效。
4. 同一个作用域内，不能定义重名的变量

2.3.2 变量分类——按数据类型

对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。

• 变量按照数据类型划分：

  1. 基本数据类型：
     整型：byte \ short \ int \ long
     浮点型：float \ double
     字符型：char
     布尔型：boolean
  2. 引用数据类型：（后续补充）
     类：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 ~ 127byte 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

1. 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
   （float表示的数值范围比long还大——float有指数位）
2. 浮点型常量有两种表示形式：
   十进制数形式：如：5.12 512.0f .512 (必须有小数点）
   科学计数法形式:如：5.12e2 512E2 100E-2
3. float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
   double:双精度，精度是float的两倍。通常采用此类型。
4. 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

1. char 型数据用来表示通常意义上“字符”(2字节)
2. Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
3. 字符型变量的三种表现形式：
   字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
   Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n’表示换行符
   直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
4. 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);}
}

1. 编码方式：字符与计算机内部的表示的对应方式
   ASCII 码 -> Unicode 编码 -> UTF-8

class ReviewTest{public static void main(String[] args){char c1 = 'a';char c2 = 97;//开发中非常少见，将其认为ASCII码，输出为ACSII码对应的字符System.out.println(c2);//achar c3 = 5;//ASCII码char c4 = '5';//字符‘5’int i1 = (int)c4;//将字符对应的ASCII妈转换为int型System.out.println(i1);//53}
}

4. 布尔类型：boolean

1. boolean 类型用来判断逻辑条件，一般用于程序流程控制：
   if条件控制语句；
   while循环控制语句；
   do-while循环控制语句；
   for循环控制语句；
2. 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

1. String不是基本数据类型，属于引用数据类型，翻译为：字符串
2. 使用方式与基本数据类型一致。声明String类型变量时，使用一对""，例如：String str = “abcd”
3. 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);//***********************//练习1char c = 'a';//97   A:65int num = 10;String str = "hello";System.out.println(c + num + str);//107helloSystem.out.println(c + str + num);//ahello10System.out.println(c + (num + str));//a10helloSystem.out.println((c + num) + str);//107helloSystem.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类型不能与其它数据类型运算。

1. 自动类型提升：
   结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
   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';//97int 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;//编译不通过//****************************************}
}

1. 强制类型转换：自动类型提升运算的逆运算。
   需要使用强转符：()
   注意点：强制类型转换，可能导致精度损失。

class VariableTest3 {public static void main(String[] args) {double d1 = 12.9;//精度损失举例1int i1 = (int)d1;//截断操作System.out.println(i1);//12//没有精度损失long l1 = 123L;short s2 = (short)l1;//精度损失举例2int i2 = 128;byte b = (byte)i2;System.out.println(b);//-128}
}

1. 变量运算规则两个特殊情况：
   ① 使用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 变量之进制

• 所有数字在计算机底层都以二进制形式存在。  对于整数，有四种表示方式：
  1. 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
  2. 十进制(decimal)：0-9 ，满10进1。
  3. 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
  4. 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0
• 二进制：

  1. Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

  2. 二进制的整数有如下三种形式：
     原码：直接将一个数值换成二进制数。最高位是符号位
     负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
     负数的补码：其反码加1。

  3. 计算机以二进制补码的形式保存所有的整数。
     正数的原码、反码、补码都相同
     负数的补码是其反码+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。

  4. 为什么要使用原码、反码、补码表示形式呢？
     计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
     

2.4 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 包括算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符。

2.4.1 算术运算符

注意点：

1. (前)++ :先自增1，后运算
   (后)++ :先运算，后自增1
2. (前)-- :先自减1，后运算
   (后)-- :先运算，后自减1
3. 连接符： + ：只能使用在String与其他数据类型之间使用。

/*
运算符之一：算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
class AriTest {public static void main(String[] args){//除号： /int num1 = 12;int num2 = 5;int result1 = num1 / num2;System.out.println(result1);//2int result2 = num1 / num2 * num2;System.out.println(result2);//10double result3 = num1 / num2;System.out.println(result3);//2.0double result4 = num1 / num2 + 0.0;//2.0double result5 = num1 / (num2 + 0.0);//2.4double result6 = (double)num1 / num2;//2.4double result7 = (double)(num1 / num2);//2.0System.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);//2int m2 = -12;int n2 = 5;System.out.println("m2 % n2 = " + m2 % n2);//-2int m3 = 12;int n3 = -5;System.out.println("m3 % n3 = " + m3 % n3);//2int m4 = -12;int n4 = -5;System.out.println("m4 % n4 = " + m4 % n4);//-2//(前)++ :先自增1，后运算//(后)++ :先运算，后自增1int a1 = 10;int b1 = ++a1;System.out.println("a1 = " + a1 + ",b1 = " + b1);//11, 11int a2 = 10;int b2 = a2++;System.out.println("a2 = " + a2 + ",b2 = " + b2);//11, 10int 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，后运算//(后)-- :先运算，后自减1int a4 = 10;int b4 = --a4;System.out.println("a4 = " + a4 + ", b4 = " + b4);//9, 9int 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);//12int 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++; (推荐)//练习1int i = 1;i *= 0.1;System.out.println(i);//0i++;System.out.println(i);//1//练习2int m = 2;int n = 3;n *= m++; //n = n * m++;//先运算，后+1   System.out.println("m=" + m);//3System.out.println("n=" + n);//6//练习3int 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);//falseSystem.out.println(i = j);//20boolean b1 = true;boolean b2 = false;System.out.println(b2 == b1);//falseSystem.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：44if((x = false) || (++z == 45)) z++;//((F)||(先增1，再比较 -> z:45, T)) -> T -> z: 46System.out.println("z = " + z);//46}
}

2.4.5 位运算符

1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2
   
   面试题：最高效方式的计算2 * 8 ？
   2 << 3 或 8 << 1
3. 没有<<<
4. 细节问题：

/*
运算符之五：位运算符 （了解）结论：
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
  
  1. 说明
     ① 条件表达式的结果为boolean类型
     ② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
     如果表达式为true，则执行表达式1。
     如果表达式为false，则执行表达式2。
     ③ 表达式1 和表达式2要求是一致的(可以用同种类型接收 )。
     ④ 三元运算符可以嵌套使用
  2. 凡是可以使用三元运算符的地方，都可以改写为if-else
     反之，不成立。
  3. 三元运算符与if-else的联系与区别：
     1）三元运算符可简化if-else语句
     2）三元运算符要求必须返回一个结果。
     3）if后的代码块可有多个语句
  4. 如果程序既可以使用三元运算符，又可以使用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 程序流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
  1. 顺序结构
     程序从上到下逐行地执行，中间没有任何判断和跳转。
  2. 分支结构
     根据条件，选择性地执行某段代码。
     有if…else和switch-case两种分支语句。
  3. 循环结构
     根据循环条件，重复性的执行某段代码。
     有while、do…while、for三种循环语句。
     注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

2.5.1 顺序结构

Java中定义成员变量时采用合法的前向引用。如：

2.5.2 分支语句1：if-else结构

• if-else的三种情况：

  1. 一分支执行，一分支不执行
     

  2. 两分支二选一
     

  3. 多选一
     

/*
分支结构中的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) {//举例1int heartBeats = 79;if(heartBeats < 60 || heartBeats > 100){System.out.println("需要做进一步检查");}System.out.println("检查结束");//举例2int age = 23;if(age < 18){System.out.println("你还未成年");}else{System.out.println("你已经成年了");}//举例3if(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类
  具体实现步骤：
  1. 导包：import java.util.Scanner;
  2. Scanner的实例化:Scanner scan = new Scanner(System.in);
  3. 调用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("什么奖励也没有");}}
}

1. 编写程序：由键盘输入三个整数分别存入变量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);elseSystem.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);elseSystem.out.println(num1 + "<" + num3 + "<" + num2);}}
}

1. 练习：判断输出结果
   ①输出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结构

• 格式
• 说明：
  1. 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
     当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
  2. break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
  3. switch结构中的表达式，只能是如下的6种数据类型之一：
     byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
  4. case 之后只能声明常量，不能声明范围。
  5. break关键字是可选的。
  6. default:相当于if-else结构中的else.
     default结构是可选的，而且位置是灵活的。

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("未成年");}*/}
}

• 例题

1. 对学生成绩大于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;}}
}

1. 编写程序：从键盘上输入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. 从键盘分别输入年、月、日，判断这一天是当年的第几天
   注：判断一年是否是闰年的标准：
   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 循环
• 循环语句的四个组成部分：
  1. 初始化部分(init_statement)
  2. 循环条件部分(test_exp) ：boolean类型
  3. 循环体部分(body_statement)
  4. 迭代部分(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,5System.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');}//输出结果：abcbcbcSystem.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. 编写程序从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();}}
}

1. 题目：输入两个正整数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(②循环条件部分)｛
③循环体部分; ④迭代部分;
}

• 执行过程：
  ①-②-③-④-②-③-④-②-③-④-…-②
• 说明：
  1. 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  2. 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. 打印如下的图形：菱形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 = 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();}}
}

1. 输出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++;}//重置isFlagisFlag = 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 语句

  1. continue只能使用在循环结构中
  2. continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
  3. 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;//结束指定标识的一层循环结构//123continue 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;}
}

尚硅谷Java入门视频教程第二章——Java基本语法相关推荐

1. 【JAVA SE】第二章 Java语法基础、数据类型、基本类型的字面值、基本类型的类型转换和运算规则

   第二章 Java语法基础.数据类型.基本类型的字面值.基本类型的类型转换.运算规则和标识符命名风格 文章目录 第二章 Java语法基础.数据类型.基本类型的字面值.基本类型的类型转换.运算规则和标识符 ...

2. 尚硅谷Java入门视频教程(在线答疑+Java面试真题)

   Java核心技术 一.Java基本语法 1.关键字与保留字 关键字的定义和特点 被Java语言赋予了特殊含义,用做专门用途的字符串(单词) 关键字中所有字母都为小写 保留字的定义 现有Java版本尚未 ...

3. java的学习--第二章 java流程控制

   1.本章内容 控制代码如何执行.是否执行.执行多少次. 2.程序结构 顺序结构 分支结构 循环结构 2.1分支结构 1.if(){} 2.if(){}else{} 3.if(){}else if(){ ...

4. 尚硅谷Java入门视频教程第三章——数组

   尚硅谷Java入门视频教程第三章 第二章复习 课后习题 复习 嵌套循环典型例题 Ecplise的安装使用 第3章:数组 3.1 数组的概述 3.2 一维数组的使用 3.3 多维数组的使用 3.4 数组 ...

5. 尚硅谷Java入门视频教程导读及第一章

   尚硅谷Java入门视频教程导读及第一章 JAVA基础学习导读-编程入门 0.1概述 0.2 计算机硬件介绍 中央处理器(CPU) 存储设备 内存 比特(bit)和字节(byte) 内存 输入和输出设备 ...

6. 尚硅谷Java入门视频教程第十七章——Java9Java10Java11新特性

   尚硅谷Java入门视频教程第十七章--Java9&Java10&Java11新特性 第17章:Java9&Java10&Java11新特性 17.1 Java 9 的新 ...

7. JavaSE入门0基础笔记 第二章Java基础语法

   JavaSE入门0基础笔记 第二章Java基础语法 1.运算符 1.1算术运算符 1.1.1运算符和表达式 1.1.2 算术运算符 1.1.3字符的"+"操作 1.1.4 字符串中 ...

8. 语言求余和乘除优先级_愉快地学Java语言：第二章基本程序设计 第2讲

   导读 本文适合Java入门,不太适合Java中高级软件工程师. 本文以<Java程序设计基础篇>第10版为蓝本,采用不断提出问题,然后解答问题的方式来讲述. 本篇文章只是这个系列中的一篇, ...

9. （Java零基础学习笔记）第二章 Java中的基本语法

   前言: 大家好! 我是BA unravel .如果你想和我一起学习JAVA,欢迎大家一起来学习这个世界上最好的语言! 学习目标: 一周掌握 Java 入门知识 学习内容: 1. 搭建 Java 开发环 ...

最新文章

1. 白噪音和粉红噪音煲机_白噪音真的有助于睡眠？这款可以自定义的应用给你答案...
2. java几个easy出错的小程序
3. 1.2 偏差/方差-深度学习第二课《改善深层神经网络》-Stanford吴恩达教授
4. VTK：PolyData之IntersectionPolyDataFilter
5. Openpose推断阶段原理
6. php类的举例,用类来代替递归方法，用php举例_php _ 搞代码
7. php带参数跳转页面,如何带参数跳转php界面_后端开发
8. 《交互式程序设计 第2版》一2.2 代码的本质
9. windows安装python3_windows下同时安装python2和python3
10. 基于ftp4j的FTP客户端工具
11. 【4】基于深度神经网络的脑电睡眠分期方法研究（训练模型）
12. dell加装固态硬盘_戴尔（dell）计算机nvme固态硬盘安装win10系统和分区教程
13. 用于屏幕对比图片jevin
14. 网络互联设备：中继器、交换机、网桥、路由器和网关
15. The following packages have unmet dependencies: build-essential : Depends: libc6-dev but it is not
16. Parameter Attribute
17. 通过cmd窗口导入导出mysql数据库
18. TOOLS——SecureCRT8.5的下载、安装、注册、连接、用到的配置以及可能遇到的错误、常用快捷键
19. th_TH是什么意思？
20. matlab中leg的用法,leg_leg的意思和用法搭配

热门文章

1. linux运行jar和关闭jar
2. html5 二进制数据解析,JavaScript读写二进制数据的方法详解
3. Antd Pro v4入门
4. java阴阳师抽卡概率_阴阳师抽卡概率公布 阴阳师SSR/御魂抽取概率
5. 不只有感动人心的故事：华为独辟蹊径的全球化营销
6. 你与育碧的服务器已经中断,育碧CJ展示游戏突然断开连接 玩家：可以，这很育碧...
7. Linux中安装和使用Translate Shell
8. 零基础怎么学习板绘 板绘入门必备知识
9. 解决GIT不能push代码到github
10. AWZ爱伪装详细使用教程