第二知识单元

Java语言基础

Java程序设计第2讲，主讲人：李欣

Created: 2022-09-21 Wed 02:28

0.1. 互动课堂

Click to host the seminar.

0.2. 签到

https://xin.blue/tool/attendance/

0.3. 本次课的目标

Java程序的构成
- 了解Java程序设计的基本结构和组成元素
数据类型、变量和常量
- 了解Java的 数据类型 、 标识符 、变量和常量
运算符及表达式
- 了解 运算符 及 表达式 的概念，学会使用关系、逻辑和条件等运算符，理解由这些运算符连接起来的表达式取值方法
- 理解赋值与 类型转换
- 掌握运算符号、运算 优先级 与 结合性
流程控制语句
- 理解并掌握顺序、选择、循环三种基本结构
- 掌握一定算法设计能力及编写结构化程序的能力
数组
- 理解数组的定义、 初始化 和使用

1. Java程序的构成

1.1. 示例程序

public class Main { // 主类类头
    public static void main(String args[]) {
        Student s1 = new Student();
        s1.read();
        System.out.println("******************** Displaying Student Information ********************");
        s1.show();
        Teacher t1 = new Teacher();
        t1.read();
        System.out.println("******************** Displaying Teacher Information ********************");
        t1.show();
    }
}
class Person {
    private String name; // 静态属性
    private long phno; // 静态属性
    public void read() { // 方法
        name = "Richard";
        phno = 123456789;
    }
    public void show() { // 方法
        System.out.println("Name = " + name);
        System.out.println("Phone = " + phno);
    }
}
class Student extends Person { // Student是Person的子类，Person是Student的父类
    private int rollno; // 静态属性
    private String course; // 静态属性
    public void read() { // 方法
        super.read();
        rollno = 007;
        course = "Computer Science";
    }
    public void show() { // 方法
        super.show();
        System.out.println("Roll No. = " + rollno);
        System.out.println("Course = " + course);
    }
}
class Teacher extends Person { // Teacher是Person的子类，Person是Teacher的父类
    private String dept_name; // 静态属性
    private String qual; // 静态属性
    public void read() { // 方法
        super.read();
        dept_name = "CSE";
        qual = "PhD";
    }
    public void show() { // 方法
        super.show();
        System.out.println("Departement = " + dept_name);
        System.out.println("Qualififcation = " + qual);
    }
}

1.2. 编译程序

javac Main.java
find . -name "*.java" -o -name "*.class"
# ./Main.java
# ./Main.class
# ./Person.class
# ./Teacher.class
# ./Student.class

1.3. 解释执行

java Main
# ******************** Displaying Student Information ********************
# Name = Richard
# Phone = 123456789
# Roll No. = 7
# Course = Computer Science
# ******************** Displaying Teacher Information ********************
# Name = Richard
# Phone = 123456789
# Departement = CSE
# Qualififcation = PhD

1.4. 思考：什么是主类？

参与人数	0
A. 类名和文件名一致的类	0
B. 包含main方法的类	0
C. 具有public修饰的类	0
D. 以上说法都对	0

1.4.1. 一般情况

// TestClass.java
import java.io.*;
public class TestClass {
    public static void main(String args []) {
        System.out.println(UserClass.msMessage);
    }
}
class UserClass {
    static String msMessage = "Message from UserClass.";
}

Message from UserClass.

1.4.2. 多个类具有public修饰的情况

// TestClass.java
import java.io.*;
public class TestClass {
    public static void main(String args []) {
        System.out.println(UserClass.msMessage);
    }
}
public class UserClass {
    static String msMessage = "Message from UserClass.";
}

javac TestClass.java

javac TestClass.java
# TestClass.java:8: error: class UserClass is public, should be declared in a file named UserClass.java
# public class UserClass {
#        ^
# 1 error

javac TestClass.java
# TestClass.java:8: error: class UserClass is public, should be declared in a file named UserClass.java
# public class UserClass {
#        ^
# 1 error
mv TestClass.java UserClass.java
javac UserClass.java

