从0开始学Java(004)_Java运算符和程序逻辑控制_java for不进行后续逻辑-优快云博客

本文链接：https://blog.youkuaiyun.com/Loiterer_Y/article/details/83066283

Java运算符

Java中常用的运算符：数学运算符、关系运算符、逻辑运算符、三目运算符和位运算符。

数学运算符

不要使用运算符编写过于复杂的计算。

=为赋值运算符。
四则运算符：+、-、*、/、%。

public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        double numB = 20;
        int numC = 3;
        System.out.println("加法计算：" + (numA + numB));
        System.out.println("减法计算：" + (numA - numB));
        System.out.println("乘法计算：" + (numA * numB));
        System.out.println("除法计算：" + (numA / numB));
        System.out.println("求模计算：" + (numA % numC));
    }
}

简化运算符：+=、-=、*=、/=、%=:

public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        numA += 2; // 等同于 numA = numA + 2
        System.out.println("加法计算" + (numA)); // 12
    }
}

++(自增),--(自减)：位置不同，功能也不同

++变量，--变量：先对变量加/减1，再使用自增或自减后的变量进行计算;
变量++，变量--：先使用变量进行计算，再进行变量加/减1。

public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        int numB = 20;
        // ++变量，先numA + 1
        // 然后(numA + 1) + numB内容
        // 最后对numB加1
        int result = (++numA) + (numB++);
        System.out.println("numA=" + numA); // 11
        System.out.println("numB=" + numB); // 21
        System.out.println("result=" + result); // 31
    }
}

关系运算符

关系运算主要是进行大小的比较处理，关系运算符有:>（大于），<（小于），>=（大于等于），<=（小于等于），!=（不相等），==（相等）。关系运算符返回的结果是布尔型数据。

public class Demo {
    public static void main(String args[]) {
        int x = 20;
        int y = 10;
        boolean flag = x > y;   
        System.out.println(flag); // false
    }
}

关系运算符可以用于所有基本数据类型的比较,如字符类型：

public class Demo {
   public static void main(String args[]) {
       char name = '游';
       boolean flag = 23142 == name;
       System.out.println(flag);  //false
   }
}

数据类型之间支持转型，因此在进行比较时，字符会自动转为int类型，而后进行关系运算。

三目运算符

三目运算符根据布尔表达式的结果进行赋值：
value_type value_name = 布尔表达式 ? true_value : false_value;
利用三目运算符可以减少判断代码:

public class Demo {
    public static void main(String[] args) {
        int numA = 10;
        int numB = 20;
        int max = 0;
        /** 使用三目运算符
         *  当numA大于numB,返回true,max = numA
         *  当numA小于numB,返回false,max = numB
         */
        max = numA>numB ? numA : numB;
        // 不使用三目运算符
        // if (numA > numB) {
        //    max = numA;
        //} else {
        //    max = numB;
        //}
        System.out.println(max);
    }
}

逻辑运算符

逻辑运算符：与&，&&、或|，||、非!

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        boolean flag = true;
        System.out.println(!flag); // false
    }
}

布尔表达式的连接，只能使用与和或操作

与：所有条件都为true时，结果为true;有一个为false，结果就是false.
或：所有条件都为false时，结果是false；有一个为true，结果就是true

范例：普通与&

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 除数不能为0
        if ((1 == 2) & (10 / 0 == 0)){
            System.out.println("Hello"); // 报错
        }
    }
}

结果：程序报错，因为&会对所有条件进行判断。但就与的特点而言，前一个条件为false，结果就是false，后续的判断没有意义。
范例：短路与&&

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        // 除数不能为0
        if ((1 == 2) && (10 / 0 == 0)){
            System.out.println("Hello"); // false,不报错
        }
    }
}

结果:程序不报错，因为&&只要有一个条件为false后，后续判断就不再进行，从而提高了效率。

或操作：一个条件为true，结果为true。

范例：普通或|

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        if ((1 < 2 ) | (10 / 0 == 0)){
            System.out.println("Hello"); // 报错
        }
    }
}

结果：使用|，会对所有条件进行判断，但是或运算的特点是：一个条件为true，结果就是true。
范例：短路或||

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        if ((1 < 2 ) || (10 / 0 == 0)){
            System.out.println("Hello"); // true,不报错
        }
    }
}

因此使用逻辑运算时就使用&&和||。

位运算符

数学运算一般是进行十进制数值之间的计算。Java支持二进制、八进制和十六进制。如果要想将十进制变为二进制，采用的方式为：除2，取余，倒序。
位运算一般用于进行二进制数据的处理。位运算符：&（与）、|（或）、>>(移位)、<<、^(反码)、~：
（1）与&运算: 两个数的同一位都为1时，才为1；否则为0

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 9;
        int numB = 11;
        System.out.println(numA & numB); // 9
    }
}

运算过程：

  1001 → 9
& 1011 → 11
  1001 →  9

