2.1 标识符和关键字、保留字

2.1.1 标识符

• 定义：程序员自己规定的具有特定含义的字符序列。java语言中标识符即类、接口、变量、方法、包的名字。

• 命名规则：由数字、字母、下划线、和“$"组成。不能为关键字、保留字，区分大小写。首字符不能为数字。

• java对标识符命名时通常遵循如下规定(命名规范)。

  类型	规则
  类和接口名	通常是名词，每个词的首字母大写，其余小写。如HelloWorld,MyClass。（驼峰式命名）
  常量名	基本数据类型的常量类型的常量使用全部大写字母，词与词之间用_分隔。如STUDENT_NUM。
  方法名	通常是动词，首字母小写，其余词首字母大写，尽量少用_。如setTime。（小驼峰式命名）
  变量名	首字母小写，其余词首字母大写，不用_，少用"$"。给变量命名尽量做到见名知意。如minSalary。（小驼峰式命名）

• 字符 java字符采用Unicode字符集的编码方案，每个字符占内存空间16位，因此有2¹⁶(65536)个字符，字符编码最大值65535。字母和汉字都占一个字符。每个字符占内存16位。

2.1.2 关键字

• 定义：被java语言赋予特定含义的单词，不能作为标识符使用。
• 关键字的字母全部小写。
• 常见的代码编辑器针对关键字有特殊颜色标记。

2.1.3 保留字

• 定义：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留

  字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const 。

2.2 基本数据类型与变量、常量

2.2.1 基本数据类型

• bit：计算机中最小的存储单位。byte：计算机中的基本存储单位，1字节(byte) = 8 bit。

数据类型	常见、[]表示所占字节数
基本数据类型（数值型）	整数(byte[1]、short[2]、int[4]、long[8]) 浮点数(float[4]、double[8])
基本数据类型（非数值型）	布尔(boolean)[1]、字符(char)[2]
引用数据类型	类(class) 接口(interface) 数组([])

• 在java中，所有的数值类型所占据的字节数量与平台无关,以保证java的可移植性。

2.2.1.1 整型与浮点类型

• 使用细节：

  1. java的整形常量有固定的范围和字段长度，不受具体操作系统的影响，以保证java程序的可移植性。

  2. long类型的变量定义时防止整数过大后面要加L，float类型的变量定义时为了防止类型不兼容后面要加F。

  3. 关于浮点数在机器中存放形式的简单说明,浮点数 = 符号位 + 指数位 + 尾数位。

  4. 尾数部分可能丢失，造成精度损失(小数都是近似值)。

  5. 科学计数法：5.12e2 等价于 512.0 5.12E-2 等价于 0.0512.

  6. 当我们对运算结果是小数的进行相等判断时，应该是以俩个数的差值绝对值，在某个精度范围内判断。

  public class variable {public static void main(String[] args) {double a = 2.7;double b = 8.1/3;System.out.println(a);System.out.println(b);if(a == b)System.out.println("a=b");elseSystem.out.println("鸡你太美");}
  }
  /* 输出结果
  2.7
  2.6999999999999997
  鸡你太美
  */
  

2.2.1.2 字符型与布尔型

• 使用细节：

  1. 在java中，char的本质是一个整数，所以char类型是可以进行运算的，在输出时，是unicode码对应的字符。其中，‘A’=65 A到Z连续 ‘a’=97 a到z连续 ‘0’=48 0到9连续。

  2. 布尔类型也叫Boolean类型，取值只允许true、false，无null。

  3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转。

     char c1 = 'a';
     char c2 = 'a' + 'b';
     System.out.println(c1);  // a
     System.out.println((int) c1);  // 97
     System.out.println(c2);  // Ã
     System.out.println((int) c2);  // 195
     char c3 = 97;
     System.out.println(c3);  // a
     System.out.println((int)c3);  // 97int m = 100;
     char c4 = m;  // false
     char c5 = (char)m   // d
     

2.2.2 常量

• Java中必须用final关键字声明符号常量，其声明格式为final 数据类型 常量名 =缺省值; 如final int STUDENT_NUM = 10;

  final表示这个常量只能被赋值一次，一但赋值后就不能再更改。

  命名规则：基本数据类型的常量类型的常量使用全部大写字母，词与词之间用_分隔。如STUDENT_NUM。

• 类常量：希望某个常量可以在一个类中的多个方法中使用，可以使用关键字static final设置一个类常量，类常量的定义在main方法的外部。

  public cl ass Constants {public static final double CM_PER_INCH = 2.54;  // 类常量的定义位于 main 方法的外部public static void main(String[] args) {double paperWidth = 8.5;double paperHeight = 11;System.out.println("Paper size in centimeters: " + paperWidth * CMJERJNCH + by " + paperHeight * CM_PER_INCH) ; }
  }
  

2.2.3 变量

