看这篇就够了，教你如何搞定Java基本语法

写在前面，Java基础系列文章都是作者基于b站尚硅谷的Java基础视频所做的笔记，没有时间的同学可以认真看看，如果有时间的同学，还是建议看看视频，毕竟笔记说到底还是自己的东西，每个人的习惯也是不一样的，所以为了自己，学就对了，加油！
也请各位同学，如果感觉对自己有帮助，可以帮忙给个一键三连，谢谢！

文章目录

• ​​1. 关键字与保留字​​

• ​​1.1 关键字的定义和特点​​
• ​​1.2 常见的关键字​​
• ​​1.3 保留字​​

• ​​2. 标识符​​

• ​​2.1 定义合法标识符的规则​​
• ​​2.2 Java中的名称命名规范​​

• ​​3. 变量​​

• ​​3.1 声明变量​​
• ​​3.2 变量的赋值​​
• ​​3.3 声明和赋值变量​​
• ​​3.4 变量的分类-按数据类型​​
• ​​3.5 变量的分类-按声明的位置的不同​​
• ​​3.6 整数类型：byte、short、int、long​​
• ​​3.7 浮点类型：float、double​​
• ​​3.8 字符类型：char​​

• ​​3.8.1 ASCII 码表​​

• ​​3.9 布尔类型：boolean​​
• ​​3.10 基本数据类型转换​​
• ​​3.11 字符串类型：String​​
• ​​3.12 强制类型转换​​

• ​​4. 进制​​

• ​​4.1 关于进制​​
• ​​4.2 二进制的原码、反码、补码​​
• ​​4.3 进制间的转化​​

• ​​5. 运算符​​

• ​​5.1 赋值运算符​​
• ​​5.2 比较运算符​​
• ​​5.3 逻辑运算符​​
• ​​5.4 位运算符​​
• ​​5.5 三元运算符​​

• ​​6. 程序流程控制​​

• ​​6.1 顺序结构​​
• ​​6.2 分支语句1： if-else结构​​
• ​​6.3 分支语句2： switch-case结构​​

• ​​6.3.1 switch和if语句的对比​​

• ​​6.4 循环结构​​
• ​​6.5 循环结构1： for循环​​
• ​​6.6 循环结构2： while循环​​
• ​​6.7 循环结构3： do-while循环​​
• ​​6.8 嵌套循环结构​​
• ​​6.9 特殊关键字的使用： break、continue​​
• ​​6.9.1 特殊流程控制语句说明​​

1. 关键字与保留字

1.1 关键字的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：​​关键字中所有字母都为小写​​

1.2 常见的关键字

注意：​​true、false、null​​都不是Java关键字

1.3 保留字

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

2. 标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。

技巧：凡是可以自己起名字的地方都叫标识符。

2.1 定义合法标识符的规则

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

举例：划红线的地方都不是合法标识符

2.2 Java中的名称命名规范

Java中的名称命名规范：

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

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

java采用unicode字符集，因此标识符​​也可以使用汉字声明​​​，但是​​不建议​​使用。

3. 变量

变量的概念

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

变量的作用

• 用于在内存中保存数据

使用变量要注意

• Java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：其定义所在的一对{ }内
• 变量只有在其作用域内才有效
• 同一个作用域内，不能定义​​重名的变量​​

3.1 声明变量

• 语法：<数据类型> <变量名称>
• 例如：int var;

3.2 变量的赋值

• 语法：<变量名称> = <值>
• 例如：var = 10;

3.3 声明和赋值变量

• 语法： <数据类型> <变量名> = <初始化值>
• 例如：int var = 10;

3.4 变量的分类-按数据类型

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

3.5 变量的分类-按声明的位置的不同

• 在​​方法体外​​​，​​类体内​​​声明的变量称为​​成员变量​​。
• 在​​方法体内部​​​声明的变量称为​​局部变量​​。

注意：二者在初始化值方面有一些区别

同：都有生命周期。

异：​​局部变量除形参外，其他都需要显式初始化​​​。而​​全局变量可以不显示初始化​​​，因为​​全局变量有默认的初始值​​。

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

• ​​java的整型常量默认为int型，声明long型常量时必须在后面添加" l "或" L "​​
• java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long型

注意：bit (位) ：计算机中的最小存储单位。

byte (字节) ：计算机中基本存储单元。

/*
Java定义的数据类型

一、变量按照数据类型来分：
  基本数据类型：
    整型：byte \ short \ int \ long
    浮点型：float \ double
    字符型：char
    布尔型：boolean

  引用数据类型：
    类：class
    接口：interface
    数组：array

二、变量在类中声明的位置：
    成员变量 vs 局部变量
*/
class VariableTest1{
  
  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型变量，必须以“1”或“L”结尾
    short s1 = 128;
    int i1 = 12345;
    long l1 = 345678586; //345678586是int类型，编译通过是因为自动类型提升为long类型
    System.out.println(l1); //类型提升后面会讲，只需知道声明long型变量，必须以“1”或“L”结尾
  }
  
}

