【JavaSE】前期总结之运算符和语句

2.JavaSE运算符和语句

2.1运算符

​ 运算符规定了数据计算的规则。运算符有两种分类方法：一种按运算符功能分类，另一种按运算符链接数据个数分类。

​ 运算符按功能分为7种：赋值运算符、算数运算符、关系运算符、逻辑运算符、条件运算符、条件运算符、位运算符、其他运算符。

​ 运算符按链接数据个数分为3种：一元运算符(连接1个数据)、二元运算符(连接两个数据)、三元运算符(连接三个数据)。

2.1.1 赋值运算符

​ 1.赋值运算的格式

​ 赋值运算符是"="。其格式如下：

​ 变量名 = 表达式；（首先计算出表达式的值，然后把计算的结果赋给左边的变量）

​ 2.赋值运算符的运用

​ 赋值运算符的作用是给符号 “=” 左边的变量赋值。例如：

   int y = 1; //把1赋给y
	 float z = y*22 +32; //先计算y*22+32，把结果赋值给z，打印结果为54.0

2.1.2 算数运算符

​ 1.算数一元运算符

​ （1）算数一元运算符包括 “+” “-”。例如

		+98;//表示正数98
		-97;//表示负数97

​ （2）自增自减运算符

				自增运算符 "++"  使变量值增1。

​ 自减运算符 " — " 使变量值减1。

​ 这里的变量必须是整型或者浮点型。例如：

		++x;	//先使x的值加1，再使用x
		x++;	//先使用x之后，再使x的值加1
		--x;	//先使x的值减1，再使用x
		x--;	//先使用x之后，再使x的值减1

​ 2.算数二元运算符

​ （1）加减运算符

​ 加减运算符的操作类型数据是整型或者浮点型。例如：

		7+8-5;

​ （2）乘除 和 求余运算符

​ “*” （乘）、"/" （除）、"%" （求余）运算符的优先级是3级，其结合方向是从左到右。

​ 乘除运算符的操作数据类型是整型或者浮点型。例如：

		5*3/5  //先计算5*3 ，然后得到的结果除以5
    12%5	//求余运算，计算的结果是2.其计算过程：12除以5，商2余2，得到的余数2就是结果

2.1.3关系运算符

 包括 > 、 <  、 >= 、<= 、== 、!=   用变量或表达式和关系运算符构成的语句称为关系表达式，关系运算的结果为boolean类型的值。例如

 	8 > 9 //运算结果为false
  3 >= 2 //运算结果为true
  'A' < 'a' //运算结果为true，因为字符'A'的unicode编码值小于字符'a'的相应值

2.1.4 逻辑运算符

​ （1）逻辑非 ！：用于对变量、函数等对象的逻辑值取反。、

​ （2）逻辑与& ：用于逻辑表达式中，符号两边的值都需要计算。只有两边都成立，表达式结果才为真。

​ （3）逻辑或| ：用于逻辑表达式中，符号两边的值都需要计算。只要两边任何一个成立，表达式结果就为真，当 | 左边的值计算结果为真时，仍需要计算 | 右边的值。

​ （4）逻辑异或^ ： 在逻辑表达式中，当符号两边的值不同的时候，表达式结果为真。

​ （5）逻辑短路与&& ： 用于逻辑表达式中，符号两边的值不需要都计算。对于表达式A && B，当A为false，不计算B的值直接返回false，而当A为true时，再计算B的值，当AB都为true，返回结果true，如果A为true，B为false，则返回false。

​ （6）逻辑短路或|| ：类似&&。对于表达式 A || B，当A为true时，不计算B的值直接返回true；当A为false时，计算B的值，如果B为true，则返回true，如果B为false，则返回false；

//分析一下&& 和 & 的差别
  	public static void main(String[] args) {
        int i = 10,j = 3,b = 3,c = 3,d = 3;
        if(j >= i && b++ > 3){
            i++;
        }
        if(j >= i & d++ > 3){
            j++;
        }
        System.out.println("b的值为："+b);
        System.out.println("d的值为："+d);
    }
			