（2）或|运算：两个数的同一位都为0时，才为0；否则为1

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int numA = 9;
        int numB = 11;
        System.out.println(numA | numB); // 11
    }
}

运算过程：

  1001 → 9
| 1011 → 11
  1011 → 11

（3）移位（最快方式计算2的3次方）

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int num = 2;
        num = num << 2; // 向左移位
        System.out.println(num); // 8,相当于2的3次方
    }
}

运算过程：

    0010 → 2
2<< 1000 → 8

章节小问题：请解释&与&&的区别，以及|与||的区别:
1. 在逻辑运算中：
  |- &和|会对所有条件进行判断后，返回结果
  |- &&只要一个条件返回false，就不进行后续判断，结果为false
  |- ||只要一个条件为true，就不进行后续判断，结果为true
2. 在位运算中：
  |- &为位与运算，|为位或运算算
  |- &&和||不能用于位运算

程序逻辑控制

程序逻辑结构主要分为三种：顺序结构、分支结构、循环结构。

顺序结构

顺序结构执行顺序是从前到后，但有时是以代码所在的{}为界限。

分支结构

分支结构即判断结构，有两种语法：if和switch.

if语句

if的使用形式：if、if…else、if…else if..else

范例：if判断

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        double score = 90.0;
        if (score < 60.0) {
            System.out.println("不及格");
        } else if (score < 90) {
            System.out.println("良");
        } else {
            System.out.println("优秀");
        }
    }
}

switch语句

switch判断不能使用布尔表达式，

JDK1.5之前版本只能对整数或字符进行判断；
JDK1.5新增对枚举判断的支持；
JDK1.7新增对于String判断的支持。

语法：

switch (数字/字符/枚举/字符串){
    case 内容 : 内容满足时执行的代码 ; break;
    case 内容 : 内容满足时执行的代码 ; break;
    ...
    default {
        内容都不满足case时执行;
        break;
    }
}

范例：使用switch

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("数字1");
                break;
            case 2:
                System.out.println("数字2");
                break;
            default:
                System.out.println("大于2的数字");
                break;
        }
    }
}

switch默认从第一个符合条件的case语句开始执行，直到整个switch执行完毕或遇到break关键字，才停止执行。程序区分大小写。

循环结构

当某段代码需要重复执行时，可使用循环语句实现，循环有两种：for循环和while循环。

while循环：

循环类型	语法
while循环	while（布尔语句）｛｝
do…while循环	do｛｝while（布尔语句);

范例：实现1到100的累加（while循环先判断再执行）：

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        int current = 1; // 循环的初始化条件
        while (current <= 100) { // 循环结束条件
            sum += current; // 累加
            current++; // 修改循环的初始化条件
        }
        System.out.println(sum); // 5050
    }
}

范例：实现1到100的累加（do…while循环是先执行再判断）

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        int current = 1;
        do {
            sum += current;
            current++;
        } while (current <= 100);
        System.out.println(sum);
    }
}

do…while循环先执行再判断，即不论循环条件是否满足，都至少执行一次，因此开发中不建议使用do…while。

for循环：

for (循环初始化条件; 循环结束条件; 循环条件变更) {
    循环语句;
}

可以简化为for(;;) {}
范例：实现1~100的累加

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

开发原则:

循环次数未知，循环结束条件已知时使用while循环；
循环次数已知，使用for循环。

循环嵌套

public class 九九乘法表 {
    public static void main(String[] args) {
        for (int x = 1; x <= 9; x++) {
            for (int y = 1; y <= x; y++) {
                System.out.print(x + "*" + y + "=" + (x * y) + "\t");
            }
            System.out.println();
        }
    }
}

// 打印等腰三角形
public class Demo{
    public static void main(String[] args) {
        int line = 10;
        for (int x = 0; x < line; x++) {
            for (int y = 0; y < line - x; y++) {
                System.out.print(" ");
            }
            for (int y = 0; y < x; y++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

循环控制

循环控制有两个语句：continue（退出本次循环）和break（结束整个循环）。循环控制语句要和判断语句一起使用。

continue

package com.java.demo;
public class Demo {
   public static void main(String[] args) {
       for (int x = 0; x < 5; x++) {
           if (x == 3) {
               continue; // 跳出本次循环，不进行后续的输出操作
           }
           System.out.print(x + ","); // 0,1,2,4,
       }
   }
}

break

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        for (int x = 0; x < 5; x++) {
            if (x == 3) {
                break; // 结束整体循环
            }
            System.out.print(x + ","); // 0,1,2,
        }
    }
}

范例：使用continue实现goto功能

package com.java.demo;
public class Demo {
    public static void main(String[] args) {
        mp: for(int x = 0; x < 5; x++) {
                for (int y = 0; y < 3; y++) {
                    if (x > 2) {
                       continue mp;
                    }
                    System.out.println("x = " + x + " ; y = " + y );
                 }
             }
    }
}