3.7 浮点类型：float、double

• 浮点型常量有两种表示形式：

• 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
• 科学计数法形式:如：5.12e2 512E2 100E-2

• float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double:双精度，精度是float的两倍。通常采用此类型。

​​Java 的浮点型常量默认为double型​​​，​​声明float型常量，必须在后面添加" f "或" F "​​

3.8 字符类型：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码。

/*
Java定义的数据类型

一、变量按照数据类型来分：

  基本数据类型：
    整型：byte \ short \ int \ long
    浮点型：float \ double
    字符型：char
    布尔型：boolean

  引用数据类型：
    类：class（String也属于类）
    接口：interface
    数组：array

二、变量在类中声明的位置：
    成员变量 vs 局部变量
*/
class VariableTest1{
  public static void main(String[] args) {
    
    //2. 浮点型：float(4字节) \ double(8字节)
    //① 浮点型，表示带小数点的数值
    //② float表示 数值的范围比long类型还大
    double d1 = 12.3;
    System.out.println(d1 +1);
    
    //定义float类型变量时，变量要以"f" 或"F"结尾
    float f1 = 12.3F;
    System.out.println(f1);

    //② 通常，定义浮点型变量时，都是使用double变量

    //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 = '\u0123';
    System.out.println(c6);
    
    char c7 = '\u0043';
    System.out.println(c7);
  }
}

3.8.1 ASCII 码表

3.9 布尔类型：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 VariableTest1{
  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("禁止入内！");
    }else{
      System.out.println("可以参观！");
    }
  }
}

3.10 基本数据类型转换

• 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成​​容量最大​​​的那种​​数据类型​​，然后再进行计算。
• ​​byte , short , char之间不会相互转换，他们三者在计算时首先转换为int类型​​。
• ​​boolean类型不能与其它数据类型进行运算​​。
• 当把任何基本数据类型的值和字符串(String)进行连接运算时(​​+​​)，基本数据类型的值将自动转化为字符串(String)类型。

/*
基本数据类型之间的运算规则：

前提：这里讨论只是7中基本数据类型变量的运算。不包含boolean类型的。
1. 自动类型提升：
  当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
  说明：此时容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
  char、byte、short-->int-->long-->float-->double

  特别的：当byte、char、short三种类型的变量做运算时，结果为int类型

2. 强制类型转换：
*/
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);
    System.out.println(l1);

    float f = b1 + i1;
    System.out.println(f);
    //***************特别的**************************
    char c1 = 'a';  //97
    int i3 = 10;
    int i4 = c1 + i3;
    System.out.println(i4);

    short s2 = 10;
    //编译错误
//    char c3 = c1 + s2;
    
    byte b2 = 10;
//    char c3 = c1 + b2;  //编译不通过,结果都为int

//    short s3 = b2 + s2; //编译不通过,结果都为int
    
//    short s4 = b1 + b2; //编译不通过,结果都为int
  }
}

class VariableTest4{
  public static void main(String[] args){
    //1. 编码情况
    long l = 123456;
    System.out.println(l);
    
    //编译失败: 过大的整数,需要在后面添加 l或L 来表示long类型
    //long l1 = 452367894586235;
    long l1 = 452367894586235L;

    //**************************
    //编译失败: 浮点型默认都是double型,需要在后面添加f或F来表示float类型
//    float f1 = 12.3;
      float f1 = 12.3f;
    
    //2. 编码情况2:
    //整型变量，默认类型为int型
    //浮点型变量，默认类型为double型
    byte b = 12;
  //  byte b1 = b + 1;  //编译失败,结果都为int
    
  //  float f1 = b + 12.3;  //编译失败,结果都为double
  }
}

3.11 字符串类型：String

• String​​不是基本数据类型​​​，​​属于引用数据类型​​
• 使用方式与基本数据类型一致。例如：String str = “abcd”;
• 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

• str = str + “xyz” ;
• int n = 100;
• str = str + n;

/*
String类型变量的使用
1. String属于引用数据类型
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算；+
4. 运算的结果仍然是String类型
*/
class StringTest{
  public static void main(String[] args){

    String s1 = "Good Moon!";

    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 + true;
    System.out.println(info1);
  }
}

String练习

String str1 = 4; //判断str1对错：no
String str2 = 3.5f + “”; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out.println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1

3.12 强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使 用时要加上强制转换符：​​( )​​​，但​​可能造成精度降低或溢出​​，需要格外注意。
• 通常，字符串不能直接转换为基本数据类型，但通过基本数据类型对应的包装类则可以实现把字符串转换成基本数据类型。

• 如： String a = “43”; int i = Integer.parseInt(a);

• ​​boolean类型不可以转换为其它的数据类型​​。

强制类型转换的练习（判断是否能通过编译）

