Java基础02-运算符&流程控制

运算符

package 基础;

public class Demo07_运算符 {
    /* 四则运算当中“+”常见的三种用法：
    * 1. 对于数值来说，就是加法
    * 2. 对于字符char来说，在计算之前，char会被提升为int类型，在进行计算
    *   char类型字符转为int类型的对照关系表：ASCII,Unicode
    * 3. 对于字符串String,代表字符串连接操作
    * */
    public static void main(String[] args) {
        // 1.加 +
        System.out.println(20 + 30);
        int a = 10;
        int b = 20;
        System.out.println(a + b);

        // 2.减 -
        System.out.println(a - b);

        // 3.乘 *
        System.out.println(a * 20);

        // 4.除 /  ：对于整数表达式，结果为整除。
        int x = 10;
        int y = 3;
        System.out.println(x / y);

        // 5.取模 % ： 取余数，仅对于整数取模有意义，浮点数无意义。
        System.out.println(x % y);

        // 注意类型转换：int + double --> double + double --> double
        double res = x + 2.7;
        System.out.println(res);

        // String 类型的加法
        String str1 = "Hello";
        String str2 = ",World!";
        System.out.println(str1 + str2);
        // 任何数据类型和String类型相加时，都会被转为String类型。
        System.out.println(str1 + 20);
        // 注意优先级问题：
        System.out.println(str1 + 20 + 30);
        System.out.println(str1 + (20 + 30));


        /* 自增运算符(自减运算符类似)
        * 1. 单独使用： 不和其他任何操作混用，此时，++num  和 num++ 完全相等。
        * 2. 混合使用： 和其他操作混合，例如和赋值操作符混合，打印操作等：
        *   ++num 和 num++ 不同:
        *   ++num 表示先加值再进行其他操作， num++ 表示先操作再加值
        *
        * 注意事项：
        *   自增自减运算符只能用于变量，常量不可用。
        * */
        int num1 = 10;
        System.out.println(num1++); // 10
        System.out.println(++num1); // 12


        /*赋值运算符：
        *1. 基本赋值运算符： =
        *2. 复合赋值运算符： += -= *= /= %=
        * 规则如下：
        * a += 3 --> a = a + 3
        * a -= 3 --> a = a - 3
        * a *= 3 --> a = a * 3
        * a /= 3 --> a = a / 3
        * a %= 3 --> a = a % 3
        * */
        byte byte1 = 5;
        byte1 += 1;
        System.out.println(byte1);
        // 其中发生强制类型转换，byte提升为int进行计算。

        /*比较运算符：
        * 1. ==
        * 2. <=
        * 3. >=
        * 4. !=
        * 5. >
        * 6. <
        *
        * 注意事项：
        * 1.比较运算符的结果返回一定是布尔值。
        * 2.不能进行连写，如： 1 < x < 3
        * */
        System.out.println(10 > 5);
        // 返回布尔值，true。

        /*逻辑运算符：
        * 1. && 与，并且：连接两个布尔值，全真为真
        * 2. || 或：一真则真
        * 3. ！ 非： 真变假，假变真
        *
        * 注意事项：
        * 1.逻辑运算符只用于布尔值
        * 2.与 或 需要至少两个布尔值，非 只需要一个布尔值
        *
        * 短路：
        * 如果根据左边即可判断表达式，则后面不会去判断。
        * */
        int aNum = 10;
        System.out.println(3 > 4 && ++aNum < 100);
        System.out.println(aNum); // 10
        // ++aNum 没有执行，因为3>4为false,右边的表达式不再运行。


        /*三元运算符：
        * 元：参数
        * 格式：
        * 数据类型 变量名称 = 条件判断 ? 表达式A ： 表达式B
        * 过程：
        * 先判断条件是否成立，成立为真则将表达式A赋值给变量,为假则将表达式B赋值给变量
        * 注意事项：
        * 1. 必须同时保证表达式A和表达式B都符合左侧变量的数据类型
        * 2. 三元运算的结果必须被使用
        *  */

        int numb1 = 10;
        int numb2 = 20;
        int maxNum = numb1 > numb2 ? numb1 : numb2;
        System.out.println(maxNum);
    }
}

方法入门

package 基础;

public class Demo08_方法 {
    /*方法定义的格式:
    *public static void 方法名() {
    *   方法体
    * }
    * 注意事项：
    * 1. 方法定义的先后顺序无所谓
    * 2. 方法定定义不能产生嵌套包含关系
    * 3. 方法定义后，不会执行，需要调用方法
    * 4. 方法调用的格式： 方法名称();
    * */