javac TestClass.java
# TestClass.java:8: error: class UserClass is public, should be declared in a file named UserClass.java
# public class UserClass {
#        ^
# 1 error
mv TestClass.java UserClass.java
javac UserClass.java
# UserClass.java:3: error: class TestClass is public, should be declared in a file named TestClass.java
# public class TestClass {
#        ^
# 1 error

1.4.3. 多个类均包含main方法的情况

// TestClass.java
import java.io.*;
public class TestClass {
    public static void main(String args []) {
        System.out.println("This is TestClass.");
        System.out.println(UserClass.msMessage);
    }
}
class UserClass {
    static String msMessage = "Message from UserClass.";
    public static void main(String args []) {
        System.out.println("This is UserClass.");
        System.out.println(UserClass.msMessage);
    }
}

This is TestClass.
Message from UserClass.

1.4.4. 多个类均包含main方法的情况

// UserClass.java
import java.io.*;
public class UserClass {
    static String msMessage = "Message from UserClass.";
    public static void main(String args []) {
        System.out.println("This is UserClass.");
        System.out.println(UserClass.msMessage);
    }
}
class TestClass {
    public static void main(String args []) {
        System.out.println("This is TestClass.");
        System.out.println(UserClass.msMessage);
    }
}

This is UserClass.
Message from UserClass.

1.4.5. 没有main方法的情况

// TestClass.java
import java.io.*;
class TestClass {
    static String msMessage = "Message from TestClass.";
    void a() {
        System.out.println("a");
    }
}
class UserClass {
    static String msMessage = "Message from UserClass.";
    void b() {
        System.out.println("b");
    }
}

javac TestClass.java

javac TestClass.java
java TestClass

javac TestClass.java
java TestClass
# Error: Main method not found in class TestClass, please define the main method as:
#    public static void main(String[] args)
# or a JavaFX application class must extend javafx.application.Application

1.4.6. 没有类具有public修饰的情况

// TestClass.java
import java.io.*;
class TestClass {
    public static void main(String args []) {
        System.out.println("This is TestClass.");
        System.out.println(UserClass.msMessage);
    }
}
class UserClass {
    static String msMessage = "Message from UserClass.";
    public static void main(String args []) {
        System.out.println("This is UserClass.");
        System.out.println(UserClass.msMessage);
    }
}

This is TestClass.
Message from UserClass.

mv TestClass.java UserClass.java
javac UserClass.java
java UserClass

mv TestClass.java UserClass.java
javac UserClass.java
java UserClass
# This is UserClass.
# Message from UserClass.

1.4.7. 结论

参考教材

3.1 pp.33-34

每个 .java 文件内最多只能有一个 public 类，若出现一个以上 public 类，则编译出错。

public 类的名称必须完全与其所在文件去掉 .java 扩展名后的 文件名 相同，包含 大小写 ，否则编译出错。

.java 文件可以没有 public 类，这种情况下可以对该文件任意命名。

在Java Application中，主类需包含 main 方法。

同一个 .java 文件中存在多个类均包含 main 方法时，包含 main 方法的类不一定是主类。

主类是Java程序执行的 入口点 。

每个程序中可以定义多个类，但只能有一个类是主类。

2. 数据类型、变量与常量

2.1. 数据类型

参考教材

3.2.1 pp.34-35

%%{init: { 'theme': 'forest', 'fontFamily': 'Times New Roman, KaiTi' }}%%
graph TB
    type("数据类型 (Data Types)")
    type --- primitive("基本数据类型 (Primitive Data Types)")
    primitive --- numericTypes["数值型 (Numeric Types)"]
    numericTypes --- integerTypes["整数类型 (Integer Types)"]
    integerTypes --- byte["byte"]
    integerTypes --- short["short"]
    integerTypes --- int["int"]
    integerTypes --- long["long"]    
    numericTypes --- floatingPointTypes["浮点类型 (Floating-Point Types)"]
    floatingPointTypes --- float["float"]
    floatingPointTypes --- double["double"]
    primitive --- characterType["字符型 (Character Data Type)"]
    characterType --- char["char"]
    primitive --- booleanType["布尔型 (Boolean Data Type)"]
    booleanType --- boolean["boolean"]
    type --- reference("引用数据类型 (Reference Data Types)")
    reference --- Class["类 (Class)"]
    reference --- Interface["接口 (Interface)"]
    reference --- Array["数组 (Array)"]
    style type fill:#eee,stroke:#333,stroke-width:3px
    style primitive fill:#edd,stroke:#333,stroke-width:3px
    style numericTypes fill:#dcf        
    style integerTypes fill:#ccf    
    style byte fill:#ccf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style short fill:#ccf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style int fill:#ccf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style long fill:#ccf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style floatingPointTypes fill:#fcf
    style float fill:#fcf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style double fill:#fcf,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style characterType fill:#ffc    
    style char fill:#ffc,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5
    style booleanType fill:#fcc
    style boolean fill:#fcc,stroke:#000,stroke-width:2px,color:#000,stroke-dasharray: 5 5        
    style reference fill:#ded,stroke:#333,stroke-width:3px