short s = 5;
s = s-2; //判断：no,结果都为int
byte b = 3;
b = b + 4;//判断：no,结果都为int
b = (byte)(b+4);//判断：yes,强转后可以为byte
char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：yes
byte b = 5;
short s = 3;
short t = s + b;//判断：no,结果都为int

4. 进制

世界上有10种人，认识和不认识二进制的。

4.1 关于进制

• 所有数字在计算机底层都以​​二进制​​形式存在。
• 对于整数，有四种表示方式：

• 二进制(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

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

    int num1 = 0b110;
    int num2 = 110;
    int num3 = 0127;
    int num4 = 0x110A;

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
    System.out.println("num3 = " + num3);
    System.out.println("num4 = " + num4);
  }
}

4.2 二进制的原码、反码、补码

• Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位； 当是long类型时，二进制默认占64位，第64位是符号位
• 二进制的整数有如下三种形式：

• 原码：直接将一个数值换成二进制数。最高位是符号位
• 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1
• 负数的补码：其反码加1

• 计算机以二进制补码的形式保存所有的整数

• 正数的原码、反码、补码都相同
• 负数的补码是其反码+1

• 原码与反码是帮助推导出补码而存在的

二进制 -> 十进制

注意：

• 对于正数来讲：原码、反码、补码 都是相同的：三码合一
• 计算机底层都是使用二进制表示的数值
• 计算机底层都是使用的数值的补码保存数据的

4.3 进制间的转化

十进制 -> 二进制

二进制 -> 十进制

5. 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

• 算术运算符
• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 位运算符
• 三元运算符

/**
 *   运算符之一：算术运算符
 *    +  -  *  /  %  (前)++  (后)++  (前)--  (后)-- 
 */
class Day3Test{
    public static void main(String[] args) {

        //除号：/
        int num1 = 12;
        int num2 = 5;
        int resule1 = num1 / num2;
        System.out.println(resule1);    //2

        int result2 = num1 / num2 * num2;
        System.out.println(result2);

        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(result5);
        System.out.println(result6);

        // %：取余运算
        //结果的符号与被模数的符号相同
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);

        //(前)++ : 先自增1，后运算
        //(后)++ ：先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1); //a1 = 11,b1 = 11

    int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2); //a2 = 11,b2 = 10

        int a3 = 10;
        a3++;    //a3++;
        int b3 = a3;

        //注意点：
        short s1 = 10;
        //s1 = s1 + 1;  //编译失败,结果为int
//      s1 = (short)(s1 + 1);   //正确的,强转后可以为short
        s1++;    //编译通过,自增1不会改变自身变量的数据类型,s1还是short类型
        System.out.println(s1);

        //问题：
        byte bb1 = 127;
        bb1++;
        System.out.println("bb1 = " + bb1); //bb1 = -128,超过了byte的表数范围，所以结果为负数

        //(前)-- :先自减1，后运算
        //(后)-- ：先运算，后自减1
        int a4 = 10;
        int b4 = a4--;    //int b4 = --a4;
        System.out.println("a4 = " + a4 + ",b4 = " + b4); //a4 = 9,b4 = 10
    }
}

​​注意：​​

• 5 % -2 = 1； -5 % 2 = -1；​​第一个数就是被模数​​
• 取模运算的结果是与被模数有关的，​​如果被模数是正数，则结果为正数，如果被模数是负数，则结果为负数​​

算术运算符练习

/*
练习：随意给出一个三位数的整数，打印显是它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

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

*/
class AriExer{
  public static void main(String[] args){
    int num = 187;
    System.out.println("百位数：" + num/100); //百位数：1
    System.out.println("十位数：" + num%100/10); //十位数：8
    System.out.println("个位数：" + num%10); //个位数：7
  }
}

5.1 赋值运算符

• 符号：=

• 当 “=” 两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
• 支持连续赋值

• 扩展赋值运算符：+=, -=, *=, /=, %=

/*
运算符之二：赋值运算符
  +=   -=   *=   /= 
*/
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);

    short s1 = 10;
    //s1 = s1 + 2;  //编译失败,结果为int类型
    s1 += 2;  //结论：不会改变变量自身的数据类型,结果还是short类型
    System.out.println(s1);

    //开发中，如果希望变量实现+2的操作，有几种方法？？？(int num = 10)
    //方式一：num = num + 2;
    //方式二：num += 2;(推荐)

    //开发中，如果希望变量实现+1的操作，有几种方法？？？(int num = 10)
    //方式一：num = num + 1;
    //方式二：num += 1;
    //方式三：num++;(推荐)
  }
}

5.2 比较运算符

• ​​比较运算符的结果都是boolean型​​​，也就是​​要么是true，要么是false​​
• 比较运算符“==”不能误写成“=”