• 定义：在程序运行中其值可以发生改变的量，从本质上讲变量是内存中的一小块区域，不同的变量，类型不同，占用的空间大小不同。

• 命名规则：首字母小写，其余词首字母大写，不用_，少用"$"。给变量命名尽量做到见名知意。如minSalary。（小驼峰式命名）

• 变量使用的注意事项：

  • 变量在同一个作用域内不能重名。

  • 变量未赋值不能使用，即变量必须先声明，后使用。

  • long类型的变量定义时防止整数过大后面要加L，float类型的变量定义时为了防止类型不兼容后面要加F。

  • 逐一声明每一个变量可以提高程序的可读性。

  • 在 Java 中， 变量的声明尽可能地靠近变量第一次使用的地方， 这是一种良好的程序编写

    风格。

• 变量的分类

  1. 局部变量（在类方法中定义的变量）

  ​ 属于方法，在方法栈中分配空间，分配后没有初始值，即不会自动初始化，必须在使用之前显示初始化。

  1. 成员变量（全局变量）（在类中定义的变量）

  ​ 属于对象或类，在堆中分配空间，分配空间后具有默认初始值，即自动初始化。

2.3 运算符

2.3.1 算术运算符

• 加+ 减- 乘* 除/ 取余%

• 取余的本质 a % b = a - (a / b) * b

• System.out.println(10 / 4);  // 2
  System.out.println(10 / 4.0); // 2.
  System.out.println(10 % 4); // 2
  System.out.println(10 % 4.0);  // 2.0int l = 1;
  l = l++;  // temp=i l=l+1 l=temp l=1
  System.out.println(l); // 1int b = 1;
  b = ++b;  // b=b+1 temp=b b=temp
  System.out.println(b);  // 2
  

• 在默认情况下， 虚拟机设计者允许对中间计算结果采用扩展的精度。

  但是， 对于使用 strictfj 关键字标记的方法必须使用严格的浮点计算来生成可再生的结果。

1. 字符的+操作

​ 拓展的+= 隐含了强制类型转换。
​ 算术表达式中包含多个基本数据类型的值时，整个算术表达式的类型会自动提升。

• byte、short、char都会被提升到int型。

• 整个表达式的类型会自动升级到表达式中最高等级操作数相同的类型。

• byte、short、char——int——long——float——double

1. 字符串的+操作

   +左右有一边出现字符串，则其功能为字符串的连接运算。

2.3.2 关系运算符(比较运算符)

• 定义：关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false 。

  ​ 关系表达式 经常用在 if 结构的条件中或循环结构的条件中。

• 常见：

  运算符	运算	范例	结果
  ==	相等于	1==2	false
  ！=	不等于	1!=2	true
  <	小于	1<2	true
  >	大于	1>2	false
  <=	小于等于	1<=2	true
  >=	大于等于	1>=2	false
  instanceof	检查是否是类的对象	“cxk” instanceof String	true

• int a = 9;
  int b = 8;
  System.out.println(a > b); // T
  System.out.println(a < b);  // F
  System.out.println(a >= b);  // T
  System.out.println(a == b);  // F
  System.out.println(a != b);  // T
  System.out.println("cxk" instanceof String);  // T
  

2.3.3 逻辑运算符

• 定义：用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。
• 常见：

逻辑运算符号	作用	说明
&	逻辑与	a&b 一假则假
|	逻辑或	a|b一真则真
^	逻辑异或	a^b ab真假性不同才为true
!	逻辑非	!a 真假性与a相反
&&	短路与	一假则假、左假则停
||	短路或	一真则真、左真则停

• int a = 10;
  int b = 20;// 逻辑与
  boolean flag = a > 100 & ++b < 20;
  System.out.println(flag); // F
  System.out.println(b);  // 21// 短路与
  boolean flag = a > 100 && ++b < 20;
  System.out.println(flag);  // F
  System.out.println(b);  //  20// 逻辑或
  boolean flag = a > 5 | ++b < 20;
  System.out.println(flag);  // T
  System.out.println(b);  //  21// 短路或
  boolean flag = a > 5 || ++b < 20;
  System.out.println(flag);  // T
  System.out.println(b);  //  20// 非与异或
  boolean flag1 = true;
  boolean flag2 = false;
  boolean flag3 = true;
  System.out.println(flag1);  // T
  System.out.println(flag2);  // F
  System.out.println(!flag1);  // F
  System.out.println(!flag2);  // T
  System.out.println(flag1 ^ flag2);  // T
  System.out.println(flag1 ^ flag3);  // F
  

2.3.4 三元运算符

• 格式：关系表达式? 表达式1 : 表达式2

• 范例：a>b? a : b true执行a false执行b

