前言

  • 这是课程的第二篇，基础篇结束，下一篇开始语句相关的内容（if，for,while,switch），所以命名为语句，以防有新读者所以我简述一下第一篇的前言。
  • 这个Java急速学习课程适合有一定编程基础的人。它通过实际的代码例子来教Java，减少了理论讲解，使学习过程更直观，帮助你更快地掌握Java的核心技能。课程内容经过优化，力求简洁明了。同时，课程鼓励大家交流心得，提出更好的解决方案，以此来不断改进课程内容。

包含的知识

这段Java代码展示了多个基本编程概念和技术细节。下面是对这些知识点的总结：

  1. 自增自减运算符

    • 类名 BasicZc0 遵循了大驼峰命名法（PascalCase）。
    • ++ 和 –：前置和后置自增自减运算符的使用及区别。
    • 后置自增 (a++)：先使用当前值，再加 1。
    • 前置自增 (++a)：先加 1，再使用新值。

  2. 扩展赋值运算符

    • printZC() 是一个静态方法，用于输出文本 “ZC”。
    • sum(int a, int b) 是一个静态方法，接受两个整数参数，并返回它们的和。
    • printLiteral() 方法展示了如何打印不同类型的字面量，如数字、布尔值、字符和字符串。
    • printV() 方法演示了变量声明和初始化，以及不同类型的数据操作。
    • div(int a, int b) 方法实现了一个简单的除法运算，并通过 return 关键字来提前退出方法。

  3. 强制类型转换

    • 在扩展赋值运算符中，自动进行类型转换
    • 示例：byte a1 = 10; byte a2 = 20; a1 += a2; 结果为 30。

  4. 三元运算符

    • 用于条件判断并选择一个值。
    • 示例：int max = a > b ? a : b; 找出较大值

  5. 方法重载的一个小示例（复习）

    • print3(int a, int b) 和 print3(int a, int b, int c)。

  6. 短路逻辑运算符与非短路逻辑运算符

    • && 和 ||：短路逻辑运算符，仅计算必要部分。
    • 示例：a > 1000 && ++b > 1：左边为假则右边不执行。
    • & 和 |：非短路逻辑运算符，始终计算两边。
    • 示例：a > 1000 & ++b > 1：即使左边为假，右边也执行。

  7. 其他逻辑运算符

    • !：取反操作。  ^：异或操作，相同为 false，不同为 true。

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package basic_0;
 
public class BasicZc2 {
    public static void main(String[] args) {
        // 理解自增自减运算符
        print0(10);  //a=10
        System.out.println("============自增自减===========");
        print1(10);  //a=10
        System.out.println("==========强制类型转换==========");
        print2();
        System.out.println("===========三元运算符===========");
        print3(10, 20);
        print3(10, 20, 30);//方法重载
        System.out.println("===========短路逻辑符号==========");
        print4(); // 判断&& || 与 & |的区别
 
    }
 
    public static void print0(int a) { //a = 10
        a++;  ++a; // a = a + 1;
        System.out.println(a); // 12
 
        a--;  --a; // a = a - 1;
        System.out.println(a); // 10
    }
 
    public static void print1(int a) {// 自增和自减放在变量前后的区别
        int b = a++; // 先用后加
        System.out.println("先用后加");
        System.out.println(a); // 11
        System.out.println(b); // 10
 
        int c = ++a; // 先加后用
        System.out.println("先加后用");
        System.out.println(a); // 12
        System.out.println(c); // 12
    }
 
    // 演示其他几个扩展的赋值运算符。
    public static void print2() {
        //扩展赋值运算符自带强制类型转换
        System.out.println("运算符自带强制类型转换示例：");
        int a = 10;
        a += 5; // 等价于 a = (a的类型)(a + 5);
        System.out.println(a); // 15
 
        byte a1 = 10;
        byte a2 = 20;
        a1 += a2; // 等价于 a1 = (byte) (a1 + a2);
        System.out.println(a1); // 30
 
        int b = 10;
        b *= 5; // 等价于 b = (b的类型)(b * 5);
        System.out.println(b); // 50
 
        int c = 10;
        c /= 5; // 等价于 c = (c的类型)(c / 5);
        System.out.println(c); // 2
 
        int d = 10;
        d %= 5; // 等价于 d = (d的类型)(d % 5);
        System.out.println(d); // 0
 
        System.out.println("表达式的自动类型提升示例：");
        //byte short char运算时会直接提升成int运算
        // 表达式的最终结果类型是有最高类型决定的
    }
 
    public static void print3(int a, int b) {// 三元运算符，无返回值
        int max = a > b ? a : b;
        System.out.println("较大值：" + max);
    }
    //求三个整数的较大值返回，嵌套
    public static int print3(int a, int b, int c) {//求三个整数的较大值返回，嵌套，有返回值
        // 三元运算符的嵌套
        int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("较大值：" + max);
        return max;
    }
 
    public static void print4() {// 判断&& ||(短路逻辑运算符) 与 & |的区别
        // &且    |或
        int a = 111;
        int b = 2;
        // System.out.println(a > 1000 && ++b > 1); // false  && 发现左边条件为false右边直接不执行
        System.out.println(a > 1000 & ++b > 1);  // false  & 即便发现左边条件为false右边依然执行
        System.out.println(b); // 3
 
        int i = 10;
        int j = 20;
        // System.out.println(i > 6 || ++j > 1); // true  || 发现左边条件为true右边直接不执行
        System.out.println(i > 6 | ++j > 1); // true & 即便发现左边条件为true右边依然执行
        System.out.println(j);
        // ! 非，取反
        System.out.println(!true); // false
        // ^ 异或，相同条件结果为false，不同为true
        System.out.println(false ^ false); // false
        System.out.println(true ^ true); // false
        System.out.println(true ^ false); // true
        System.out.println(false ^ true); // true
    }
}