2.1.1. 如何使用？

byte b = 10; // 声明变量并赋初值，可能的取值范围： [-2^7, 2^7 - 1]
short s = 10; // 声明变量并赋初值，可能的取值范围： [-2^15, 2^15 - 1]
int i, j, k = 10; // 声明变量i和j，同时声明变量k并赋初值，可能的取值范围： [-2^31, 2^31 - 1]
long l = 10l; // 声明变量并赋初值，可能的取值范围： [-2^63, 2^63 - 1]
float f = 10.0f; // 声明变量并赋初值，可能的取值范围： [-2^31, 2^31-1]
double d = 10.0d; // 声明变量并赋初值，可能的取值范围： [-2^63, 2^63-1]
char c = 65; // or char c = 'A'; 声明变量并赋初值，可能的取值范围： [0, 2^16-1]
boolean bl = true; // true or false

i = 1; // 赋值语句
j = 2; // 赋值语句

System.out.println("b: " + b + ", s: " + s + ", i: " + i + ", j: " + j + ", k: " + k +
                   ", l: " + l + ", f: " + f + ", d: " + d + ", c: " + c + ", bl: " + bl);

b: 10, s: 10, i: 1, j: 2, k: 10, l: 10, f: 10.0, d: 10.0, c: A, bl: true

2.2. 标识符

标识符 是赋予变量、类、方法、数组等的名称。

Java对于 标识符的定义 有如下的规定：

可以由字母、数字和两个特殊字符（下划线 _ 及美元符号 $ ）组合而成。

标识符必须以字母、下划线 _ 或美元符号 $ 开头。

Java是大小写敏感的语言， class 和 Class 、 System 和 system 分别代表不同的 标识符 。

应该使标识符尽量反映它所表示的变量、常量、对象或类的意义。

关键字 不能作为 标识符 。

2.2.1. 合法与不合法的标识符的例子

参考教材

表3-2 p.36

2.2.2. Java标识符的习惯性约定

类名、接口名

采用名词，首字母大写，内含的单词首字母大写
例如： AppletInOut

方法名

采用动词，首字母小写，内含的单词首字母大写
例如： actionPerformed()

变量名

采用名词，首字母小写，内含的单词首字母大写
例如： prompt connectNumber

常量名

全部大写 ，单词间用下划线分开
例如： HEAD_COUNT

2.3. 常量

布尔常量

true
false

整型常量

按采用的进制划分
- 十进制 ：非 0 开头的数值，例如 100 -50
- 八进制 ： 0 开头的数值，例如十进制的 15 用八进制表示为 017
- 十六进制 ： 0x 开头的数值，例如十进制的 47 用十六进制表示为 0x2F
按占用内存长度划分
- 一般整型 ：占用32位
- 长整型 ：占用64位 -386L 017777l

浮点常量

一般浮点常量 ：占用32位 19.4F 3.0513E3 8701.52f
双精度浮点常量 ：占用64位 2.433E-5D 700041.273d 3.1415

字符常量

一般Latin字符 'a' 'Z' '8' '#'
转义字符 '\b' '\t' '\n' '\r' '\"' '\'' '\\'
Unicode码表示的的字符 '\u0008' '\u0009' '\u000a' '\u000d'
八进制数表示的字符 '\101'

字符串常量

"Hello" "My\nJava" "How are you?" ""