• int a = 10;
  int b = 20;
  int result = a > b ? a++ : b--;
  System.out.println(result);  // 20
  System.out.println(a);  // 10
  System.out.println(b);  // 19int c = 10;
  int d = 20;
  int resultTwo = c < d ? c++ : d--;
  System.out.println(resultTwo);  // 10
  System.out.println(c);  // 11
  System.out.println(d);  // 20// 找出三个数中的最大数
  int n1 = 10;
  int n2 = 20;
  int n3 = 30;
  int max1 = n1 > n2 ? n1 : n2;
  int max2 = max1 > n3 ? max1 : n3;
  System.out.println("result is " + max2);
  

• 使用细节：

  1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换）。

  2. 三元运算符可以转成 if–else 语句。

2.4 表达式的类型转换

2.4.1 自动类型转换

• 定义：在java程序进行赋值或者运算时，把一个数值范围小的数值或变量赋值给数据范围大的变量。

• 规则：

  char–int–long–float–double

  byte–short–int–long–float–double

• 使用细节：

  1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据，然后进行计算,自然，表达式的结果的类型自动提升为操作数中最大的类型。

  2. 当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时，就会报错，反之就会进行自动类型转换。

  3. (byte、short)和char之间不会相互自动转换。

  4. byte、short、char他们三者可以计算，在计算时首先转换为int类型。

  5. boolean不参与转换。

     byte b1 = 1;
     byte b2 = 2;
     int b3 = b1 + b2;
     System.out.println(b3);  // 3
     System.out.println(2.12e2 + "," + 2.12e-2);  // 212.0,0.0212
     

2.4.2 强制类型转换

• 定义：把一个数值范围大的数值或变量赋值给数据范围小的变量。由多储存字节到少储存字节的转换会丢失一些信息。

• 使用细节：

  1. 7种数值型可以混合运算，布尔型不能与7种数值型混合运算。

  2. char类型可以保存int的常量值，但不能保存int的变量值，需要强转。

     char c1 = 100;  // true
     int m = 100  // true
     char c2 = m  // false
     char c3 = (char)m   // true
     System.out.println(c3)  // 100对应的字符
     

  3. byte、short、char在进行运算时，当做int类型处理。

2.4.3 基本数据类型和String类型转换

2.4.3.1 基本类型转为String类型

1. 将基本类型后加” “即可。

   int n1 = 100;
   float n2 = 1.1f;
   double n3 = 1.3;
   boolean n4 = true;
   String str1 = n1 + "";
   String str2 = n2 + "";
   String str3 = n3 + "";
   String str4 = n4 + "";
   System.out.println(str1);  // 100
   System.out.println(str2);  // 1.1
   System.out.println(str3);  // 1.3
   System.out.println(str4);  // true
   

2.4.3.2 String类型转为基本数据类型

String str5 = "123";
byte num1 = Byte.parseByte(str5);
short num2 = Short.parseShort(str5);
int num3 = Integer.parseInt(str5);
long num4 = Long.parseLong(str5);
float num5 = Float.parseFloat(str5);
double num6 = Double.parseDouble(str5);
boolean b4 = Boolean.parseBoolean("true");
System.out.println(num1);  // 123
System.out.println(num2);  // 123
System.out.println(num3);  // 123
System.out.println(num4);  // 123
System.out.println(num5);  // 123.0
System.out.println(num6);  // 123.0
System.out.println(b4);  // true

• 注意事项：

  在将 String 类型转成 基本数据类型时， 要确保String类型能够转成有效的数据，比如我们可以把 “123” , 转成一

  个整数，但是不能把 “hello” 转成一个整数。

2.5 键盘输入

• 定义：在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是

  Scanner 。

• 示例：

  Scanner sc = new Scanner(System.in);
  System.out.println("请输入球员年龄：");  // 请输入球员年龄：
  int age = sc.nextInt();  // 20System.out.println("请输入球员薪水：");  // 请输入球员薪水：
  double salary = sc.nextDouble();   // 100.56System.out.println("请输入球员能力值：");  // 请输入球员能力值
  int ability = sc.nextInt();  // 91System.out.println("球员年龄:" + age + " 球员薪水:" + salary + " 球员能力值:" + ability);  // 球员年龄:20 球员薪水:100.56 球员能力值:91
  

2.5.1 输入单个字符

• // 输入单个字母
  Scanner sc = new Scanner(System.in);
  System.out.println("请输入：");  // 请输入：
  char c = sc.next().charAt(0);  // afsdfdsfsd
  System.out.println("首字母是:" + c);  // 首字母是:a
  

2.5.2 循环输入

• double sum = 0;
  double average;
  int t = 0;
  System.out.print("请输入整数：");
  while (sc.hasNextInt()) {int a = sc.nextInt();sum += a;t++;average = sum / t;System.out.println("当前已输入：" + t + "次" + "," + " 总数是：" + sum + " 平均数是：" + average);System.out.print("请输入整数：");
  }
  sc.close();
  System.out.println("你输入的不是整数，程序结束");
  