/*
运算符之三：比较运算符
==  !=  > < >= <= 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
  }
}

5.3 逻辑运算符

• & - 逻辑与

• && - 短路与

• | - 逻辑或

• | | - 短路或

• ！ - 逻辑非
• ^ - 逻辑异或

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写 成x>3 & x<6 。
• “&”和“&&”的区别：

• &：​​左边无论真假，右边都得进行运算​​；
• &&：​​如果左边为真，右边参与运算​​​；​​如果左边为假，那么右边不参与运算​​

• “|”和“| |”的区别同理，| |表示：​​当左边为真，右边不参与运算​​。
• 异或( ^ ) ：当左右都为true时，结果为false。

/*
运算符之四：逻辑运算符
  &   &&   |   ||   ！   ^

说明：
1. 逻辑与运算符操作的都是boolean类型的变量

*/
class LogicTest{
  
  public static void main(String[] args){
    //区分 & 与 &&
    //相同点1：& 与 && 的运算结果都相同
    //相同点2：当符号左边是true时，二者都会执行符号右边的运算
    //不同点：当符号左边是false时，&继续执行右边的运算，而 && 不再进行右边的运算
    //开发中，推荐使用 &&
    boolean b1 = true;
    int num1 = 0;
    if(b1 & (num1++ > 0)){
      System.out.println("我现在在南京");
    }else{
      System.out.println("我现在在北京"); //最后输出这句话，因为num1是先运算，再自增
    }
    System.out.println("num1 = " + num1); // 1

    boolean b2 = true;
    int num2 = 1;
    if(b2 && (num2-- > 0)){
      System.out.println("我现在在南京"); //最后输出这句话，因为num2是先运算，再自减
    }else{
      System.out.println("我现在在北京");
    }
    System.out.println("num2 = " + num2); // 0

    //区分：| 与 ||
    //相同点1：| 与 || 的运算结果都相同
    //相同点2：当符号左边是false时，二者都会执行符号右边的运算
    //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
    //开发中，推荐使用||
    boolean b3 = true;
    int num3 = 10;
    if(b3 | (num3++ > 0)){
      System.out.println("我现在在南京");
    }else{
      System.out.println("我现在在北京");
    }
    System.out.println("num3 = " + num3);

    boolean b4 = true;
    int num4 = 10;
    if(b4 || (num4++ > 0)){
      System.out.println("我现在在南京");
    }else{
      System.out.println("我现在在北京");
    }
    System.out.println("num4 = " + num4);
  }
  
}

5.4 位运算符

• 位运算是直接对整数的二进制进行的运算

• 注意：没有 <<< 这个符号

package cn.sxt.java;
/*
运算符之五：位运算符(了解)

结论：
1.位运算符操作的都是整型的数据变量
2.<< : 在一定范围内，每向左移一位，相当于 * 2
  >> : 在一定范围内，每向右移一位，相当于 / 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)); // 21 * 2 ^ 2
    System.out.println("i << 3 :" + (i << 3)); // 21 * 2 ^ 3
    System.out.println("i << 20 :" + (i << 20)); // 21 * 2 ^ 20
    System.out.println("i << 27 :" + (i << 27)); // 21 * 2 ^ 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;

    //方式一：
  //  int tent = num1;
  //  num1 = num2;
  //  num2 = tent;

    //方式二：
    //好处：不用定义临时变量
    //弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
//    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);
  }
}

class BitTest{
  public static void main(String[] args){
    //练习：交换两个变量的值
    int num1 = 10;
    int num2 = 20;

    //方式一：
  //  int tent = num1;
  //  num1 = num2;
  //  num2 = tent;

    //方式二：
    //好处：不用定义临时变量
    //弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
//    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);
  }
}

5.5 三元运算符

/*
运算符之六：三元运算符
1.结构：(条件表达式)？表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true,则执行表达式1
  如果表达式为false,则执行表达式2
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符是可以嵌套的
3. 凡是可以使用三元运算的地方，都是可以改写if-else。
   反之，可以用if-else的，不一定可以使用三元运算符
*/
class SanTest{
  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大";  //编译错误

    //****************************************
    String str = (m > n) ? "m大" : ((m == n)? "m和n相等" : "n大");
    System.out.println(str);

    //****************************************
    //获取三个数中的最大值
    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);

    //此方法：pass
    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);
    }
  }
}

运算符的优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
• 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的

6. 程序流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即

• 顺序结构
• 分支结构
• 循环结构

• 顺序结构

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

• 分支结构

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

• 循环结构

• 根据循环条件，重复性的执行某段代码
• 有while、do…while、for三种循环语句
• 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

6.1 顺序结构

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

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

分支结构：if-else使用说明

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但都建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓

• 当多个条件是“包含”关系时，“小上大下 / 子上父下”