在Java中可以使用连接操作符 + 把两个或更多的字符串常量串接在一起，组成一个更长的字符串。

2.4. 变量

变量是在程序的运行过程中数值可变的数据。

Java中的变量必须 先声明后使用 。声明变量又称为创建变量。

public class UseVariable {
    public static void main(String args[]) {
        boolean b = true;
        short si = 128;
        int i = -99;
        long l = 123456789L;
        char ch = 'J';
        float f = 3.1415925F;
        double d = -1.04E-5;
        String s = "你好！"; // 不是基本数据类型，每个字符串相当于一个字符串对象。
        System.out.println("布尔型变量   b = " + b);
        System.out.println("短整型变量  si = " + si);
        System.out.println("整型变量     i = " + i);
        System.out.println("长整型变量   l = " + l);
        System.out.println("字符型变量  ch = " + ch);
        System.out.println("浮点型变量   f = " + f);
        System.out.println("双精度型变量 d = " + d);
        System.out.println("字符型对象   s = " + s);
    }
}
// 布尔型变量   b = true
// 短整型变量  si = 128
// 整型变量     i = -99
// 长整型变量   l = 123456789
// 字符型变量  ch = J
// 浮点型变量   f = 3.1415925
// 双精度型变量 d = -1.04E-5
// 字符型对象   s = 你好！

2.4.1. 处理用户输入

import java.io.*;
public class GetNumber {
    public static void main(String args[]) {
        int i = 0;
        String s;
        try{
            System.out.print("请输入一个整型数：");
            BufferedReader br =
                new BufferedReader(new InputStreamReader(System.in));
            s = br.readLine( );
            i = Integer.parseInt(s);
        } catch(IOException e) { }
        System.out.print("你输入了数字：" + i );
        System.out.println("，\t对吗？");
    }
}

java GetNumber
# 请输入一个整型数：

java GetNumber
# 请输入一个整型数：111

java GetNumber
# 请输入一个整型数：111
# 你输入了数字：111，     对吗？

java GetNumber
# 请输入一个整型数：111
# 你输入了数字：111，     对吗？
java GetNumber
# 请输入一个整型数：000
# 你输入了数字：0，       对吗？
java GetNumber
# 请输入一个整型数：abc
# Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
#         at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
#         at java.base/java.lang.Integer.parseInt(Integer.java:652)
#         at java.base/java.lang.Integer.parseInt(Integer.java:770)
#         at GetNumber.main(GetNumber.java:11)

3. 表达式

表达式 是由变量、常量、对象、方法调用和操作符组成的式子。

符合语法规则的表达式可以被编译系统理解、执行或计算。

表达式的值 是对它运算后所得的结果。

3.1. 赋值与强制类型转换

3.1.1. 赋值

i = 0;
j = i;
k = i + j * 5;
myFirstString = myDouble.toString( );
mySecondString = myFirstString;

变量或对象 = 表达式

需要注意的是，当赋值号的左边是一个对象名时，赋值运算符将把右边表达式所得的对象的引用赋值给它，而不是为这个对象开辟新的内存空间并把右边对象的所有内容赋值给它。

class MyDouble {
    public String toString() {
        return "123.45";
    }
    public static void main(String args[]) {
        int i, j, k;
        String myFirstString, mySecondString;
        MyDouble myDouble = new MyDouble();
        i = 0;
        j = i;
        k = i + j * 5;
        myFirstString = myDouble.toString();
        mySecondString = myFirstString;
    }
}

class MyDouble {
    public String toString() {
        return "123.45";
    }
    public static void main(String args[]) {
        int i, j, k;
        String myFirstString, mySecondString;
        MyDouble myDouble = new MyDouble();
        i = 0;
        j = i;
        k = i + j * 5;
        myFirstString = myDouble.toString();
        mySecondString = myFirstString;
        String theNewString = new String("123.45");
        System.out.println("i: " + i + ", j: " + j + ", k: " + k +
                           ", myFirstString: " + myFirstString +
                           ", mySecondString: " + mySecondString +
                           ", theNewString: " + theNewString);
        System.out.println("Hash of myFirstString: " + System.identityHashCode(myFirstString));
        System.out.println("Hash of mySecondString: " + System.identityHashCode(mySecondString));
        System.out.println("Hash of theNewString: " + System.identityHashCode(theNewString));
    }
}