2.5.3 Random

• 作用：产生一个随机数
• 使用步骤
  1. 导包 import java.util.Random
  2. 创建对象 Random r = new Random ();
  3. 获取随机数 int number = r.nextInt(10);获取数据范围[0,10)的数,前面包括后面不包括。

2.6 字符串

• 定义：字符串就是Unicode字符序列。

2.6.1 字串

• 定义：String类的substring方法可以从一个较大的字符串中提取出一个字串。

• // 字串
  String s1 = "hello";
  String s2 = s1.substring(0,3); // 前闭后开
  System.out.println(s2);  // “hel”
  

2.6.2 拼接

• 定义：与绝大多数的程序设计语言一样，Java语言允许使用 + 号连接（拼接）两个字符串。

• String s3 = "hello";
  String s4 = "kyrie";
  String s5 = s3 + " " + s4;
  System.out.println(s5);  // "hello kyrie"
  

2.6.3 不可变字符串

• 定义：String 类没有提供用于修改字符串的方法，如果想要修改字符串， 只能通过字串的方法提取，然后再拼接上替换的字符串。

• // 不可变字符串
  String s6 = "hello";
  String s7 = s6.substring(0,3) + "p";
  System.out.println(s7);  // "help"
  

• 优点：编译器可以让字符串共享，可以想象各种字符串存放在公共的存储池中。字符串变量指向存储池中相应的位置，如果复制一个字符串变量，原始字符串与复制的字符串共享相同的字符。总而言之，java的设计者任务共享带来的高效率远胜过提取、拼接字符串带来的低效率。

2.6.4 检测字符串是否相等

• 定义：可以使用 equals 方法检测两个字符串是否相等。

• // 不可变字符串
  String s8 = "hello";
  String s9 = "kyrie";
  String s10 = "hello";
  System.out.println(s8.equals(s9));  // false
  System.out.println(s8 == s9);  // false
  System.out.println(s8.equals(s10));  // true
  System.out.println(s8 == s10);  // true
  

• 细节：一定不要使用==运算符检测两个字符串是否相等！ 这个运算符只能够确定两个字串是否放置在同一个位置上。当然， 如果字符串放置在同一个位置上， 它们必然相等。但是，完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。

2.6.5 空串和Null串

1. 空串定义：空串 “” 是长度为 0 的字符串，空串是一个 Java 对象， 有自己的串长度（ 0 ) 和内容（空）。

   • // 检测是否为空串
     String s11 = "";
     Boolean b1 = s11.length() == 0;  // 长度检测
     Boolean b2 = s11.equals("");  // 内容检测
     System.out.println("s11 is 空串？：" + b1 );  // s11 is 空串？：true
     System.out.println("s11 is 空串？：" + b2 );  // s11 is 空串？：true
     

2. Null串定义：String 变量还可以存放一个特殊的值， 名为 null, 这表示目前没有任何对象与该变量关联。

   • // 检测是否为Null串
     String s12 = null;
     Boolean b3 = s12 == null; // == 检测
     System.out.println("s12 is null? ：" + b3);  // s12 is null? : true
     System.out.println(s12.equals(null));  // 报错
     

2.6.6 码点与代码单元

• 定义：Java 字符串由 char 值序列组成。

• 常见方法：

  1. str.length() 方法将返回采用 UTF-16 编码表示的给定字符串所需要的代码单元数量。

     String s13 = "hello kyrie";
     System.out.println("字符串长度是：" + s13.length());  // 11
     

  2. str.codePointCount(0, greeting.length)，得到码点数量，即实际长度。

     String s13 = "hello kyrie";
     System.out.println("码点数量是：" + s13.codePointCount(0,s13.length()));  // 11
     

  3. str.charAt(n) 将返回位置 n 的代码单元，n 介于 0 ~ str.length()-1之间。

     String s13 = "hello kyrie";
     System.out.println("第一个字母是：" + s13.charAt(0));  // h
     System.out.println("最后一个字母是：" + s13.charAt(s13.length() - 1));  // e
     

  4. 遍历字符串

     for (int i = 0;i < s13.length();i++) {System.out.println(s13.charAt(i));
     }
     

2.6.7 String API

2.6.8 构建字符串

• 定义：有些时候， 需要由较短的字符串构建字符串,采用字符串连接的方式达到此目的效率比较低。每次连接字符串， 都会构建一个新的 String 对象，既耗时， 又浪费空间。使用 StringBuildei类就可以避免这个问题的发生。

• StringBuilder builder = new StringBuilder();
  // 当每次需要添加一部分内容时， 就调用 append 方法。
  builder.append("hello");
  builder.append(' ');
  builder.append("kyrie");
  String completedString = builder.toString();
  System.out.println(completedString);  // hello kyrie
  

2.7 进制(程序员的基本功)

