2 Java基本语法
2.1 关键字和保留字
关键字(keyword)
- 定义:被Java语言赋予了特殊含义，用做专门用途的字符串(单词)
- 特点:关键字中所有字母都为小写
- 官方地址: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
保留字(reserved word)
Java保留字:现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字：goto 、const
2.2 标识符
- 标识符:
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧:凡是自己可以起名字的地方都叫标识符。（类名、变量名、接口名、…）
- 定义合法标识符规则: （如果没有遵守，编译不通过）
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
- Java中的名称命名规范:
-
包名:多单词组成时所有字母都小写:xxxyyyzzz
-
类名、接口名:多单词组成时，所有单词的首字母大写:XxxYyyZzz（大驼峰）
-
变量名、方法名:多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写:xxxYyyZzz（小驼峰）
-
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
-
注意1:在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
-
注意2:java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
2.3 变量
- 变量的概念:
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
- 变量的作用:
- 用于在内存中保存数据
- 使用变量注意:
- Java中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域:其定义所在的一对{ }内
- 变量只有在其作用域内才有效
- 同一个作用域内，不能声明重名的变量
1. 声明变量
- 语法:<数据类型> <变量名称>
- 例如:int var;
2. 变量的赋值
- 语法:<变量名称> = <值>
- 例如:var = 10;
3. 声明和赋值变量
- 语法: <数据类型> <变量名> = <初始化值>
- 例如:int var = 10;
2.3.1 变量的分类-按数据类型
对于每一种数据都定义了明确的具体数据类型(强类型语言)，在内存中分
变量的分类-按数据类型 配了不同大小的内存空间。
补充:变量的分类-按声明的位置的不同 （在学习面向对象时再详细介绍）
- 在方法体外，类体内声明的变量称为成员变量。
- 在方法体内部声明的变量称为局部变量。
- 注意:二者在初始化值方面的异同:
同:都有生命周期
异:局部变量除形参外，需显式初始化。
2.3.2 整数类型
整数类型:byte、short、int、long
- Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
- java的整型常量默认为int型，声明long型常量须后加‘l’或‘L’
- java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
（超出范围的话编译会不通过）
（通常定义整型变量类型为 int ）
2.3.3 浮点类型
浮点类型：float、double
- 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
- 浮点型常量有两种表示形式:
- 十进制数形式:如:5.12 512.0f .512 (必须有小数点)
- 科学计数法形式:如:5.12e2 512E2 100E-2
- float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。double:双精度，精度是float的两倍。通常采用此类型。
- Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
float表示的数值范围比整型的long还要大
（定义浮点类型数据时，通常使用double类型）
long l1 = 123456; // 右式默认为int，将int赋给long型
long l2 = 1234567890987654321 // 右式默认为int，编译失败：过大的整数
byte b1 = 12; // 不报错
byte b2 = b1 + 1; //报错，不兼容的类型: 从int转换到byte可能会有损失
byte b3 = 128; // 报错，不兼容的类型: 从int转换到byte可能会有损失
float f1 = 12.3; // 编译失败，12.3默认为double型，double赋给float报错
2.3.4 字符类型
字符类型：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码。
char c1 = 97; // a
在计算机内部，所有数据都使用二进制表示。每一个二进制位(bit)有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节(byte)。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从0000000 到 11111111。
乱码:世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
ASCII码:上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的 关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如 空格“SPACE”是32(二进制00100000)，大写的字母A是65(二进制01000001)。这 128个符号(包括32个不能打印出来的控制符号)，只占用了一个字节的后面7位，最前 面的1位统一规定为0。缺点:不能表示所有字符；相同的编码表示的字符不一样:比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel。
Unicode:一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。缺点:Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码 应该如何存储:无法区别 Unicode 和 ASCII:计算机无法区分三个字节表示一个符号 还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果 unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有 二到三个字节是0，这对于存储空间来说是极大的浪费。
UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式，是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。UTF-8的编码规则:对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码(等同于 ASCII码)；对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一 个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的 所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。
char c1 = ''; // 报错
2.3.5 布尔类型
布尔类型：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版》
2.3.6 字符串类型
字符串类型：String
- String不是基本数据类型，属于引用数据类型
- 使用方式与基本数据类型一致。例如:String str = “abcd”;
- 一个字符串可以串接另一个字符串，也可以用连接运算符 “+” 串接其他8种类型的数据。例如:
str = str + “xyz”;
int n = 100;
str = str + n;
// 输出 * *
System.out.println("* *"); // * *
System.out.println('*' + '\t' + '*'); // 93
System.out.println('*' + "\t" + '*'); // * *
System.out.println('*' + '\t' + "*"); // 51*
System.out.println('*' + ('\t' + "*")); // * *
2.3.7 基本数据类型转换
不包含boolean类型。
2.3.7.1 自动类型提升
- 自动类型提升（自动类型转换）:容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为:
（当byte、char、short做运算时，结果为int型，即使是同类型做运算也是如此） - 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的 那种数据类型，然后再进行计算。
byte b1 = 2;
int i1 = 129;
// byte b2 = b1 + i1; // 编译不通过
float f1 = b1 + i1 // 131.0
char c1 = 'a';
int i2 = 10;
int i3 = c1 + i2; // 107
- byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
- boolean类型不能与其它数据类型运算。
- 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
2.3.7.2 强制类型转换
强制类型转换：自动类型提升的逆运算。
- 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符:()，但可能造成精度降低或溢出,格外要注意。
- 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如:
String a = “43”;
int i = Integer.parseInt(a);
- boolean类型不可以转换为其它的数据类型。
double d1 = 12.9;
int i1 = (int)d1; // 截断操作，12
int i2 = 128; // 00000000 00000000 00000000 10000000 // 二进制形式
byte b1 = (byte)i2; // -128，即为10000000
2.3.8 关于进制
- 所有数字在计算机底层都以二进制形式存在。
- 对于整数，有四种表示方式:
- 二进制(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
（计算机底层都是以补码形式存储数据）
- 为什么要使用原码、反码、补码表示形式呢?
- 计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
2.3.8.1 二进制转十进制
- 计算机底层一般存储的是补码形式，先得到原码再计算得到十进制数。
- 计算原码：正数的原码、反码、补码的形式都是一致的；负数的最高位为符号位，负数先减1得到反码，再除符号位外取反得到原码。
- 计算十进制数：在原码中，从右往左，即从最低位开始：
十 进 制 数 = n u m 0 ∗ 2 0 + n u m 1 ∗ 2 1 + n u m 2 ∗ 2 2 + . . . , 十进制数 = num0 * 2^0 + num1 * 2^1 + num2 * 2^2 + ... , 十进制数=num0∗20+num1∗21+num2∗22+...,
其中，numN为从右往左数第N位数的值。
由补码计算负数的值：
2.3.8.2 十进制转二进制
2.3.8.3 进制间转化
- 十进制 二进制互转
- 二进制转成十进制 乘以2的幂数
- 十进制转成二进制 除以2取余数
- 二进制 八进制互转
- 二进制 十六进制互转
- 十进制 八进制互转
- 十进制 十六进制互转
二进制转八进制：从低位到高位，每三位为一个数，拼起来即为对应八进制数。
八进制转二进制：从低位到高位，每位数写成一个三位的二进制数，拼起来即为对应二进制数。
二进制转十六进制：从低位到高位，每四位为一个数，拼起来即为对应八进制数。
十六进制转二进制：从低位到高位，每位数写成一个四位的位二进制数，拼起来即为对应二进制数。
2.4 运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算术运算符
- 赋值运算符
- 比较运算符(关系运算符)
- 逻辑运算符
- 位运算符
- 三元运算符
2.4.1 算数运算符
- 取模运算中，结果的符号与被模数的符号是一致的。此外，取模运算的结果不一定总是整数。
- 对于除号“/”，它的整数除和小数除是有区别的:整数之间做除法时，只 保留整数部分而舍弃小数部分。 例如:int x=3510;x=x/1000*1000; x的 结果是3000.
- “+”除字符串相加功能外，还能把非字符串转换成字符串.例如: System.out.println(“5+5=”+5+5); //打印结果是? 5+5=55 ?
// 除法
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2; // 2，int之间运算的结果还是int
int result2 = num1 / num2 * num2; // 10
double result3 = num1 / num2; // 2.0
double result4 = num1 / (num2 + 0.0); // 2.4
double result5 = (num1 + 0.0) / num2; // 2.4
double result6 = (double)num1 / num2; // 2.4
double result7 = (double)(num1 / num2); // 2.0
// %：取余运算
int m1 = 12;
int n1 = 5;
System.out.println(m1 % n1); // 2
int m2 = -12;
int n2 = 5;
System.out.println(m2 % n2); // -2
int m3 = 12;
int n3 = -5;
System.out.println(m3 % n3); // 2
int m1 = -12;
int n1 = -5;
System.out.println(m1 % n1); // -2
自增1
a++：先返回a，再自增1
++a：先自增1，再返回a
- 都会自增1，返回的值看第一个符号；
- 不会改变字符类型
int a1 = 10;
int b1 = ++a1;
System.out.println(a1, b1); //11, 11
int a2 = 10;
int b2 = a2++;
System.out.println(a2, b2); //11, 10
byte b3 = 127;
b3++;
System.out.println(b3); // -128
自减1
a–：先返回a，再自减1
–a：先自减1，再返回a
练习1:
public class SignTest{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print(“i=”+i); // 10
System.out.println(“i1=”+i1); // 11
i = ++i1;
System.out.print(“i=”+i); // 12
System.out.println(“i1=”+i1); // 12
i = i2--;
System.out.print(“i=”+i); // 20
System.out.println(“i2=”+i2); // 19
i = --i2;
System.out.print(“i=”+i); // 18
System.out.println(“i2=”+i2); // 18
}
}
练习2:
/*
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。 格式如下:
数字xxx的情况如下:
个位数:
十位数:
百位数:
例如: 数字153的情况如下:
个位数:3
十位数:5
百位数:1
*/
import javax.swing.JOptionPane;
public class Test {
public static void main(String[] args){
int num = Integer.parseInt(JOptionPane.showInputDialog(null,"请输入一个三位整数如；135"));
int unitsDigit = num % 10;
int tensDigit = num % 100 / 10;
int hundredsDigit = num / 100;
JOptionPane.showMessageDialog(null,"输入的数为：" + num +
"\n个位数：" + unitsDigit +
"\n十位数：" + tensDigit +
"\n百位数：" + hundredsDigit);
}
}
2.4.2 赋值运算符
- 符号:=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制 类型转换原则进行处理。
- 支持连续赋值。
- 扩展赋值运算符: +=, -=, *=, /=, %=
int a = 10;
int c,b;
c = b = 10;
int i1 = 10, i2 = 20; // 公用int类型，中间 “,”
int i3 = 10;
i3 += 2; // 12
i4 %= 3; // 1
byte i5 = 10;
// i5 = i5 + 2; 编译失败
i5 += 2; // 不改变原类型
开发中实现+2的操作有哪些？（前提：int num = 10）
- num = num + 2;
- num += 2; (推荐)
开发中实现+1的操作有哪些？（前提：int num = 10）
- num = num + 1;
- num += 1;
- num++; (推荐)
思考：
int a = 1;
a *= 0.1;
System.out.println(a); // 0
a++;
System.out.println(a); // 1
int i = 1;
i += (i++) + (++i);
// 相当于 i = i + (i++) + (++i)，右式第一个i为原值1
System.out.println(i); // 5
2.4.3 比较运算符
- 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
- 比较运算符“==”不能误写成“=” 。
- >、<、>=、<=：只能用于数值类型之间。
- ==、!=不仅可以用于数值类型数据之间，还可以用于其他类型的数据之间。
// 区分 == 和 =
int i = 10;
int j = 20;
System.out.println(i == j); // false
System.out.println(i = j); // 20，j赋给i再输出i
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2); // false
System.out.println(b2 = b1); // true，b1赋给b2再输出b2
2.4.4 逻辑运算符
| 符号 | 含义 |
|---|---|
| & | 逻辑与 |
| | | 逻辑或 |
| ! | 逻辑非 |
| && | 短路与 |
| || | 短路或 |
| ^ | 逻辑异或 |
（短路的与和或，当左边足以得出结论时，不继续判断右边表达式）
- 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
- “&”和“&&”的区别:
- 单&时，左边无论真假，右边都进行运算;
- 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
（二者结果一致）
- “|”和“||”的区别同理，||表示:当左边为真，右边不参与运算。
- 异或( ^ )与或( | )的不同之处是:当左右都为true时，结果为false。 理解:异或，追求的是“异”! （同0异1）
练习：
// 1
int x = 1;
int y=1;
if(x++==2 & ++y==2){ // false & true is false
x =7;
}
System.out.println("x="+x+",y="+y); // x=2,y=2
// 2
int x = 1,y = 1;
if(x++==2 && ++y==2){ // false
x =7;
}
System.out.println("x="+x+",y="+y); // x=2,y=1
// 3
int x = 1,y = 1;
if(x++==1 | ++y==1){ // true | false is true
x =7;
}
System.out.println("x="+x+",y="+y); // x=7,y=2
// 4
int x = 1,y = 1;
if(x++==1 || ++y==1){ true
x =7;
}
System.out.println("x="+x+",y="+y); // x=2,y=1
【面试题】程序输出:
class Test {
public static void main (String [] args) {
boolean x=true;
boolean y=false;
short z=42;
if((z++==42)&&(y=true))z++; // 区分 == 与 =
if((x=false) || (+ +z==45)) z++;
System. out.println(“z=”+z); } // 46
2.4.5 位运算符
- 位运算是直接对整数的二进制进行的运算
- &、｜、^是逻辑运算符还是位运算符取决于前后的数据类型，若为数值则为位运算符；
- a<<n：在一定范围内，结果为a * 2^n;
- a>>n：在一定范围内，结果为a / (2^n);
逻辑与、或、抑或示例：
面试题：最高效的计算2 * 8的方式： 2<<3 或 8<<1.
练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
// 方式一：定义临时变量
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;
如何从键盘获取不同类型的变量：需要使用Scanner类
实现步骤：
import java.util.Scanner; // 1. 导包
System.out.print("请输入一个整数"); // 提示
Scanner scan = new Scanner(System.in); // 2. Scanner的实例化
int num = scan.nextInt(); //3. 调用Scanner类的相关方法，来获取指定类型的变量
// nextInt, nextDouble, nextBoolean, 类型不匹配时会报错
// next 用于String
// 对于char型的获取，Scanner没有提供相关的方法，只能获取一个字符串，可以先获取字符串，再用字符串的方法获得特定字符
2.4.6 三元运算符
- 格式：
- 表达式1和表达式2为同种类型，或可以统一为一个类型；
- 凡是能用三元的都可以改写为if-else，反之不成立；三元比if-else结构的运行效率高；
- 三元运算符与if-else的联系与区别: 1)三元运算符可简化if-else语句 2)三元运算符要求必须返回一个结果。 3)if后的代码块可有多个语句。
int m = 12;
int n = 5;
int k = 6;
int max = (m>n)?m:n; // 求两数最大
int max2 = (max>k)?max:k; // 求三数最大
// 或
int max3 = (m>n)?((m>k)?m:k):((n>k)?n:k); // 三求数最大，可读性差
面试题：如何求一个0～255范围内的整数的十六进制值，例如60的十六进制表示形式为3C。（0～255为FF内的十六进制数）
// 法1:
int num1 = 31;
String numStr2 = Integer.toBinaryString(num1);
String numStr16 = Integer.toHexString(num1);
System.out.println(numStr2);
System.out.println(numStr16);
// 法2
import java.util.Scanner;
public class Test {
public static void main(String[] args){
System.out.print("请输入一个0～255的整数：");
Scanner input = new Scanner(System.in);
int num1 = input.nextInt();
int k = num1 & 15; // 15为低四位为1，其他全为0的二进制数对应值
// 该操作可以保留num1二进制值的低四位值
String hexLowNum = (k>9)?""+(char)('A'+(k-9)):(""+k);
// 十六进制数低位值
int j = (num1 >> 4) & 15;
String hexHighNum = (j>9)?""+(char)('A'+(j-9)):(""+j);
// 十六进制数高位值
String result = hexHighNum + hexLowNum;
System.out.println(num1 + "对应的十六进制值为：0x" + result);
}
}
2.4.7 运算符的优先级
- 运算符有不同的优先级，所谓 优先级就是表达式运算中的运 算顺序。如右表，上一行运算 符总优先于下一行。
- 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的。
（一般不记这个表，多写几行代码增强可读性，或者用括号保证优先级）
2.5 程序流程控制
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
流程控制方式采用结构化程序设计中规定的三种基本流程结构，即: 顺序结构、分支结构、循环结构。
- 顺序结构
- 程序从上到下逐行地执行，中间没有任何判断和跳转。
- 分支结构
- 根据条件，选择性地执行某段代码。
- 有if…else和switch-case两种分支语句。
- 循环结构
- 根据循环条件，重复性的执行某段代码。
- 有while、do…while、for三种循环语句。
- 注:JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
2.5.1 顺序结构
Java中定义成员变量时采用合法的前向引用。如:
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
// 错误形式:
public class Test{
int num2 = num1 + 2;
int num1 = 12;
}
2.5.2 分支语句1:if-else结构
（条件判断结构）
第一种：
if(条件表达式){
执行代码块;
}
第二种：二选一
if(条件表达式){
执行代码块1;
} else{
执行代码块2;
}
第三种：多选一
if(条件表达式1){
执行代码块1;
}else if (条件表达式2){
执行代码块2;
}
......
}else{
执行代码块n;
}
分支结构:if-else使用说明
- 条件表达式必须是布尔表达式(关系表达式或逻辑表达式)、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留;
- if-else语句结构，根据需要可以嵌套使用;
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略 ;
- 如果有交集的话视实际情况而定；
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓;当多个条件是“包含”关系时，“小上大下 / 子上父下”。
练习：由键盘输入三个整数分别存入变量num1、num2、num3， 对它们进行排序(使用 if-else if-else),并且从大到小输出。
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("请输入第一个数：");
int num1 = input.nextInt();
System.out.print("请输入第二个数：");
int num2 = input.nextInt();
System.out.print("请输入第三个数：");
int num3 = input.nextInt();
int max, mid, min;
if (num1 >= num2) {
}else{ // 交换num1, num2
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
}
if (num3 >= num1){
System.out.println("" + num3 + ">=" + num1 + ">=" + num2);
}else if (num2 >= num3){
System.out.println("" + num1 + ">=" + num2 + ">=" + num3);
}else{
System.out.println("" + num1 + ">=" + num3 + ">=" + num2);
}
}
}
public class Test {
public static void main(String[] args){
int x = 4;
int y = 1;
if (x>2)
if (y>2)
System.out.print("A");
else
System.out.println("B");
}
}
// 输出为“B”
// if语句不加大括号只能管一行，但上面是合法的，把分号当成一行的结尾
练习:
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。 2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。 3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。 4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。 5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
提示:使用(int)(Math.random() * 90 + 10)产生随机数。
Math.random() : [0,1) * 90 --> [0,90) + 10 --> [10,100) --> [10,99]
// 公式：整数[a,b] (int)(Math.random()*(b-a+1)+a)
import java.util.Scanner;
public class Test {
public static void main(String[] args){
int lottery = (int)(Math.random() * 90 + 10);
int tensDigitOfLottery = lottery / 10;
int unitsDigitOfLottery = lottery % 10;
System.out.print("请输入一个两位数");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int tensDigit = num / 10;
int unitsDigit = num % 10;
if (num == lottery){
System.out.println("中奖号码为" + lottery + "，奖金10000美元");
}else if (tensDigitOfLottery == unitsDigit && unitsDigitOfLottery == tensDigit){
System.out.println("中奖号码为" + lottery + "，奖金 3000美元");
}else if (tensDigitOfLottery == tensDigit || unitsDigitOfLottery == unitsDigit){
System.out.println("中奖号码为" + lottery + "，奖金 1000美元");
}else if (tensDigitOfLottery == unitsDigit || unitsDigitOfLottery == tensDigit){
System.out.println("中奖号码为" + lottery + "，奖金 500美元");
}else{
System.out.println("中奖号码为" + lottery + "，未中奖，彩票作废。");
}
}
}
2.5.3 分支语句2:switch-case结构
switch(表达式){
case 常量1:
语句1;
// break;
case 常量2:
语句2;
// break;
…
case 常量N:
语句N;
// break;
default:
语句;
// break;
}
根据switch表达式的值，以此匹配各个case中的常量，一旦匹配成功，则进入相应的case执行其语句。执行完成之后，依次执行后面的case和default结构中的语句，直到遇到break关键字或到switch-case结构末尾才停止。
- switch(表达式)中表达式的值必须是下述几种类型之一:byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0);
- case子句中的值必须是常量(不能范围)，不能是变量名或不确定的表达式值;
- 同一个switch语句，所有case子句中的常量值互不相同;
- break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有break，程序会顺序执行到switch结尾
- default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时， 执行default
练习：使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e. 其它的输出 “other”。
提示:String word = scan.next(); char c = word.charAt(0); switch©{}
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String word = input.next();
char c = word.charAt(0);
switch(c) {
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;
default:
System.out.println("other");
break;
}
}
}
- 如果switch-case语句结构中多个case的执行语句想同，可以考虑进行合并。
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年的第几天。
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("请输入2019年中的某个月份：");
int month = input.nextInt();
System.out.print("请输入该月中的日期：");
int day = input.nextInt();
int result = 0;
switch (month){
case 1:
result = day;
break;
case 2:
result = 31 + day;
break;
case 3:
result = 31 + 28 + day;
break;
case 4:
result = 31 + 28 + 31 + day;
break;
case 5:
result = 31 + 28 + 31 + 30 + day;
break;
case 6:
result = 31 + 28 + 31 + 30 + 31 + day;
break;
case 7:
result = 31 + 28 + 31 + 30 + 31 + 30 + day;
break;
case 8:
result = 31 + 28 + 31 + 30 + 31 + 30 + 31 + day;
break;
case 9:
result = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day;
break;
case 10:
result = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
break;
case 11:
result = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
break;
case 12:
result = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
break;
}
System.out.println("2019年"+month+"月"+day+"日是2019年的第"+result+"天");
}
}
// 更优者：
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;
}
// 判断闰年
int year;
isLeapYear = (year%400)?true:((year%4==0 && year%100!=0)?true:false)
练习：从键盘上读入一个学生成绩，存放在变量score中，根据score的 值输出其对应的成绩等级:
score>=90 等级: A
70<=score<90 等级: B
60<=score<70 等级: C
score<60 等级: D
switch (score / 10){
case 10:
case 9:
System.out.println("等级A");
break;
case 8:
case 7:
System.out.println("等级B");
break;
case 6:
System.out.println("等级C");
break;
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
System.out.println("等级D");
break;
}
说明：
- 凡是可以用switch-case结构的都可以用if-else结构，反之不成立；
- 二者都可以使用且case数量不多时，优先使用switch-case结构；
- 三元结构 <-- if -->switch
if和switch语句很像，具体什么场景下，应用哪个语句呢?
- 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几
种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。 - 其他情况:对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
2.5.4 循环结构
- 循环结构
在某些条件满足的情况下，反复执行特定代码的功能 - 循环语句分类
- for 循环
- while 循环
- do-while 循环
- 循环语句的四个组成部分
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
- 语法格式
for (1初始化部分; 2循环条件部分; 4迭代部分){
3循环体部分;
}
- 执行过程: 1-2-3-4-2-3-4-2-3-4-…-2
- 说明:
- 2循环条件部分为boolean类型表达式，当值为false时，退出循环
- 1初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
- 4可以有多个变量更新，用逗号分隔
(上面i只在for循环内有效)
int num = 1;
for(System.out.print('a');num <= 3;System.out.print('c'),num++){
System.out.print('b');
} // abcbcbc
练习：
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("100以内的偶数和为" + sum);
练习：输入两个正整数m和n，求其最大公约数和最小公倍数。比如:12和20的最大公约数是4，最小公倍数是60。 说明:break关键字的使用。
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.print("请输入第一个正整数：");
int num1 = scan.nextInt();
System.out.print("请输入第一个正整数：");
int num2 = scan.nextInt();
if (num1>num2){
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
} // 保证num1不大于num2
// 求最大公约数
for(int i=num1;i>=1;i--){
if(num1%i==0 && num2%i==0){
System.out.println(num1 + "和" + num2 +
"的最小公约数为：" + i);
break;
}
}
// 求最小公倍数
for(int i=num2;i<=num1*num2;i++){
if(i%num1==0 && i%num2==0){
System.out.println(num1 + "和" + num2 +
"的最最大公倍数为：" + i);
break;
}
}
}
}
2.5.5 循环结构2:while循环
- 语法格式
1初始化部分
while(2循环条件部分){
3循环体部分;
4迭代部分;
}
- 执行过程: 1-2-3-4-2-3-4-2-3-4-…-2
说明:
- 注意不要忘记声明4迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换。
- 与for循环的一点点区别：初始化部分的作用范围。
public class WhileLoop {
public static void main(String args[]) {
int result = 0; int i = 1;
while (i <= 100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
}
2.5.6 循环结构3:do-while循环
- 语法格式
1初始化部分;
do{
3循环体部分
4迭代部分
}
while(2循环条件部分);
- 执行过程: 1-3-4-2-3-4-2-3-4-…2
- 说明: do-while循环至少会执行一次循环体。
public class DoWhileLoop {
public static void main(String args[]) {
int result = 0, i = 1;
do {
result += i;
i++;
} while (i <= 100);
System.out.println("result=" + result);
}
}
最简单“无限” 循环格式:while(true) , for(; ; ),无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。
练习：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
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{
// 输入为0时跳出循环
break;
}
}
System.out.println("输入的正数个数为" + positiveNumber);
System.out.println("输入的负数个数为" + negativeNumber);
}
}
说明：
- 不在循环条件部分限制循环次数的结构：for(; ; ) 或 while(true)
- 结束循环的几种方式：
- 循环条件部分返回false；
- 循环体中执行break。
2.5.7 嵌套循环
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
练习：九九乘法表
public class Test {
public static void main(String[] args){
for(int m=1;m<=9;m++){
for(int n=1;n<=m;n++){
System.out.print(n + "*" + m + "=" + m*n + " ");
}
System.out.println();
}
}
}
练习：100以内所有质数
public class Test {
public static void main(String[] args){
for(int i=2;i<=100;i++){
// 判断质数
boolean flag = true;
for(int j=2;j<=Math.pow(i,0.5);j++){
if(i%j==0){
flag = false;
break;
}
}
if (flag){
System.out.println(i);
}
}
}
}
2.5.7 特殊关键字的使用：break、continue
- break 语句
break语句用于终止某个语句块的执行
{ ......
break;
}
- break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { ......
label2: { ......
label3: { ......
break label2;
}
}
}
- continue 语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
说明：
- break只能用于switch语句和循环语句中。
- continue 只能用于循环语句中。
- 二者功能类似，但continue是终止本次循环，break是终止本层循环。
- break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
- 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break; // 默认跳出包含此关键词的最近的一层循环
//continue;
//break label; //结束指定标识的一层循环结构
continue label; //结束指定标识的一层循环结构的当次循环
}
System.out.print(j);
}
System.out.println();
}
public class Test {
public static void main(String[] args){
label1:for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++){
if(j%4==0){
continue label1;
}
System.out.print(j);
}
System.out.println(); // 永远不会被执行，因为内层循环都是从continue结束的，不会完整执行
}
}
}
附加:特殊流程控制语句3
- return:并非专门用于结束循环的，它的功能是结束一个方法。 当一个方法执行到一个return语句时，这个方法将被结束。
- 与break和continue不同的是，return直接结束整个方法，不管 这个return处于多少层循环之内
补充：
衡量一个功能代码的优劣：
- 正确性；
- 可读性；
- 健壮性：考虑多种情况；
- 高效率与低存储：时间复杂度低，空间复杂度低。
视频网址：https://www.bilibili.com/video/BV1Kb411W75N?p=1
课程资料：http://www.atguigu.com/download_detail.shtml?v=129
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