i: 0, j: 0, k: 0, myFirstString: 123.45, mySecondString: 123.45, theNewString: 123.45
Hash of myFirstString: 990368553
Hash of mySecondString: 990368553
Hash of theNewString: 1828972342

3.1.2. 强制类型转换

byte myByte = 10;
int myInteger = -1;

myInteger = myByte;
myByte = myInteger;

javac Main.java
# Main.java:8: error: incompatible types: possible lossy conversion from int to byte
#         myByte = myInteger;
#                  ^
# 1 error

byte myByte = 10;
int myInteger = -1;

myInteger = myByte;
myByte = (byte) myInteger;

3.2. 字符串连接

int i = -99;
boolean b = true;
float f = 3.14159265F;
System.out.println("整型变量 i = " + i + ", 布尔型变量 b = " + b + ", 浮点型变量 f = " + f); 
System.out.println("===" + 100 + 200 + "===");
System.out.println("===" + (100 + 200) + "===");
System.out.println("===" + 100 + 200);
System.out.println(100 + 200 + "===");

整型变量 i = -99, 布尔型变量 b = true, 浮点型变量 f = 3.1415927
===100200===
===300===
===100200
300===

3.3. 算术运算

3.3.1. 双目运算符

运算符	运算	例	功能	注意事项
`+`	加	`a + b`	求a与b相加的和
`-`	减	`a - b`	求a与b相减的差
`*`	乘	`a * b`	求a与b相乘的积
`/`	除	`a / b`	求a除以b的商	整型数据相除保留整数部分
`%`	取余	`a % b`	求a除以b所得的余数	整型数据才能取余

除法和取余（C语言）

printf("%d, %d\n", 7 / 3, 7 % 3);
printf("%d, %d\n", 7 / -3, 7 % -3);
printf("%d, %d\n", -7 / 3, -7 % 3);
printf("%d, %d\n", -7 / -3, -7 % -3);

2, 1
-2, 1
-2, -1
2, -1

除法和取余（Java）

System.out.println(7 / 3 + ", " + (7 % 3));
System.out.println(7 / -3 + ", " + (7 % -3));
System.out.println(-7 / 3 + ", " + (-7 % 3));
System.out.println(-7 / -3 + ", " + (-7 % -3));

2, 1
-2, 1
-2, -1
2, -1

除法和取余（Python）