• 定义：对于整数，有四种表示方式：

  二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。

  十进制：0-9 ，满 10 进 1。

  八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。

  十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

• // 1. 输出示例
  //n1 二进制
  int n1 = 0b1010;
  // n2 10 进制
  int n2 = 1010;
  // n3 8 进制
  int n3 = 01010;
  //n4 16 进制
  int n4 = 0X10101;
  System.out.println("n1=" + n1);  // n1=10
  System.out.println("n2=" + n2);  // n2=1010
  System.out.println("n3=" + n3);  // n4=65793
  System.out.println(0x23A);  // 570
  

2.7.1 进制转换

2.7.1.1 二、八、十六进制转换为十进制

• 规则：从最低位(右边)开始，将每个位上的数提取出来，乘以2、8、16的==（位数-1）==次方，然后求和。

• // 2. 二、八、十六进制转换为十进制
  System.out.println(0b110001100); // 396
  System.out.println(02456);  // 1326
  System.out.println(0xA45);  // 2629
  

2.7.1.2 十进制转换为二、八、十六进制

• 规则：将该数不断除以 2、8、16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二、八、十六进制。

• // 3.  十进制转换为二、八、十六进制
  System.out.println("123转换为二进制为：0b01111011");
  System.out.println("678转换为八进制为：01246");
  System.out.println("8912转换为十六进制为：0X22D0");
  

2.7.1.3 二进制转换为八进制、十六进制

• 规则：从低位开始,将二进制数每（3、4）位一组，转成对应的八、十六进制数即可。

• // 4. 二进制转换为八进制、十六进制
  System.out.println("0b11 100 101转换位八进制为：0345");
  System.out.println("0b11 1001 0110转换为十六进制为：0x396");
  

2.7.1.4 八进制、十六进制转换为二进制

• 规则：：将八、十六进制数每 1 位，转成对应的一个 3 、4位的二进制数即可。

• // 5. 八进制、十六进制转换为二进制
  System.out.println("01230转换为二进制为：001 010 011 000");
  System.out.println("0xAB29转换为二进制为：1010 1011 0010 1001");
  

2.7.2 位运算

• 相关内容：
  1. 二进制是奉2进位的进位制，0、1是基本算符。
  2. 现代的电子计算机技术全部采用的是二进制，因为它只使用0、1俩个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制(Binary)数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字在不同的位上代表不同的值，按从右至左的次数，这个值以二倍递增。

2.7.2.1 原码、反码、补码

1. 二进制的最高位是符号位：0表示正数、1表示负数。
2. 正数的原码、反码、补码都一样（三码合一）。
3. 负数的反码=它的原码符号位不变，其他位取反（0 -> 1,1 -> 0 ）
4. 负数的补码=它的反码+1。
5. 0的反码，补码都是0。
6. java没有无符号数，换言之，java中的数都是有符号的。
7. 在计算机运算时，都是以补码的方式来运算的。
8. 当我们看运算结果的时候。要看它的源码。

2.7.2.2 位运算符

• java中有7个位运算符，如下

  符号	作用
  按位与 &	两位全为1，结果为1，否则为0
  按位或 |	两位有一个为1，结果为1，否则为0
  按位异或 ^	两位有一个为0，一个为1，结果为1，否则为0
  按位取反 ~	0 ->1，1->0
  算术右移 >>	低位溢出，符号位不变，并用符号位补溢出的高位
  算术左移 <<	符号位不变，低位补0
  逻辑右移 >>>	逻辑右移也叫无符号右移，运算规则是：低位溢出，高位补0

• 示例

  System.out.println(2&3);  // 2
  System.out.println(~-2);  // 1
  System.out.println(~2);  // -3
  System.out.println(2|3);  // 3
  System.out.println(2^3);  // 1System.out.println(1 >> 2);  // 0
  System.out.println(1 << 2);  // 4
  System.out.println(4 << 3);  // 32
  System.out.println(15 >> 2);  // 3
  

  • 特别说明，没有<<<符号。

2.8 流程控制

2.8.1 顺序结构

• 定义：顺序结构是程序中最简单、最基本的结构。没有特定的语法结构，按照代码的先后顺序依次执行。程序中大多数代码都是这样执行。

• public class Test {int n1 = 1;int n2 = n1 + 1 ;  // rightint n2 = n1 + 1int n1 = 1 // false
  }
  

2.8.2 分支结构(if else,switch case)

2.8.2.1 if else