/*
分支结构中的if-else（条件判断结构）
一、三种结构
第一种：
if(条件表达式){
  执行表达式
}
第二种：
if(条件表达式){
  执行表达式1
}else{
  执行表达式2
}
第三种：
if(条件表达式){
  执行表达式1
}else if{
  执行表达式2
}else if(条件表达式){
  执行表达式3
}
...
else{
  执行表达式n
}

*/
class IfTest{
  public static void main(String[] args){
    //举例1
    int heartBeats = 75;
    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类

具体步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化;
3.调用Scanner类的相关方法，来获取指定的变量。
*/
import java.util.Scanner;

class IFTest{
  public static void main(String[] args){
    //声明一个Scanner
    Scanner scan = new Scanner(System.in);

    int num = scan.nextInt();

    System.out.println(num);
  }
}

/*
如何从键盘获取不同类型的变量，需要使用Scanner类

具体步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化;
3.调用Scanner类的相关方法，来获取指定的变量。
*/
import java.util.Scanner;

class IFTest{
  public static void main(String[] args){
    //Scanner实例化
    Scanner scan = new Scanner(System.in);

    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 isLive = scan.nextBoolean();
    System.out.println(isLive);

    //char型的获取，Scanner没有提供相关方法，只能获取一个字符串
    System.out.println("请输入你的性别：(男/女)");
    String TF = scan.next();
    char TFChar = TF.charAt(0);
    System.out.println(TFChar);
  }
}

If-else练习

练习1

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

说明：
1.else结构是可选的。
2.针对于条件表达式：
  ① 如果多个条件表达式之间的关系是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓；
  ② 如果多个条件表达式之间是有交集的关系，需要根据实际情况，需要考虑实际情况，考虑清楚应该将哪个结构声明在上面。
  ③ 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会运行。
*/
import java.util.Scanner;
class IFTest02{
  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入岳小鹏的成绩：");
    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("奖励？学习去！！！");
    }
  }
}

练习2

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

*/
import java.util.Scanner;

class Sorting{
  public static void main(String[] args){
    //Scanner实例化
    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();

    int MaxNumber = 0;
    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);
      }
    }
  }
}

练习3

/*
我家的狗5岁了，5岁的狗相当于人类多大呢？
其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。
那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
如果用户输入负数，请显示一个提示信息。

*/
import java.util.Scanner;

class DogYear{
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入狗的年龄：");
    double Dyear = scan.nextDouble();
    if(Dyear <= 2 &&  Dyear > 0){
      System.out.println("狗的年龄等同于人的：" + Dyear * 10.5);
    }else if(Dyear <= 0){
      System.out.println("你输入的不正确。");
    }else{
      double number = 2 * 10.5 + (Dyear - 2) * 4;
      System.out.println("狗的年龄等同于人的：" + number);
    }    
  }
}

练习4

/*
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，
提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
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]

*/
import java.util.Scanner;

class CaiTest{
  public static void main(String[] args){
    //1、随机产生一个两位数
    //System.out.println(Math.random());//产生[0,1)
    int number = (int)(Math.random()*90 + 10);//得到[10,99]，即[10,100)
    //System.out.println(number);
    
    int numberShi = number/10;
    int numberGe = number%10;
    
    //2、用户输入一个两位数
    Scanner input = new Scanner(System.in);
    System.out.print("请输入一个两位数：");
    int guess = input.nextInt();
    
    int guessShi = guess/10;
    int guessGe = guess%10;
    
    if(number == guess){
      System.out.println("奖金10 000美元");
    }else if(numberShi == guessGe && numberGe == guessShi){
      System.out.println("奖金3 000美元");
    }else if(numberShi==guessShi || numberGe == guessGe){
      System.out.println("奖金1 000美元");
    }else if(numberShi==guessGe || numberGe == guessShi){
      System.out.println("奖金500美元");
    }else{
      System.out.println("没中奖");
    }
    
    System.out.println("中奖号码是：" + number);
  }
}

练习5

/*
大家都知道，男大当婚，女大当嫁。
那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；
富：财富1千万以上；帅：是。如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”

*/
import java.util.Scanner;

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

    System.out.println("请输入你的身高：(cm)");
    int height = scan.nextInt();
    System.out.println("请输入你的财富：(千万)");
    double weight = scan.nextDouble();
//    System.out.println("请输入你是否帅：(true/false)");
//    boolean isHandSome = scan.nextBoolean();

//    if(height >= 180 && weight >= 1 && isHandSome){
//      System.out.println("我一定要嫁给他!!!");
//    }else if(height >= 180 || weight >= 1 || isHandSome){
//      System.out.println("嫁吧，比上不足，比下有余。");
//    }else{
//      System.out.println("不嫁！");
//    }

    //方式二
    System.out.println("请输入你是否帅: (是or否)");
    String isHandsome = scan.next();

    if(height >= 100 && weight >= 1 && isHandsome.equals("是")){
      System.out.println("我一定要嫁给他!!!");
    }else if(height >= 180 || weight >= 1 || isHandsome.equals("是")){
      System.out.println("嫁吧，比上不足，比下有余。");
    }else{
      System.out.println("不嫁！");
    }
  }
}

6.3 分支语句2： switch-case结构

