第二知识单元
Java语言基础
Java程序设计 第2讲，主讲人：李欣
Created: 2024-09-04 Wed 20:52
0.1. 互动课堂
https://www.memopixel.com/course/java-2024/slides/lesson02?room=hylojy8qyvibnyeyrox6j9h7kn8fucrd
0.2. 签到
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()
- 变量名
- 采用 名词 ， 首字母 小写 ， 内含的单词首字母 大写
- 例如：
promptconnectNumber
- 常量名
- 全部大写 ，单词间用 下划线 分开
- 例如：
HEAD_COUNT
2.3. 常量
- 布尔常量
truefalse
- 整型常量
- 按采用的进制划分
- 十进制 ：非
0开头的数值，例如100-50 - 八进制 ：
0开头的数值，例如十进制的15用八进制表示为017 - 十六进制 ：
0x开头的数值，例如十进制的47用十六进制表示为0x2F
- 十进制 ：非
- 按占用内存长度划分
- 一般整型 ：占用32位
- 长整型 ：占用64位
-386L017777l
- 按采用的进制划分
- 浮点常量
- 一般浮点常量 ：占用32位
19.4F3.0513E38701.52f - 双精度浮点常量 ：占用64位
2.433E-5D700041.273d3.1415
- 一般浮点常量 ：占用32位
- 字符常量
- 一般Latin字符
'a''Z''8''#' - 转义字符
'\b''\t''\n''\r''\"''\'''\\' - Unicode码表示的的字符
'\u0008''\u0009''\u000a''\u000d' - 八进制数表示的字符
'\101'
- 一般Latin字符
- 字符串常量
"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);
0
int j = 0;
for(int i = 0; i < 100; i++){
j++;
}
System.out.println(j);
100
3.4. 关系运算
| 运算符 | 运算 |
|---|---|
== |
等于 |
!= |
不等于 |
> |
大于 |
< |
小于 |
>= |
大于等于 |
<= |
小于等于 |
关系运算的结果是 布尔型 的量，即 真 或 假 。
3.5. 逻辑运算
| 运算符 | 运算 | 例 | 运算规则 |
|---|---|---|---|
& |
非简洁与 | x & y |
x y 都真时结果才为真 |
| | | 非简洁或 | x|y | x y 都假时结果才为假 |
! |
取反 | !x |
x 真时为假 x 假时为真 |
^ |
异或 | x ^ y |
x y 同真假时结果为假 |
&& |
简洁与 | x && y |
x y 都真时结果才为真 |
| || | 简洁或 | x||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语言基础 Java程序设计 第2讲，主讲人：李欣 Created: 2024-09-04 Wed 20:52