• 练习：

  1. // if分支控制 练习1
     boolean b1 = true;
     if (b1 == false) {System.out.println("a");
     } else if (b1) {System.out.println("b");
     } else if (!b1) {System.out.println("c");
     } else {System.out.println("d");
     }  // bboolean b2 = true;
     if (b2 = false) {System.out.println("a");
     } else if (b2) {System.out.println("b");
     } else if (!b2) {System.out.println("c");
     } else {System.out.println("d");
     }  // c
     

  2. // if分支控制 练习2
     Random r = new Random();
     int number = r.nextInt(101);
     while (true) {System.out.print("请输入你要猜的数字：");Scanner sc = new Scanner(System.in);int guessNumber = sc.nextInt();if (guessNumber > number) {System.out.println("你猜的数字偏大");} else if (guessNumber < number) {System.out.println("你猜的数字偏小");} else {System.out.println("终于猜中了随机数");break;}
     }
     

  3. // if分支控制 练习3
     Scanner sc = new Scanner(System.in);
     System.out.print("请输入月份：");
     int month = sc.nextInt();
     if (month >= 4 && month <= 10) {System.out.print("请输入客户年龄：");int year = sc.nextInt();if (year >= 18) {System.out.println("成人衣服100元");} else {System.out.println("童装50元");}
     } else if ((month >= 1 && month <= 3) || (month >= 11 && month <= 12)) {System.out.println("淡季通通10元");
     } else {System.out.println("月份不对请重新输入月份...");
     }
     

2.8.2.2 switch case

• switch注意事项和细节讨论：

  1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，而常量值是int。

     // switch 分支控制练习1
     Scanner sc = new Scanner(System.in);
     System.out.print("请输入一个字符：");
     char c = sc.next().charAt(0);
     switch (c) {case 'a':System.out.println("星期一");break;case 'b':System.out.println("星期二");break;case 65:System.out.println("星期三");break;default:System.out.println("过年了...");
     }
     // 输出示例
     //请输入一个字符：A
     //星期三
     

  2. switch(表达式)中表达式的返回值必须是：(byte,short,int,enum[枚举]，String)

     double c = 1.1;
     switch(c) {case 1.1:  // 报错System.out.println("过年了...);break;
     }
     

  3. case字句中的值必须是常量，而不能是变量。

  4. default字句是可选的，当没有匹配的case时，执行default。

  5. break语句用在执行完一个case分支后使程序跳出switch语句块，如果没有写break，程序会顺序执行到switch结尾，除非遇到break。（穿透）

• 练习：

  1. // switch 分支控制练习2
     Scanner sc = new Scanner(System.in);
     System.out.print("请输入学生考试成绩：");
     int grade = sc.nextInt();
     if (grade < 0 || grade > 100) {System.out.println("输入的学生成绩有误，请重新输入成绩...");
     } else {switch ((int) grade / 60) {case 1:System.out.println("学生成绩合格");break;case 2:System.out.println("学生成绩不合格");default:System.out.println("数据有误");}
     }
     

  2. // switch 分支控制练习3
     Scanner sc = new Scanner(System.in);
     System.out.print("请输入月份：");
     int month = sc.nextInt();
     switch (month) {case 3:case 4:case 5:System.out.println("春季");break;case 6:case 7:case 8:System.out.println("夏季");break;case 9:case 10:case 11:System.out.println("秋季");break;case 12:case 1:case 2:System.out.println("冬季");break;default:System.out.println("输入的数据有误");
     }
     

2.8.2.3 if和switch比较

1. 如果判断的具体数值不多，而且符合byte、short、int、char、enum[枚举]、String这六种类型。虽然俩个语句都可以使用，建议使用switch语句。
2. 其他情况，对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

2.8.3 循环结构(for,while,do…while)

2.8.3.1 for

• 基本语法：

  for (循环变量初始化;循环条件;循环变量迭代) {循环操作(可以多条语句)；
  }// for死循环
  for(;;) {}
  

• 注意事项和细节说明：

  1. 循环条件是返回一个布尔值的表达式。

  2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

  3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

     // for循环练习1
     int count = 3;
     for (int i = 0, j = 0; i < count; i++, j += 2) {System.out.println("i = " + i + " j = " + j);
     }
     /* 输出结果
     i = 0 j = 0
     i = 1 j = 2
     i = 2 j = 4 */
     

• 练习：

  1. // for循环练习2 公鸡、母鸡、小鸡分别值5、3、1/3元。现在用100元买一百只鸡
     for (int cock = 0; cock < 20; cock++) {for (int hen = 0; hen < 33; hen++) {int chicken = 100 - cock - hen;if ((double) 1 / 3 * chicken + 5 * cock + 3 * hen == 100) {System.out.println("公鸡有：" + cock);System.out.println("母鸡有：" + hen);System.out.println("小鸡有：" + chicken);}}
     }
     

  2. // for循环练习3 水仙花数
     int count = 0;
     for (int i = 100; i <= 999; i++) {int a = i / 100;  // 百位int b = i / 10 % 10;  // 十位int c = i % 10;  // 个位if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == i) {System.out.println(i);count++;}
     }
     System.out.println("水仙花的个数是：" + count);
     

2.8.3.2 while

• 基本语法：

  循环变量初始化;
  while (循环条件) {循环体(语句);循环变量迭代;
  }// while 死循环
  while(true) {}
  