/*
分支结构之二：switch-case

1.格式
switch(表达式){
case 常量1:
  执行语句1;
  //break;
case 常量2:
  执行语句2;
  //break;
...
default:
  执行语句n:
  //break;
}

2.说明:
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，进入相应case结构中，执行相关语句。
  当调用完执行语句后，则仍然继续向下执行其他case语句，直到遇到break关键字或末尾结束为止。

② break, 可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。

③ switch结构中的表达式，只能是如下的六种数据类型之一：byte、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。不能声明范围。

⑤ break关键字是可选的。
⑥ default：相当于if-else结构中的else。
      default 结构是可选的，而且位置是灵活的。
*/

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

    int number = 2;
    switch(number){
    case 0:
      System.out.println("zero");
      break;
    case 1:
      System.out.println("one");
      break;
    case 2:
      System.out.println("twe");
      break;
    case 3:
      System.out.println("three");
      break;
    default:
      System.out.println("other");
      break;
    }

    //*********************************
    //运行报错，不能运行boolean类型
/*    boolean isHandSome = true;
    switch(isHandSome){
    case true:
      System.out.println("可乐吗？？");
      break;
    case false:
      System.out.println("薯条吗？？");
      break;
    default:
      System.out.println("输入有误！！！");
    }
*/
    //*********************************
    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;
    }

    //**************************************
    //运行报错
/*    int age = 10;
    switch(age){      
    case age > 18:
      System.out.println("成年了");
      break;
    default:
      System.out.println("未成年");
    } */
  }
}

switch-case练习

练习1

/*
使用switch 把小写类型的char型转为大写。只转换a, b, c, d, e. 其它的输出“other”。
提示：String word = scan.next();  char c = word.charAt(0); switch(c){}
*/
import java.util.Scanner;
class  SwitchCaseTest1{
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    String word = scan.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;
    case 'e':
      System.out.println("E");
      break;
    default:
      System.out.println("other");
    }
  }
}

练习2

/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明：如果switch-case语句中多个相同语句，可以进行合并。
*/
class  SwitchTest1{
  public static void main(String[] args){
    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;
    }
  }
}

练习3

/*
根据用于指定月份，打印该月份所属的季节。
3,4,5 春季6,7,8 夏季9,10,11 秋季12, 1, 2 冬季

*/
class MonthTest{
  public static void main(String[] args){
    int month = 6;
    switch(month){
    case 12:
    case 1:
    case 2:
      System.out.println("冬季");
      break;
    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;
    }
  }
}

练习4

/*
编写程序：从键盘上输入2020年的“month”和“day”，
要求通过程序输出输入的日期为2019年的第几天。
2 15 : 31 + 15

5 7: 31 + 28 +31 +30 + 7
...
说明：break在switch-case中是可选的。
*/
import java.util.Scanner;
class DayTest{
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入2020年的month");
    int month = scan.nextInt();
    System.out.println("请输入2020年的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 += 29;
    case 2:
      sumDays += 31;
    case 1:
      sumDays += day;
    }

    System.out.println("2020年" + month + "月" + day + "日是当年的第" + sumDays + "天");
  }
}

练习5

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除或
2）可以被400整除

说明:
1凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
2.我们写分支结构时,当发现既可以使用switch-case,〔(同时,switch中表达式的取值情况不太多),
又可以使用，我们优先选择使用switch-case。原因:switch-case执行效率稍高。

*/
import java.util.Scanner;
class YearDayTest{
  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:
      //判断是否为闰年
      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 + "天");
  }
}

练习6

/*
编写一个程序，为一个给定的年份找出其对应的中国生肖。
中国的生肖基于12年一个周期，每年用一个动物代表：
rat、ox、tiger、rabbit、dragon、snake、horse、sheep、monkey、rooster、dog、pig。
提示：2019年：猪2019 % 12 == 3
*/
import java.util.Scanner;
class ZodiacSignTest{
  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入年份：");
    int year = scan.nextInt();
    switch (year % 12){
    case 1:
      System.out.println("rooster");
      break;
    case 2:
      System.out.println("dog");
      break;
    case 3:
      System.out.println("pig");
      break;
    case 4:
      System.out.println("rat");
      break;
    case 5:
      System.out.println("ox");
      break;
    case 6:
      System.out.println("tiger");
      break;
    case 7:
      System.out.println("rabbit");
      break;
    case 8:
      System.out.println("dragon");
      break;
    case 9:
      System.out.println("snake");
      break;
    case 10:
      System.out.println("horse");
      break;
    case 11:
      System.out.println("sheep");
      break;
    case 12:
      System.out.println("monkey");
      break;
    }
  }
}

6.3.1 switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？

• 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。也就是说，使用switch-case的，都可以改写为if-else。反之则不成立。

6.4 循环结构

• 循环结构

• 在某些条件满足的情况下，反复执行特定代码的功能

• 循环语句分类

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

