03. Java运算符&分支语句&循环

Java运算符&分支语句&循环

1.运算符

运算符：对常量或者变量进行操作的符号。

运算符基本分为五类：

• 赋值运算符 (=，+=，-=，*=，/=，%=，++，–）
• 算术运算符(+，-，*，/，%，++，–）
• 关系运算符(>，>=，<，<=，==，!=)
• 逻辑运算符(&，&&，|，||，!)
• 三元运算符(判断语句 ? 表达式1 : 表达式2)

1.1 赋值运算符

将等号右边的值赋值给等号左边的值。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

赋值运算符拓展：

赋值运算符可以与算数运算符，位移运算符结合，扩展成为更强大的运算符。称之为扩展赋值运算符。在赋值运算符（=）前加上其他运算符，即构成扩展赋值运算符。

例如，下面两行是等价的：

a + = 6 ;

a = a + 6 ;

扩展赋值运算符有11个，下表给出了所有的扩展的赋值运算符及其使用方法。只要能使用了这种扩展后的赋值运算符，通常都推荐使用它们，因为这种运算符不仅能有更好的性能，而且程序会更加健壮。

下面是Java语言支持的扩展赋值运算符：

注意：

拓展的赋值运算符隐含了强制类型转换

short s = 10; 
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度 
s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

1.2算数运算符

示例：

		//算数运算符
		int in = 10;
        double dl = 3.3 + 10 + 'a';
        System.out.println(3 * 3);
        System.out.println("商：" + 10 / 3);
        System.out.println("余数：" + 10 % 3);

++ 自增 如果放在前面先自增再赋值，如果放在后面是先赋值再自增

- - 自减 如果放在前面先自减再赋值，如果放在后面是先赋值再自减

		int a = 10;
        int b = ++a;// ++ 自增 如果放在前面先自增再赋值，如果放在后面是先赋值再自增
        System.out.println("a的值："+a);//11
        System.out.println("b的值："+b);//11

        int c = 20;
        int d = c--;// -- 自减
        System.out.println("c的值："+c);//19
        System.out.println("d的值："+d);//20

1.3 关系运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假(非真)。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）非真。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

示例：

public class Test {
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a==b : " + (a == b) ); // a==b : false
     System.out.println("a!=b : " + (a != b) ); // a!=b : true
     System.out.println("a>b : " + (a > b) ); // a>b : false
     System.out.println("a<b : " + (a < b) ); // a<b : true
     System.out.println("b>=a : " + (b >= a) ); // b>=a : true
     System.out.println("b<=a : " + (b <= a) ); // b<=a : false
  }
}

1.4 逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假。

示例：

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b)); // false
     System.out.println("a || b = " + (a||b) ); // true
     System.out.println("!(a && b) = " + !(a && b));  // true
  }
}

短路逻辑运算符

​ 当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

public class Test {
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        // 首先判断 a<4 的结果为 false，则 b 的结果必定是 false，
        // 所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。
        boolean b = (a<4) && (a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b); // false
        System.out.println("a的结果为"+a); // 5
    }
}

1.5 三元运算符

三目运算符是一个特殊的运算符，它的语法形式如下：

布尔表达式？表达式1：表达式2

运算过程：如果布尔表达式的值为true，就返回表达式1的值，否则返回表达式2的值，例如：

int sum=90;String str=sum<100 ? "失败" : "成功";

等价于下列代码：

String str = null;
if(num<100){
  str="失败";
}else{
  str="成功";
}

三目运算符和if…else语句相比，前者使程序代码更加简洁。

2.数据输入

通过Scanner类来获取用户的输入。使用步骤如下：

1.导包：

import java.util.Scanner;

2.创建Scanner对象

Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

3.接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

示例：

import java.util.Scanner;
public class ScannerDemo { 
	public static void main(String[] args) { 
		//创建对象 
		Scanner sc = new Scanner(System.in); 
		//接收数据 
		int x = sc.nextInt(); 
		//输出数据 
		System.out.println("x:" + x); 
	}
 }

3.流程控制语句

​ 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

3.1流程控制语句分类

• 顺序结构
• 分支结构(if, switch)
• 循环结构(for, while, do…while)

3.2顺序结构

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

顺序结构执行流程图：

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

3.3分支结构

3.3.1 if语句

if语句格式1：

if (条件) {
	代码块; 
}

执行流程：

①首先判断条件

②如果条件为true就执行代码块

③如果条件为false就不执行代码块

④继续执行后面的语句内容

示例：是否大于60

	//简单的if语句：
	//成绩如果大于60   给奖励
	int score = 10;
	if(score>60){
		System.out.println("给颗糖");
	}	

if语句格式2：

if (条件) { 
		代码块; 
	} else { 
		代码块2;
    }

执行流程：

①首先判断条件

②如果条件为true就执行代码块1

③如果条件为false就执行代码块2

④继续执行后面的语句内容

示例：

public class IfDemo02 { 
    public static void main(String[] args) {
        System.out.println("开始"); //定义两个变量 
        int a = 10; 
        int b = 20; 
        b = 5; 
        //需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b 
        if(a > b) { 
            System.out.println("a的值大于b"); 
        } else { 
            System.out.println("a的值不大于b"); 
        }System.out.println("结束");
    } 
}

if语句格式3：