• 练习：

  1. // while循环练习1
     double paper = 0.1;
     int height = 8844430;
     int count = 0;
     while (paper <= height) {paper *= 2;count++;
     }
     System.out.println("折叠的次数是：" + count);
     

  2. // while循环练习2
     int i = 0;
     while (i <= 100) {if (i % 17 == 0) {System.out.println(i);}i++;
     }
     

2.8.3.3 do…while

• 基本语法：

  循环变量初始化;
  do {循环体(语句);循环变量迭代;
  } while(循环条件);
  

• 练习：

  1. Scanner sc = new Scanner(System.in);
     char answer = ' ';
     do {System.out.println("坤坤向你发起了篮球邀请");System.out.print("接受坤坤的篮球邀请吗？y/n：");answer = sc.next().charAt(0);System.out.println("你的回答是：" + answer);
     } while (answer != 'y');System.out.println("你干嘛啊，哎哟！");
     

2.8.3.4 多重循环控制

• 介绍：

  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环.【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环.

• 练习：

  1. // 多重循环练习1 九九乘法表
     for (int i = 0; i <= 9; i++) {for (int j = 1; j <= i; j++) {System.out.print(j + " * " + i + " = " + (j * i) + "\t");}System.out.println();
     }
     

  2. // 多重循环练习2 空心金字塔
     Scanner sc = new Scanner(System.in);
     System.out.print("请输入要打印的空心金字塔的行数：");
     int totalLevel = sc.nextInt();
     for (int i = 1; i <= totalLevel; i++) {  // i表示当前层数for (int j = 1; j <= totalLevel - i; j++) {  // 打印内容前的空格System.out.print(" ");}for (int j = 1; j <= 2 * i - 1; j++) {  // 打印内容if (j == 1 || j == 2 * i - 1 || i == totalLevel) {System.out.print("*");} else {System.out.print(" ");}}System.out.println();
     }
     

2.8.4 跳转控制语句(break,continue,return)

2.8.4.1 break

• 定义：break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说提前结束当前的整个循环。一般用在switch或者循环(for,while,do…while)中。

• 基本语法：

  {    ......break;......
  }
  

• 注意事项：

  1. break语句可以出现在多层嵌套的语句块中，可以通过标签指明要终止的是那一层语句块。

  2. 在实际开发中，尽量不适用标签。

  3. 如果没有指定break，默认退出最近的循环体。

     // break练习1
     lable1:
     for (int j = 0; j < 3; j++) {lable2:for (int i = 0; i < 10; i++) {if (i == 2) {break;}System.out.println("i = " + i);}
     }
     // 输出结果
     i = 0
     i = 1
     i = 0
     i = 1
     i = 0
     i = 1lable3:
     for (int j = 0; j < 3; j++) {lable4:for (int i = 0; i < 10; i++) {if (i == 2) {break lable3;}System.out.println("i = " + i);}
     }
     // 输出结果
     // i = 0
     // i = 1
     

• 练习：

  1. // break练习2
     int i;
     int sum = 0;
     for (i = 0; i <= 100; i++) {sum += i;if (sum > 20) {System.out.println("当前的和是：" + sum + " 当前是第" + i + "次");break;}
     }
     

  2. // break练习3 登录案例
     Scanner sc = new Scanner(System.in);
     int chance = 3;
     String name = "";
     String pw = "";
     for (int i = 0; i < 3; i++) {System.out.print("请输入账号名称：");name = sc.next();System.out.print("请输入密码：");password = sc.next();if ("kyrie".equals(name) && "666".equals(pw)) {System.out.println("恭喜你登录成功！");break;}chance--;System.out.println("登录失败，您当前还有" + chance + "次机会。。。");}
     

2.8.4.2 continue

• 定义：continue 用在循环中，基于条件控制，跳过某次循环体的执行，继续下一次执行。

• continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样。

• 基本语法：

  {......continue;......}
  

• 练习：

  1. label1:
     for (int j = 0; j < 2; j++) {label2:for (int i = 0; i < 10; i++) {if (i == 2) {continue;}System.out.println("i = " + i);}
     }// 输出结果
     // 俩组 i = [0,9] label3:
     for (int j = 0; j < 2; j++) {label4:for (int i = 0; i < 10; i++) {if (i == 2) {continue label3;}System.out.println("i = " + i);}
     }
     // 输出结果
     // i = 0
     // i = 1
     // i = 0
     // i = 1
     

2.8.4.3 return

• 定义：使用在方法，表示跳出所在的方法。特别的，如果return写在main方法，表示退出程序。

2.9 方法

2.9.1 方法的概述

• 方法是具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
• 方法必须先创建再使用，该过程称为方法的定义。
• 方法创建后并不是直接运行的，需要手动调用后才执行，该过程称为方法的调用。