    public static void main(String[] args) {
        Run();
        Eat();
    }

    public static void Run() {
        System.out.println("running");
    }

    public static void Eat() {
        System.out.println("eating");
    }
}

流程控制判断语句

package 基础;

public class Demo09_流程控制_判断 {
    /*判断语句if:
     * 格式：
     * if(关系表达式) {
     *   语句体1
     * } else {
     *   语句体2
     * }
     * */

    public static void main(String[] args) {
        int num = 13;
        if (num % 2 == 0) {
            System.out.println("偶数");
        } else {
            System.out.println("奇数");
        }

        int x = 13;
        int y;
        if (x >= 3) {
            y = 2 * x + 1;
        } else if (-1 < x && x < 3) {
            y = 2 * x;
        } else {
            y = 2 * x - 1;
        }
        System.out.println(y);

        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);

        int maxNum;
        if (a > b) {
            maxNum = a;
        } else {
            maxNum = b;
        }
        System.out.println(maxNum);

        /*选择语句switch：
         * 格式：
         * switch (表达式) {
         *   case 常量1：
         *   语句体1
         *   break;
         *  case 常量2：
         *   语句体2
         *   break;
         *   default:
         *   语句体n
         * }
         *
         * 注意事项：
         * 1. 多个case的值不能相同
         * 2. switch语句中只能是下列数据类型：基本数据类型： byte/short/char/int
         *                               引用数据类型：String字符串/enum枚举
         * 3. switch语句很灵活，case前后顺序可以变化，break语句可以省略
         * 4. 省略break后，会导致case穿透，遇到break语句后，才会停止，如下例2
         * */

        int numS = 1;
        switch (numS) {
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("not 1 or 2");
                break;
        }

        // 省略break,此时会输出 20， 30 ，40
        int num1 = 20;
        switch (num1) {
            case 10:
                System.out.println("10");
                break;
            case 20:
                System.out.println("20");
            case 30:
                System.out.println("30");
            case 40:
                System.out.println("40");
                break;
        }
    }
}

流程控制循环语句

package 基础;

public class Demo10_流程控制_循环 {
    public static void main(String[] args) {
        /*循环结构的基本组成部分：
         * 1. 初始化语句：在循环最开始执行，仅做一次
         * 2. 条件判断： 如果城里，继续循环，否在停止循环
         * 3. 循环体：需循环的语句
         * 4. 步进语句： 每次循环之后要进行的语句
         * */

        /*for循环：
         * 格式：
         * for (初始表达式;布尔表达式；步进表达式) {
         *   循环体
         * }
         * */
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
        }

        /*while循环：
         * 格式：
         * while (条件判断) {
         *   循环体
         * }
         * */
        int num = 1;
        while (num <= 100) {
            System.out.println(num);
            num++;
        }

        /*do while循环：
        * do {
        *   循环体
        *} while (条件判断) {};
        * */

        int num1 = 1;
        do {
            System.out.println(num1);
            num1++;
        } while (num1 <= 100);

        // 1~100之间的偶数和
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            if (i % 2 == 0) {
                sum += i;
            } else {

            }
        }
        System.out.println("sum is " + sum);

        /*三种循环的区别：
        * 1. 如果条件判断一次都没有满足，for和while循环会执行0次，但do-while会执行1次
        * 2. for循环的变量在小括号但中定义，只有在循环内部（循环作用范围内）可以使用
        *   while和do-while循环初始化语句不在循环内，循环结束后仍可使用
        * */

    }
}

条件控制

package 基础;

public class Demo11_条件控制 {
    public static void main(String[] args) {

        /*break关键字的用法：
        * 1. switch语句中：一旦执行break,整个switch语句立刻结束
        * 2. 循环语句中：一旦执行break,整个循环语句立刻结束，打断循环
        * */
        for (int i = 0; i < 10; i++) {
            if (i==4) {
                break;
            } else {
                System.out.println(i);
            }
        }

        /*continue关键字用法：
        * 1. 循环语句中:一旦执行continue语句，立刻跳过当前循环，进入下一次循环
        * */

        for (int i = 0; i < 10; i++) {
            if (i==4) {
                continue;
            } else {
                System.out.println(i);
            }
        }

        /*死循环：
        * while (true) {
        *   循环体
        * }
        * */

//        while (true) {
//            System.out.println(100);
//        }

        /*循环嵌套：
        *
        * */

        for (int i = 0; i < 24; i++) {
            for (int j = 0; j < 60; j++) {
                System.out.println(i + "：" + j);
            }
        }
    }
}