6.5 循环结构1： for循环

语法格式
for(①初始化部分;②循环条件部分;④迭代部分)｛
            ③循环体部分;
｝


执行过程：①-②-③-④-②-③-④-②-③-④-.....-②


说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔

/*
For循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件
③ 循环体
④ 迭代条件

二、for循环的结构
for(①;②;④){
  ③
}
*/
class ForTest{
  public static void main(String[] args){
    for(int i=1;i <= 5 ;i++){
      System.out.println("Hello World!");
    }

    //练习：
    int num = 1;
    for(System.out.print('a');num <= 3;System.out.print('c'),num++){
      System.out.print('b');
    }

    //遍历100以内的偶数,获取所有偶数的和,输出偶数的个数
    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);
    System.out.println("个数为：" + count);
  }
}

for循环练习

练习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();
    }
  }
}

练习2

/*
输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。说明：break关键字的使用

*/
import java.util.Scanner;
class GnumberTest{
  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入m:");
    int m = scan.nextInt();
    System.out.println("请输入n:");
    int n = scan.nextInt();
    //获取m和n的较大值
    int max = (m > n) ? m : n;
    //获取m和n的最小值
    int min = (m < n) ? m : n;
    
    //求最大公约数
    for(int i = min;i >= 1;i--){
      if(m % i == 0 && n % i == 0){
        System.out.println("m和n的最大公约数：" + i);
        break;
      }
    }

    //求最小公倍数
    for(int i = max;i <= m * n;i++){
      if( i % m == 0 && i % n == 0){
        System.out.println("m和n的最小公倍数是：" + i);
        break;
      }
    }
  }
}

练习3

/*
输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。说明：break关键字的使用

*/
import java.util.Scanner;
class GnumberTest{
  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    System.out.println("请输入m:");
    int m = scan.nextInt();
    System.out.println("请输入n:");
    int n = scan.nextInt();
    //获取m和n的较大值
    int max = (m > n) ? m : n;
    //获取m和n的最小值
    int min = (m < n) ? m : n;
    
    //求最大公约数
    for(int i = min;i >= 1;i--){
      if(m % i == 0 && n % i == 0){
        System.out.println("m和n的最大公约数：" + i);
        break;
      }
    }

    //求最小公倍数
    for(int i = max;i <= m * n;i++){
      if( i % m == 0 && i % n == 0){
        System.out.println("m和n的最小公倍数是：" + i);
        break;
      }
    }
  }
}

6.6 循环结构2： while循环

语法格式
    ①初始化部分
    while(②循环条件部分)｛
        ③循环体部分;
        ④迭代部分;
    }

执行过程：①-②-③-④-②-③-④-②-③-④-…-②
  
说明：
1.注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环
2.for循环和while循环可以相互转换

/*
While循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件
③ 循环体
④ 迭代条件

二、while循环的结构
①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
}

执行过程： ① - ② - ③ - ④ - ② -  ③ - ④ - ... - ② 

说明：
1.写while循环千万要小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.写程序要避免死循环。
3.能用while循环的，可以用for循环，反之亦然。二者可以相互转换。
区别：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++;
        }
    }
}

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

6.7 循环结构3： do-while循环

do-while循环结构的使用
一、循环结构的四个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件

二、do-while循环的结构
①
do{
  ③;
  ④;
}while(②);

执行过程：① - ③ - ④ - ② - ① - ③ - ④ - ... - ②
 
说明：do-while循环至少执行一次循环体。

do-while循环练习

练习1

class DoWhileTest{
  public static void main(String[] args){
    //遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数
    int number = 1;
    int sum = 0;  //记录总和
    int count = 0;  //记录个数
    do{
      if(number % 2 == 0){
        System.out.println(number);
        sum += number;
        count++;
      }
      number++;
    }while(number <= 100);

    System.out.println("总和为：" + sum);
    System.out.println("个数为：" + count);

    //*********************************
    int numb = 10;
    while(numb > 10){
      System.out.println("hello:while");
      numb--;
    }

    int numb2 = 10;
    do{
      System.out.println("hello：do-while");
      numb2--;
    }while(numb2 > 10);
  }
}

练习2

/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1.不在循环条件部分限制次数的结构：while(true) , for(true)
2.结束循环的几种方式：
  方式一：循环条件部分返回false;
  方式二：在循环体中，执行break;
*/
import java.util.Scanner;
class XunTest{
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int Positive = 0;  //正数个数
    int Negative = 0;  //负数个数
    while(true){
      int number = scan.nextInt();
      if(number > 0){
        Positive++;
      }else if(number < 0){
        Negative++;
      }else{
        //一旦执行，跳出循环。
        break;
      }  
    }

    System.out.println("正数的个数：" + Positive);
    System.out.println("负数的个数：" + Negative);
  }
}

6.8 嵌套循环结构

嵌套循环(多重循环)

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环或内层循环
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开 始下一次的循环
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