//打印结果为 b的值为：3
//         d的值为：4

2.1.5 位运算符

​ 位运算符针对二进制位进行运算，分为以下4种。

​ （1）按位取反～

​ 对某二进制位取反。例如，～1 = 0;

​ (2) 按位与&

​ 两变量的对应二进制位向与。

​ 例如，111 & 010 = 010。

​ （3）按位异或^

​ 两变量的对应二进制位异或。

​ 例如，111 ^ 011 = 100。

​ （4）按位或 |

​ 两变量对应二进制位相或。

​ 例如，111 | 110 = 111。

2.1.6 条件运算符

​ 条件运算符包括"?" 和 “:”,是三元运算符。条件表达式的格式如下：

  conditionExpression? dataExpression1 : dataExpression2

​ conditionExpression 是逻辑或关系表达式。若conditionExpression 的值是true，则整个表达式的值是dataExpression1；若conditionExpression的值是false，则整个表达式的值是dataExpression2。

例如：

			int a = 5, b = 2,result;
			if(a > b){
        result = a - b;
      }else{
        result b - a;
      }

以上if语句等价于下面的语句：

result = a > b ? a-b : b-a;

2.1.7 其他运算符

1.点运算符

​ 点运算符 “.” 用来访问对象（或类）的成员变量或成员方法。

2.new 运算符

​ 可以用new运算符创建一个对象或一个数组。

3.instanceof运算符

​ instanceof运算符是二元运算符。常用格式如下：

object instanceof type_name

上面是一个表达式，其运算结果的数据类型是boolean类，其中，object是一个对相，type_name是一个类。当object是type_name类创建的对象时，该运算符运算的结果是true，否则是false。

2.2 语句

​ Java语句按格式分为六种。在Java源文件中，包命名语句package和包引用语句import 放在类和接口定义之外（其中包命名语句放在Java源文件的第一行），其他的语句都放在放在方法体中。每个语句的最后必须有分号。

​ 1.方法调用语句

​ 在方法最后加上一个分号，就构成了一个方法调用语句。例如：

	System.out.println("方法调用语句");  //该语句是调用方法print()

​ 2.表达式语句

​ 一个表达式的最后加上一个分号，就构成了和一个表达式语句。例如：

 z = a + b + 23;

​ 3.复合语句

​ 用{}把一些语句括起来便构成了复合语句。例如：

{
  z = x + y + 123;
  t = n + v + z;
  System.out.println("Hello World"+t)
}

​ 4.package语句

​ 包命名语句的作用是为包命名。包命名语句必须放在源文件的第一行。例如：

  package java.moon;

  5.import语句

​ 包引用语句主要用于引用包中的类。例如：

  import java.sun.*;

​ 6.控制语句

​ 控制语句用于控制程序执行的顺序。控制语句包括选择语句、循环语句和跳转语句。

2.2.1 选择语句

​ 选择语句依据条件表达式的值，可以改变程序执行的顺序。选择语句分为两大类，即条件语句和开关语句（Switch）。

1.条件语句

​ 条件语句可以分为三种。

（1）if 语句

​ if语句的格式：

	 if(条件表达式){
     语句组;
   }

​ if语句执行过程：

​ 当条件表达式的值为true时，则执行后面的语句组；当表达式的值为false，则跳到if语句下面的语句开始执行。

（2）if…else语句

if…else语句的格式如下：

	if(条件表达式)
  {
    语句组1;
  }else{
    语句组2;
  }

当条件表达式的值为true时，则执行语句组1，若条件表达式的值为false，则执行语句组2。

(3) if … else if嵌套语句

 格式如下

if(条件表达式1){
  语句组1;
}else if(条件表达式2){
  语句组2;
  ...
}else if(条件表达式n){
  语句组n;
}else{
  语句组m;
}

Java解释器从上到下依次测试条件表达式的值，当某个条件表达式的值为false时，继续测试下一个条件表达式的值； 当某个条件表达式的值为true时，则执行此语句表达式的语句组，忽略其他的语句组，如果最后有else{}，那么这里的else{}的意思是上面的条件表达式都为false时，则执行语句组m。