2.9.2 方法的注意事项

• 方法不能嵌套定义。
• void表示无返回值，可以省略return，也可以单独书写return后面不加东西。

2.9.3 方法重载

• 在同一个类中定义的多个方法之间的关系，满足下列多个条件的方法相互构成重载。

• 方法名称相同。

• 方法参数个数不同，或参数类型不同。

• 与返回值无关。

2.9.4 方法的参数传递

• 基本数据类型：形式参数改变，不影响实际参数的值。
• 引用数据类型：形式参数改变，影响实际参数的值。

第二章 java语言基础相关推荐

1. java语言定义一个具备栈功能的类_Java学习笔记 第二章 Java语言基础

   第二章 JAVA语言基础 一.关键字 1.关键字的定义和特点 定义:被Java语言赋予了特殊含义的单词 特点:关键字中所有的字母都为小写 2.用于定义数据类型的关键字 c;ass  interface ...

2. 进击 ！！第二章 JAVA编程基础

   第二章 JAVA编程基础 目标: 掌握java的基本语法,常量,变量,流程控制语句,方法以及数组 运用java运算符的使用 了解java代码的基本格式 2.1java 的基本语法 1. 代码的基本格式 ...

3. 第二章 Mablab语言基础

   第二章 Mablab语言基础 2.1 Matlab的变量与常量 1) input:x=input('please enter a numb') 2) Inf/inf:正无穷大 3) pi:圆周率 4) ...

4. python语言中、用来表示赋值的符号是_第二章Python语言基础知识

   第二章Python语言基础知识 2.1 Python语言基础知识 2.1.1标识符与关键字 在Python语言中,对程序中各个元素命名加以区分,这种用来标识变量.函数.类等元素的符号称为标识符. Py ...

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

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

6. 【Java基础系列教程】第二章 Java语言概述、配置环境变量

   一.计算机编程语言概述 1.1 语言 语言(英文:Language)是人类进行沟通交流的表达方式.例如:中国人与中国人用普通话沟通.而中国人要和英国人交流,就要学习英语.              语 ...

7. 第二章java编程基础测试题_Java编程基础测试题分享

   单选题:(每道题目2分) 1. 下列哪个声明是错误的?(B) A. int i=10; B. float f=1.1; //float f=1.1f C. double d=34.4; D. byte ...

8. 第二章 C语言基础程序设计

   一概览 本章介绍以下内容: - 变量 - 常量 - 进制及其转换 - 计算机信息存储 - C语言基本数据类型-整型 - C语言基本数据类型-浮点型 - C语言基本数据类型-字符型 - C语言基本数据类 ...

9. 第二章 Pyton语言基础、Ipython及Jupyter notebook(?功能,%run命令,魔法函数）

   ?功能 在一个变量名的前后使用问号(?)可以显示一些关于该对象的概要信息: b=[1,2,3] b? 假设已经写好了如下函数(你可以在Ipython或jup中复现): def add_numbers( ...

最新文章

1. 程序员花名大 PK | 每日趣闻
2. 蓝牙Bluetooth技术小知识
3. MUI+H5手机上传照片 支持多图片上传和拍照上传
4. CSS教程：li和ul标签用法举例
5. 数据结构：关于AVL树的平衡旋转详解
6. 从并发视角来看智能合约（上）【渡鸦论文系列】
7. Python开发：初识Python
8. 微服务整合系列整个代码
9. mongodb+java_Java EE + MongoDb与Apache TomEE和Jongo Starter项目
10. DEL: Open explorer from Console
11. java——获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示，并不要再运行程序
12. linux 'stack'未声明(在此函数内第一次使用,c - 错误：未声明“ asm”（此函数中的首次使用） - 堆栈内存溢出...
13. 远离复杂公式推导，直接解决共线性
14. 21天Jenkins打卡day8-配置SSH远程服务器
15. MDC记录activiti流程ID
16. 2021年百度账号批量取消绑定手机号教程
17. 支持ipv6路由器有什么优点？路由器应用了哪些技术？
18. 基础树状数组和线段树
19. CurveLane-NAS: Unifying Lane-Sensitive Architecture Search and Adaptive Poin
20. 好用的便签APP排行榜前十名？

热门文章

1. 大菠萝 Pinia 持久化方案 Pinia Persist Own
2. 职业经理人影响力自检手册(二)
3. 一个元素位于另一个元素之上，点击上面的元素引发下面元素事件操作
4. 头条抖音后端技术3面，2021Java通用流行框架大全，含面试题+答案
5. 层次分析法——确定指标权重、解决评价类问题
6. python课程设计矩阵对角线之和_Python二维数组实现求出3*3矩阵对角线元素的和示例...
7. 高斯消元法求解方程组
8. storm各组件特点
9. %02d得意思是什么？
10. 墙裂推荐一个高质量的数据分析学习平台