if (关系表达式1) { 
	语句体1; 
} else if (关系表达式2) { 
	语句体2; 
}…else {
	语句体n+1;
}

执行流程：

①首先判断条件

②如果条件为true就执行代码块1；如果条件为false就判断条件2的值

③如果条件为true就执行代码块2；如果条件为false就判断条件3的值

④…

⑤如果没有条件为true，就执行代码块n+1。

示例：输入四个季节：如果春天，输出“春暖花开”，如果是夏天，输出“夏日炎炎”,如果是秋天，则输出"秋高气爽",如果是冬天，则输出"安静祥和"。

import java.util.Scanner;

class  Demo
{
	public static void main(String[] args) 
	{
		//  == 判断基本数据类型内容是否相等
		// 引用数据类型  ==  判断内存地址 
		// 判断内容  String 类型 判断内容 equals
		Scanner sc = new Scanner(System.in);
		String str = sc.next();	
	//	boolean falg= str.equals("春天");
       if(str.equals("春天")){
   			System.out.println("春暖花开");
   		}else if(str.equals("夏天") ){
   			System.out.println("夏日炎炎");
   		}else if(str.equals("秋天")){
   			System.out.println("秋高气爽");
   		}else if(str.equals("冬天")){
   			System.out.println("安静祥和");	
   		}
   	}
}

不建议使用。

3.3.2 switch语句

switch格式：

switch (表达式) { 
    case 1: 语句体1;
        break;
    case 2: 语句体2;
        break; 
    ...
    default: 语句体n+1;
        break; 
}

执行流程：

• 首先计算出表达式的值
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
• 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch规则：

1. switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开 始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面 量。
2. switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
3. case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字 面常量。
4. 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
5. 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
6. switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分 支（可以在任何位置，但一般在最后一个）。default 在没有 case 语句的值和变 量值相等的时候执行。default 分支不需要 break 语句。（如果case语句中没有break 语句，程序会一直执行到default 分支）

示例：

public class Demo1 { 
    public static void main(String[] args) { 
        //键盘录入月份数据，使用变量接收 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt(); 
        //case穿透 
        switch(month) { 
            case 1:
            case 2: 
            case 12:
            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;
            default:
            System.out.println("你输入的月份有误"); 
        }
    }
}

**注意：**如果switch中得case，没有对应break的话，则会出现case穿透的现象。

3.3.3 for循环

格式：

for (初始化语句;条件判断语句;条件控制语句) { 
	循环体语句;
  }

格式解释：

• 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
• 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
• 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
• 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

循环：

​ 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。

下列列出一些循环变体：

for循环变体：A（初始化语句），B（条件判断语句），C（条件控制语句）

变体一：语句丰富化多样化，只要保证语句A、C都是一条语句，语句B是布尔表达式，语句想怎么写由你自己定。

for(int i = 0, j = 0; i < 10 | j< 12; i++, j++) { 
       System.out.println(i); 
       System.out.println(j); 
}

变体二：语句A省略

boolean flag =true; 
int m =0; 
for(;flag; m++){ 
      if(m==10) 
      flag=false; 
      System.err.println(m); 
 
}

变体三：语句B省略，此时只有从循环体内退出循环，否则是无限循环。

int m =0; 
for(;;){ 
      if(m==10) 
            break; 
      System.err.println(m); 
      m++; 
}

**说明：**以上的变体，只是相对于我们常用的形式来讲的，变体的结构本质是不变的，我们没必要去刻意的使用变体的形式。上面并未列出所有变体，简单来说，语句A，B，C都是可以单独省略的。

3.3.4 while循环

while循环格式：

初始化语句; 
while (条件判断语句) { 
     循环体语句; 
     条件控制语句;
 }

while循环执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

示例代码：

public class WhileDemo { 
    public static void main(String[] args) { 
        //需求：在控制台输出5次"HelloWorld" 
        //for循环实现 
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------"); 
        //while循环实现 
        int j = 1; 
        while(j<=5) {
            System.out.println("HelloWorld"); 
            j++;
        } 
    } 
}

3.3.5 do…while循环

do…while循环格式：

初始化语句;
do {
	循环体语句;
    条件控制语句; 
}while
    (条件判断语句);

执行流程：

① 执行初始化语句

② 执行循环体语句

③ 执行条件控制语句

④ 执行条件判断语句，看其结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

⑤ 回到②继续

示例代码：

public class DoWhileDemo { 
    public static void main(String[] args) { 
        //需求：在控制台输出5次"HelloWorld" 
        //for循环实现 
        for(int i=1; i<=5; i++) { 
            System.out.println("HelloWorld"); 
        }
        System.out.println("--------"); 
        //do...while循环实现 
        int j = 1; 
        do {
            System.out.println("HelloWorld"); 
            j++; 
        }while(j<=5); 
    }
}

3.3.6 三种循环的区别

三种循环的区别

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
• do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）

for循环和while的区别

• 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
• 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

死循环（无限循环）的三种格式

1. for( ; ; ){}
2. while(true){}
3. do {} while(true);

3.3.7 跳出控制语句

跳转控制语句（break）

• 跳出循环，结束循环

跳转控制语句（continue）

• 跳过本次循环，继续下次循环

注意： continue只能在循环中进行使用！