例如：

 public static void main(String[] args) {
        double stuGrade;
        System.out.println("请输入学生的成绩：");
        Scanner scanner = new Scanner(System.in);
        String line = scanner.nextLine();
        stuGrade = Double.parseDouble(line);
        if(stuGrade >= 0 && stuGrade < 60){
            System.out.println("不及格");
        }else if(stuGrade >= 60 && stuGrade <= 100){
            System.out.println("及格");
        }else{
            System.out.println("输入有误");
        }
    }
 // 输入32，结果为不及格
 // 输入89，结果为及格
 // 输入-100，结果为输入有误

（4）if的嵌套语句

	if(条件表达式1)
  {
    
    if(条件表达式2)
    {
      语句块2;
    }
    语句块1;
  }	

​ 由代码可以看出，当条件表达式1的值为true时才进入第一个if语句，然后判断条件表达式2的值是否为true，如果为真，那么执行语句块2，然后再执行语句块1，如果条件表达式2为false时，只执行语句块1。

public static void main(String[] args) {
        int i = 10;
        int j = 5;
        if(i > 0){
            if(j > 0){
                System.out.println(j);
            }
            System.out.println(i);
        }
    } //打印结果为  5  10

public static void main(String[] args) {
        int i = 10;
        int j = -1;
        if(i > 0){
            if(j > 0){
                System.out.println(j);
            }
            System.out.println(i);
        }
    }//打印结果为 10

2. switch开关语句

​ switch(表达式)

​ {

​ case 常量1：

​ 多个语句;

​ break;

​ case 常量2:

​ 多个语句;

​ case 常量3：

​ 多个语句;

​ [default: 多个语句;]

​ }

  public static void main(String[] args) {
        int moneyType;
        System.out.println("请输入币种：1人民币 2美元 3越南盾");
        Scanner scanner = new Scanner(System.in);
        moneyType = scanner.nextInt();
        switch (moneyType){
            case 1:
                System.out.println("人民币");
                break;
            case 2:
                System.out.println("美元");
                break;
            case 3:
                System.out.println("越南盾");
                break;

                default: //默认值
                     System.out.println("人民币");
                     break;
        }
    }
//输入1输出人民币，输入2输出美元，输入3输出越南盾

值得注意的是如果case语句下没有写break关键字，那么程序会继续往下执行知道遇到break关键字或者到程序结束为止。

	 public static void main(String[] args) {
        int moneyType;
        System.out.println("请输入币种：1人民币 2美元 3越南盾");
        Scanner scanner = new Scanner(System.in);
        moneyType = scanner.nextInt();
        switch (moneyType){
            case 1:
                System.out.println("人民币");

            case 2:
                System.out.println("美元");

            case 3:
                System.out.println("越南盾");


                default: //默认值
                     System.out.println("人民币");
                 break;    
        }
    }
//输入1输出人民币 美元 越南盾 人民币   如果去掉break之后的break，输出结果不变，因为此时程序结束。

2.2.2 循环语句

​ Java语言中3种重要的循环结构包括for循环语句，while循环语句，do…while循环语句。

1. for循环语句

   (1) for循环语句的格式

   for(表达式1;表达式2;表达式3;)
     
   			{
   				语句组;  //也称为循环体
         }
   

   表达式1: 对变量初始化，只执行一次。

   表达式2: 条件表达式，当表达式2为真时，继续执行循环体。

   表达式3: 调整表达式2中的变量值，以便改变表达式2的值。

   语句组：称为循环体。

   (2) for循环执行的过程

   ​ 首先计算表达式1，完成变量初始化。再测试表达式2的值，若表达式2的值为true，则执行循环体。执行完循环体之后紧接着计算表达式3，一次循环结束，然后下次又从计算表达式2开始，若表达式2的值仍为true则继续执行语句组，否则跳出整个for循环，执行for语句后面的语句。

   (3) 另外两种结构

   表达式1;
   for(;条件表达式;表达式2)
   {
     循环体;
   }
   

   表达式1;
   for(;条件表达式;)
   {
     语句块;
     表达式2;
   }
   