嵌套循环练习

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A
3.说明
① 内层循环遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次

4.技巧
外层循环控制行数，内层循环控制列数
*/
class  ForForTest{
  public static void main(String[] args) {
    //******
    for(int i = 1;i <= 6;i++){
      System.out.print("*");
    }
    System.out.println();//换行
    System.out.println("--------------------");

    /*
    ******
    ******
    ******
    ******
    */
    for(int i = 1;i <= 4;i++){  
      for(int j = 1;j <= 6;j++){  
        System.out.print('*');
      }
      System.out.println();  //换行
    }
    System.out.println("--------------------");
    /*
    *
    **
    ***
    ****
    *****
    */
    for(int i = 1;i <= 5;i++){  //控制行数
      for(int j = 1;j <= i;j++){  //控制列数
        System.out.print("*");
      }
      System.out.println();
    }
    System.out.println("--------------------");
    /*
    *****
    ****
    ***
    **
    *
    */
    for(int i = 1;i <= 6;i++){
      for(int j = 1;j <= 6-i;j++){
        System.out.print("*");
      }
      System.out.println();
    }
    System.out.println("--------------------");
    /*
    *
    **
    ***
    ****
    *****
    ****
    ***
    **
    *
    */
    for(int i = 1;i <= 5;i++){
      for(int j = 1;j <= i;j++){
        System.out.print("*");
      }
      System.out.println();
    }

    for(int i = 1;i <= 5;i++){
      for(int j = 1;j <= 5-i;j++){
        System.out.print("*");
      }
      System.out.println();
    }
    System.out.println("--------------------");

    //九九乘法表
    for(int i = 1;i <= 9;i++){
      for(int j = 1;j <= i;j++){
        System.out.print(i + "*" + j + "=" + i*j + " ");
      }
      System.out.println();  //换行
    }

  }
}

练习2

/*
100以内的所有质数
质数：素数，只能被1和它本身整除的自然数。

最小的质数是：2
*/
class PrimeNuberTest{
  public static void main(String[] args){
    boolean isFlag = true;  //标识是否被除尽，一旦除尽，修改其值。

    for(int i = 2;i <= 100;i++){  //遍历100以内的自然数
      for(int j =2;j < i;j++){  //j:被i去除
        if(i % j == 0){  //i被j除尽
          isFlag = false;
        }
      }
      if(isFlag == true){
        System.out.println(i);
      }

      //重置isFlag
      isFlag = true;
    }
  }
}

练习2的优化

/*
100000以内的所有质数
质数：素数，只能被1和它本身整除的自然数。

最小的质数是：2
*/

class PrimeNuberTest{
  public static void main(String[] args){
    boolean isFlag = true;  //标识是否被除尽，一旦除尽，修改其值。
    int count = 0;  //记录质数的个数

    //获取当前时间举例1970-01-01 00:00:00 的毫秒数
    long start = System.currentTimeMillis();

    for(int i = 2;i <= 100000;i++){  //遍历100以内的自然数
      //优化2：对本身是质数的自然数有效 5447---> 11
    //  for(int j =2;j < i;j++){ //j:被i去除
      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));  //16843 --> 5447 优化一
  }
}

6.9 特殊关键字的使用： break、continue

break的使用

break语句
  break语句用于终止某个语句块的执行
    {    
    ......
    break;
    ......
    }

  break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
      label1:  {  ......
      label2:    {  ......
      label3:      {  ......
                break label2;
                ......
                  }
                }
              }

continue的使用

continue 语句

• continue​​只能使用在循环结构中​​
• continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
• continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

return的使用

• return：​​并非专门用于结束循环的​​​，​​它的功能是结束一个方法​​。当一个方法执行到一个return语句时，这个方法将被结束。
• 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

6.9.1 特殊流程控制语句说明

• ​​break只能用于switch语句和循环语句中​​
• ​​continue 只能用于循环语句中​​
• 二者功能类似，但​​continue是终止本次循环​​​，​​break是终止本层循环​​
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面
• 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。

/*
break和countinue关键字的使用
            使用范围               循环中使用的作用(不同点)              相同点
break:    switch-case、循环结构中      结束当前循环              关键字后面不能声明执行语句
           

countinue:  循环结构中                结束当次循环               关键字后面不能声明执行语句

*/
class BreakContinueTest{
  public static void main(String[] args){
    
    for(int i = 1;i <= 10;i++){
      if(i % 4 == 0){
      //  break;  //1、2、3
        continue;  //1、2、3、5、6、7、9、10
      //  System.out.println("该吃饭了！！！");
      }
    //  System.out.println(i);
    }
    //********************************
    for(int i = 1;i <= 4;i++){
      
        for(int j = 1;j <= 10; j++){
          if(i % 4 == 0){
        //    break;  //默认跳出包裹此关键字最近一层的循环
            continue;
          }
          System.out.print(j);
        }
        System.out.println();
    }
  }
}