return(str(7 // 3) + ", " + str(7 % 3) + "\n" +
       str(7 // -3) + ", " + str(7 % -3) + "\n" +
       str(-7 // 3) + ", " + str(-7 % 3) + "\n" +
       str(-7 // -3) + ", " + str(-7 % -3))

2, 1
-3, -2
-3, 2
2, -1

除法和取余（Lisp）

(list (list (/ 7 3) "%" (% 7 3) "mod" (mod 7 3))
      (list (/ 7 -3) "%" (% 7 -3) "mod" (mod 7 -3))
      (list (/ -7 3) "%" (% -7 3) "mod" (mod -7 3))
      (list (/ -7 -3) "%" (% -7 -3) "mod" (mod -7 -3)))

((2 "%" 1 "mod" 1) (-2 "%" 1 "mod" -2) (-2 "%" -1 "mod" 2) (2 "%" -1 "mod" -1))

除法和取余（不同语言对比）

	`7 / 3`	`7 / -3`	`-7 / 3`	`-7 / -3`
C	2	-2	-2	2
Java	2	-2	-2	2
Python `//`	2	-3	-3	2
Lisp	2	-2	-2	2

	`7 % 3`	`7 % -3`	`-7 % 3`	`-7 % -3`
C	1	1	-1	-1
Java	1	1	-1	-1
Python	1	-2	2	-1
Lisp	1	1	-1	-1
Lisp `mod`	1	-2	2	-1

使用Java对浮点型数值取整

// 舍弃小数
System.out.print("Truncate(1.5) = " + (int) 1.5);
System.out.println(", Truncate(-1.5) = " + (int) -1.5);

// 向上取整
System.out.print("Ceiling(1.1) = " + Math.ceil(1.1));
System.out.println(", Ceiling(-1.1) = " + Math.ceil(-1.1));

// 向下取整
System.out.print("Floor(1.9) = " + Math.floor(1.9));
System.out.println(", Floor(-1.9) = " + Math.floor(-1.9));

// 四舍五入
System.out.print("Round(0.4) = " + Math.round(0.4));
System.out.println(", Round(-0.4) = " + Math.round(-0.4));
System.out.print("Round(0.5) = " + Math.round(0.5));
System.out.print(", Round(-0.5) = " + Math.round(-0.5));
System.out.println(", Round(-0.5000001) = " + Math.round(-0.5000001));

Truncate(1.5) = 1, Truncate(-1.5) = -1
Ceiling(1.1) = 2.0, Ceiling(-1.1) = -1.0
Floor(1.9) = 1.0, Floor(-1.9) = -2.0
Round(0.4) = 0, Round(-0.4) = 0
Round(0.5) = 1, Round(-0.5) = 0, Round(-0.5000001) = -1

3.3.2. 单目运算符

运算符	运算	例	功能等价	注意事项
`++`	自增	`a++` `++a`	`a = a + 1`	`a++` 与 `++a` 的区别
`--`	自减	`a--` `--a`	`a = a - 1`	`a--` 与 `--a` 的区别
`-`	求相反数	`-a`	`a = -1`

int x = 2;
int y = (++x) * 3;
System.out.println("x: " + x + ", y: " + y);
x = 2;
y = (x++) * 3;
System.out.println("x: " + x + ", y: " + y);

x: 3, y: 9
x: 3, y: 6

int j = 0; 
for(int i = 0; i < 100; i++){ 
    j = j++;
} 
System.out.println(j);

int j = 0; 
for(int i = 0; i < 100; i++){ 
    j++;
} 
System.out.println(j);

3.4. 关系运算

运算符	运算
`==`	等于
`!=`	不等于
`>`	大于
`<`	小于
`>=`	大于等于
`<=`	小于等于

关系运算的结果是 布尔型 的量，即真或假。

3.5. 逻辑运算

运算符	运算	例	运算规则
`&`	非简洁与	`x & y`	`x` `y` 都真时结果才为真
$\vert$	非简洁或	$x \vert y$	`x` `y` 都假时结果才为假
`!`	取反	`!x`	`x` 真时为假 `x` 假时为真
`^`	异或	`x ^ y`	`x` `y` 同真假时结果为假
`&&`	简洁与	`x && y`	`x` `y` 都真时结果才为真
$\vert\vert$	简洁或	$x \vert\vert y$	`x` `y` 都假时结果才为假

3.5.1. 简洁、非简洁

int x = 3, y = 5;
boolean b = x > y && x++ == y--;
System.out.println("x: " + x + ", y: " + y + ", b: " + b);

x = 3;
y = 5;
b = x > y & x++ == y--;
System.out.println("x: " + x + ", y: " + y + ", b: " + b);

x: 3, y: 5, b: false
x: 4, y: 4, b: false

3.6. 位运算

位运算 是对操作数以二进制比特位为单位进行的操作和运算，位运算的操作数和结果都是整型量。

运算符	运算	例	运算规则
`~`	位反	`~x`	将 `x` 按比特位取反
`>>`	右移	`x >> n`	`x` 各比特位右移 `n` 位
`<<`	左移	`x << n`	`x` 各比特位左移 `n` 位
`>>>`	不带符号的右移	`x >>> n`	`x` 各比特位右移 `n` 位，左边的空位一律填零

`x` （十进制表示）	二进制补码表示	`x << 2`	`x >> 2`	`x >>> 2`
30	00011110	01111000	00000111	00000111
-17	11101111	10111100	11111011	00111011

int a = 30;
int b = -17;

System.out.println("a << 2: " + (a << 2) + ", a >> 2: " + (a >> 2) + ", a >>> 2: " + (a >>> 2));
System.out.println("b << 2: " + (b << 2) + ", b >> 2: " + (b >> 2) + ", b >>> 2: " + (b >>> 2));

a << 2: 120, a >> 2: 7, a >>> 2: 7
b << 2: -68, b >> 2: -5, b >>> 2: 1073741819

1073741819
3FFFFFFB
0011 1111 1111 1111 1111 1111 1111 1011

3.7. 其他运算符

三目条件运算符

x ? y : z

复杂赋值运算符

表3-10 pp.48-49

括号与方括号

()
[]

对象运算符

instanceof

3.8. 运算符的优先级与结合性

参考教材

例3-11 p.49

3.9. 注释

行注释符 //
块注释符 /* */

// 行注释
// This a test program of what is to be done

// 块注释
/* 程序名：
   项目名：
   编写时间：
   功能：
   输入/输出： */

4. 流程控制语句

4.1. 结构化程序设计的三种基本流程

%%{init: { 'theme': 'forest', 'fontFamily': 'Times New Roman, KaiTi' }}%%
graph TB
    structures["三种基本流程结构"]
    structures --- sequential["顺序结构"]
    structures --- selection["选择结构（分支结构）"]
    structures --- iteration["循环结构"]

Figure 1: 结构化程序设计的三种基本结构

4.2. 分支语句

if 语句

if ( 条件表达式 )
    语句块;
else
    语句块;

switch 语句

switch ( 表达式 ) {
    case 判断值1: 语句块1;
    case 判断值2: 语句块2;
    case 判断值n: 语句块n;
    default: 语句块n+1
}

4.3. 循环语句

while 语句

while ( 条件表达式 )
    循环体

do-while 语句

do
    循环体
while ( 条件表达式 );

for 语句

for ( 表达式1; 表达式2; 表达式3 )
    循环体

4.3.1. 寻找水仙花数

参考教材

例3-8 p.55

public class Narcissus {
    public static void main(String args[]) {
        int i, j, k, n = 100, m = 1;

        while(n < 1000) {
            i = n / 100; // 计算百位数
            j = (n - i * 100) / 10; // 计算十位数
            k = n % 10; // 计算个位数
            if((Math.pow(i, 3) + Math.pow(j, 3) + Math.pow(k, 3)) == n)
                System.out.println("找到第" + m++ + "个水仙花数:" + n);
            n++;
        }
    }
}
// 找到第1个水仙花数:153
// 找到第2个水仙花数:370
// 找到第3个水仙花数:371
// 找到第4个水仙花数:407

4.4. 跳转语句

参考教材

3.4.4 pp.58-59

continue 语句

break 语句

return 语句

5. 数组

一维数组

int array1[];
// or
int [] array2;

二维数组

int array1[][];
// or
int [][] array2;

第二知识单元

Java程序设计 第2讲，主讲人：李欣

0.1. 互动课堂

0.2. 签到

0.3. 本次课的目标

1. Java程序的构成

1.1. 示例程序

1.2. 编译程序

1.3. 解释执行

1.4. 思考：什么是主类？

1.4.1. 一般情况

1.4.2. 多个类具有public修饰的情况

1.4.3. 多个类均包含main方法的情况

1.4.4. 多个类均包含main方法的情况

1.4.5. 没有main方法的情况

1.4.6. 没有类具有public修饰的情况

1.4.7. 结论

2. 数据类型、变量与常量

2.1. 数据类型

2.1.1. 如何使用？

2.2. 标识符

2.2.1. 合法与不合法的标识符的例子

2.2.2. Java标识符的习惯性约定

2.3. 常量

2.4. 变量

2.4.1. 处理用户输入

3. 表达式

3.1. 赋值与强制类型转换

3.1.1. 赋值

3.1.2. 强制类型转换

3.2. 字符串连接

3.3. 算术运算

3.3.1. 双目运算符

3.3.2. 单目运算符

3.4. 关系运算

3.5. 逻辑运算

3.5.1. 简洁、非简洁

3.6. 位运算

3.7. 其他运算符

3.8. 运算符的优先级与结合性

3.9. 注释

4. 流程控制语句

4.1. 结构化程序设计的三种基本流程

4.2. 分支语句

4.3. 循环语句

4.3.1. 寻找水仙花数

4.4. 跳转语句

5. 数组

Java程序设计第2讲，主讲人：李欣