​ 例如：

public static void main11(String[] args) {//计算10的阶乘
        int i = 1;//此时的整型变量i是在for循环体外定义的，也可以在for循环体内声明，此时i的作用域为整个类
        int result = 1;
        for(;i < 11;i++){
            result *= i;
        }
        System.out.println("10的阶乘是："+result);
    }//打印结果为10的阶乘是3628800

   public static void main12(String[] args) {//打印乘法口诀
        for(int i = 1;i <= 9;i++){//for循环的嵌套
            for(int j = 1;j <= i; j++){
                System.out.print( j+"x"+i+ "="+ i * j+"\t");
            }
            System.out.println();
        }
    }

  //10个斐波那契数
    public static void main(String[] args) {
        int[] str = new int[10];
        System.out.println(str[0] = 1);
        System.out.println(str[1] = 1);
       	int i = 2;
        for(; i < str.length;i++){

            str[i] = str[i - 1] + str[i - 2];
            System.out.println(str[i]);
        }
    }

2.while语句

while(条件表达式)
{
  语句块;
}

while为关键字，条件表达式的值为布尔值，为真时才执行循环体中的语句，否则不执行。

例如：

//求1到100之间所有整数只和
public static void main(String[] args){
  int result = 0;
  int i = 1;
  while(i >= 1 && i <= 100){
    result = result + i;
    i++;
  }
  System.out.println(result);
}//结果为5050

3. do…while语句

do … while 语句可以实现循环，与以上两种循环不同的特点是，先执行一遍循环体然后再判断条件是否满足。

do
{
  语句块;
}while(条件表达式);

do 和 while 是关键字。语句块是即将实现的内容。条件表达式可以是关系表达式、逻辑表达式、布尔值、方法等。条件表达式的值为布尔值

4. 循环语句嵌套

   for(表达式1;条件表达式1;表达式2){
     for(表达式3;条件表达式2;表达式3){
       语句块;
     }
   }
   

   while(条件表达式1){
     while(条件表达式2)
   }
   

    for(表达式1;条件表达式2;表达式2){
   
      	while(条件表达式2)
   
      				{
          					语句块;
      	      }
   
      }
   
   
   

   例如：

   public static void main(String[] args) {
           for(int i = 0; i < 5 ;i++){
               for(int j = i; j < 5;j++){
                   System.out.print("$");
               }
               System.out.print("&");
           }
       }//打印结果为$ $ $ $ $ & $ $ $ $ & $ $ $ & $ $ & $ & &
   

   5.跳转语句

   ​ (1) break

   ​ break用于结束整个循环，如果是嵌套的多层循环，那么用于结束当前层次的循环。

   ​ switch语句中，case语句结束之后如果没有加break关键字那么程序会继续往下执行，直到程序结束或者遇到break关键字。

   ​ (2) continue

   ​ continue 跳转语句的作用是强制一个循环体前返回也就是让循环继续执行，但不执行本次循环剩余的循环体中的语句。

   public static void main(String[] args) {
           for(int a = 0; a < 10; a++){
               System.out.print(a);
               if(a % 2 == 0){
                   continue;
               }
               System.out.println("$");
           }
       }
   /* 打印结果为 01$ 
   						23$
   						45$
   						67$
   						89$
   */
   

   分析：从for循环开始，a = 0，先打印 0，然后通过if语句判断 0 % 2 == 0 为真，所以执行continue语句，使循环体之后的语句不执行直接进入下一次循环，然后打印1，此时 1 % 2 == 0 为假，continue不执行，打印$，打印结果就如此可见了。

   ​ (3) return

   ​ 可以使用return语句返回一个值，并把控制权交给调用它的语句。在java程序中使用return语句的语法如下：

   return [表达式];//其中表达式是可选参数，表示要返回的值，他的数据类型必须与方法声明中的返回值类型一致，这可以通过强制类型转换来实现
   

   ​