Java核心技术· 卷一（11版）笔记（第1-3章）_java 核心技术卷

第一章 Java程序设计概述

1.1 Java的简单介绍

Java是一种跨平台的编程语言，广泛应用于企业级应用、嵌入式系统、移动应用等领域。Java程序可以在不同的操作系统和硬件平台上运行，具有高效性、安全性、稳定性等特点。

Java程序的编写需要使用Java开发工具，如Eclipse、NetBeans、IntelliJ IDEA等。编写完成后，Java程序需要通过编译器将其转换为字节码，然后再通过Java虚拟机（JVM）解释执行。

Java程序的基本组成部分包括类、对象、方法、变量、运算符等，Java程序也支持面向对象编程的特性，如封装、继承和多态。

Java程序在应用中广泛使用，比如Web应用开发、企业应用开发、游戏开发、移动应用开发等。同时，Java也成为了许多其他编程语言的基础，如Scala、Groovy等。

1.2 Java “白皮书” 关键词

1. 简单性
2. 面对对象
3. 分布式
4. 健壮性
5. 安全性
6. 体系结构中立
7. 可移植性
8. 解释型
9. 高性能
10. 多线程
11. 动态性

1.3 Java 发展史

Java是一种跨平台的编程语言，它的发展始于上世纪90年代初期，以下是Java的发展史：

1. 1991年，Sun公司成立Green Team小组，开始研究一种新的编程语言，初期称为Oak。
2. 1994年，Oak语言更名为Java，并公开发布。
3. 1995年，Java 1.0正式发布，引起广泛关注。
4. 1997年，Java 1.1发布，增加了内部类、JavaBean等特性。
5. 1998年，Sun公司发布Java 2，其中包含了许多新特性，如Swing组件、Java Naming and Directory Interface（JNDI）和RMI-IIOP等。
6. 2000年，Java 2被更名为Java SE（Standard Edition）、Java EE（Enterprise Edition）和Java ME（Micro Edition）。
7. 2004年，Java 5发布，引入了自动装箱、泛型、枚举等新特性。
8. 2006年，Sun公司发布Java SE 6，包括了更高效的XML处理、JDBC 4.0和Java Compiler API等。
9. 2009年，Oracle收购了Sun公司，成为Java的新所有者。
10. 2011年，Java 7发布，引入了Switch语句的字符串支持、NIO.2文件处理和多语言环境等新特性。
11. 2014年，Java 8发布，引入了Lambda表达式、Stream API、日期时间API等新特性。
12. 2017年，Java 9发布，引入了模块化系统、接口私有方法等新特性。
13. 2018年，Java 10发布，引入了局部变量类型推断等新特性。
14. 2019年，Java 11发布，引入了HTTP客户端API、局部变量类型推断等新特性。

Java在过去几十年中不断发展和完善，成为一种广泛应用的编程语言，应用于大量的企业应用、移动应用和Web应用开发中。

第二章 Java程序环境设计

2.1 Java开发相关术语

2.2 Java开发环境配置

JDK（Java Development Kit）是Java程序开发所必须的开发工具包，包含了Java编译器、JVM（Java虚拟机）和一些Java工具等。下面是在Windows系统上安装JDK的步骤：

1. 下载JDK安装包

在Oracle官网上下载JDK安装包，链接为：https://www.oracle.com/java/technologies/javase-downloads.html
选择与你所用操作系统相应的版本进行下载安装。

2. 安装JDK

双击下载好的JDK安装包，按照提示进行安装。选择默认安装路径即可。

3. 配置环境变量

打开“我的电脑”右键“属性”，选择“高级系统设置”，再选择“环境变量”，在系统变量中找到“Path”，将JDK的安装路径加入到Path中，例如：C:\Program Files\Java\jdk1.8.0_231\bin

4. 验证JDK安装

在命令行中输入“java -version”，如果出现JDK版本信息，则表示JDK已经安装成功。

到此，JDK安装就完成了。JDK（Java Development Kit）是Java程序开发所必须的开发工具包，包含了Java编译器、JVM（Java虚拟机）和一些Java工具等。下面是在Windows系统上安装JDK的步骤：

1. 下载JDK安装包

在Oracle官网上下载JDK安装包，链接为：https://www.oracle.com/java/technologies/javase-downloads.html
选择与你所用操作系统相应的版本进行下载安装。

2. 安装JDK

双击下载好的JDK安装包，按照提示进行安装。选择默认安装路径即可。

3. 配置环境变量

打开“我的电脑”右键“属性”，选择“高级系统设置”，再选择“环境变量”，在系统变量中找到“Path”，将JDK的安装路径加入到Path中，例如：C:\Program Files\Java\jdk1.8.0_231\bin

4. 验证JDK安装

在命令行中输入“java -version”，如果出现JDK版本信息，则表示JDK已经安装成功。

到此，JDK安装就完成了。

第三章 Java的基本程序设计结构

3.1 Java的基本程序结构

Java的基本程序结构包括以下几个部分：

1. 包声明：即package语句，用来表示该程序所属的包。
2. 导入声明：即import语句，用来导入其他包中的类或接口。
3. 类定义：即class语句，用来定义一个类。一个Java程序中可以有多个类，但只能有一个public类。
4. 方法定义：即method语句，用来定义一个方法。一个类中可以有多个方法。
5. 变量定义：即variable语句，用来定义变量。在Java中，必须先定义变量，然后才能使用它们。
6. 语句：即statement语句，用来描述程序的执行流程。在Java中，常用的语句包括条件语句、循环语句、switch语句、赋值语句等。
7. 注释：即comment语句，用来对程序进行注释说明，便于程序的理解和修改。

Java程序的基本结构如下所示：

package com.example;

import java.util.*;

public class MyClass {
   
    public static void main(String[] args) {
   
        int a = 0;
        int b = 1;
        int c = a + b;
        System.out.println("The answer is: " + c);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

其中，package语句表示该程序属于com.example包；import语句导入了java.util包；类定义使用了public关键字；main方法是程序的入口，它输出了一个字符串和计算结果。

3.2 Java的注释

Java语言中有三种类型的注释：

1. 单行注释：使用"//“符号，从”//"到该行末尾的所有内容都会被注释。

// 这是一个单行注释
1

2. 多行注释：使用"/“表示开始注释，使用”/"表示结束注释，中间的所有内容都会被注释。

/*
这是一个多行注释
可以注释多行内容
*/
1
2
3
4

3. 文档注释：使用"/**“表示开始注释，使用”*/"表示结束注释，中间的内容会被Javadoc工具解析成HTML文档，用于生成API文档。

/**
 * 这是一个文档注释
 * 可以用来生成API文档
 */
1
2
3
4

3.3 Java的数据类型

基本数据类型具有固定的大小和范围，而引用数据类型则需要在程序运行时动态分配内存空间。在Java中，基本数据类型是按值传递的，而引用数据类型是按引用传递的。

3.3.1 基本数据类型

基本数据类型：Java提供了8种基本数据类型，分别是
整型：byte、short、int、long；
浮点型：float、double；
字符型：char；
布尔型：boolean。

定义方式如下：

byte：byte variableName = value;
short：short variableName = value;
int：int variableName = value;
long：long variableName = valueL;
float：float variableName = valueF;
double：double variableName = value;
char：char variableName = value;
boolean：boolean variableName = value;
1
2
3
4
5
6
7
8

其中，value可以是一个字面量，也可以是一个变量。

3.3.2 引用数据类型

引用数据类型是指除了上述基本数据类型以外的数据类型，如类、数组、接口等。在Java中，引用类型的变量存储的是一个指向对象的内存地址。

类类型：自定义类（例如String、Math等）
接口类型：自定义接口
数组类型：int[]、String[]等

定义方式如下：

类类型：ClassName variableName = new ClassName();
接口类型：InterfaceName variableName = new ClassName();
数组类型：TypeName[] arrayName = new TypeName[length];
1
2
3

其中，ClassName、InterfaceName、TypeName分别表示类、接口、数据类型的名称，new关键字用来创建对象，length表示数组的长度。

3.4 常量和变量

Java中常量和变量是有明显区别的：

1. 常量是不可变的，一旦声明后就不能再被修改。而变量是可以被修改的，它们的值可以随时被重新赋值。

2. 常量的值在编译时就固定下来了，而变量的值在程序运行时才确定。

3. 常量必须在声明时赋值，而变量可以先声明再赋值或在声明时同时赋值。

4. 常量使用关键字final来声明，变量则不需要。

5. 常量一般使用大写字母表示，变量则使用小写字母表示。

总的来说，常量可以看作是一种特殊的变量，其值不能被修改，并且在程序中多次使用时可以保持一致。而变量则用来存储可变的数据，它们的值会随着程序的执行而发生变化。

3.4.1 在Java中声明变量时需要注意：

1. 变量名必须是合法的标识符，即符合Java命名规范，可以包含字母、数字、下划线和美元符号等字符，但不能以数字开头。

2. 变量名应该具有描述性，能够清晰地表达变量的含义。

3. 变量的类型必须在声明时确定，可以是Java内置的基本数据类型（如int、double、boolean等），也可以是自定义的引用类型（如类、接口、数组等）。

4. 变量必须先声明后使用，否则会出现编译错误。

5. 变量可以在声明时初始化，也可以在后面的代码中赋值。

6. 变量的作用域取决于它们的声明位置，在同一作用域中不能存在重名的变量。

7. 变量的值可以被改变，但对于被声明为final的变量，其值不能被重新赋值。

3.4.2 变量初始化

在Java中，变量必须先被初始化，才能被使用。变量初始化是指为变量赋初值，使其拥有初始状态。变量可以在声明时进行初始化，或在程序执行中进行初始化。

下面是示例代码：

// 在声明时初始化
int a = 10;
String str = "Hello World";

// 在程序执行中初始化
int b;
b = 20;

// 多个变量同时进行初始化
int c = 30, d = 40;
double e = 3.1416;
1
2
3
4
5
6
7
8
9
10
11

注意：如果变量在声明后没有被初始化，它将会默认赋值为其类型的初始值。例如，int类型的变量默认值为0，String类型的变量默认值为null。

3.4.3 Java的常量

Java常量是指在程序中定义一次后不会改变的值。常量声明后，其值不能被修改，因此常量在程序运行期间一直保持不变，常量在Java中使用关键字final来声明。

关键词final 表示这个变量只能赋值一次。

常量可以是数值、布尔值或字符串等数据类型。声明常量时，变量名通常使用全大写字母，且单词之间用下划线分隔。

例如，以下是声明一个整型常量的示例：

final int MAX_COUNT = 100;
1

以下是声明一个字符串常量的示例：

final String MESSAGE = "Hello World!";
1

3.4.4 枚举类型

Java枚举（Enum）类型是一种特殊的数据类型，它允许我们定义一个有限的、预先定义的、可枚举的值集合。

枚举类型可以在switch语句中使用，也可以通过枚举类型的values()方法返回枚举值的集合。枚举类型是类型安全的，可以用来替代常量。

以下是定义一个简单的枚举类型的示例：

public enum Weekday {
   
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
1
2
3
4

使用上述枚举类型的示例：

public class TestEnum {
   
    public static void main(String[] args) {
   
        Weekday day = Weekday.MONDAY;
        switch (day) {
   
            case MONDAY:
                System.out.println("This is Monday.");
                break;
            case TUESDAY:
            case WEDNESDAY:
            case THURSDAY:
            case FRIDAY:
                System.out.println("This is a weekday.");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("This is a weekend day.");
                break;
            default:
                System.out.println("Invalid day.");
                break;
        }
    }
}

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

3.5 运算符

3.5.1 算术运算符

Java语言中的算术运算符包括加法运算符（+）、减法运算符（-）、乘法运算符（*）、除法运算符（/）、取余运算符（%）和自增自减运算符等。

以下是一些示例：

1. 加法运算符（+）：

int a = 10;
int b = 20;
int sum = a + b;
System.out.println("a + b = " + sum);
1
2
3
4

输出结果为：a + b = 30

2. 减法运算符（-）：

int a = 30;
int b = 20;
int diff = a - b;
System.out.println("a - b = " + diff);
1
2
3
4

输出结果为：a - b = 10

3. 乘法运算符（*）：

int a = 10;
int b = 20;
int product = a * b;
System.out.println("a * b = " + product);
1
2
3
4

输出结果为：a * b = 200

4. 除法运算符（/）：

int a = 20;
int b = 10;
int quotient = a / b;
System.out.println("a / b = " + quotient);
1
2
3
4

输出结果为：a / b = 2

5. 取余运算符（%）：

int a = 20;
int b = 3;
int remainder = a % b;
System.out.println("a % b = " + remainder);
1
2
3
4

输出结果为：a % b = 2

6. 自增自减运算符（++，–）：

int a = 10;
a++;
System.out.println("a++ = " + a);

int b = 20;
b--;
System.out.println("b-- = " + b);
1
2
3
4
5
6
7

输出结果为：a++ = 11，b-- = 19

3.5.2 数学函数和常量

Java中提供了一些数学函数和常量，这些函数和常量可以帮助我们进行数学计算和处理。

3.5.2.1 常用的数学函数和常量：

常量：

Math.E：自然对数的底数e。

Math.PI：圆周率π。

Math.sqrt(x)：返回x的平方根。

Math.pow(x, y)：返回x的y次幂。

Math.abs(x)：返回x的绝对值。

Math.max(x, y)：返回x和y中的最大值。

Math.min(x, y)：返回x和y中的最小值。

Math.round(x)：返回最接近x的整数。

Math.floor(x)：返回小于等于x的最大整数。

Math.ceil(x)：返回大于等于x的最小整数。

Math.random()：返回一个0到1之间的随机小数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.5.2.2 数学函数和常量的实例：

public class MathExample {
   
    public static void main(String[] args) {
   
        double x = 2.0;
        double y = 4.0;
        
        // 求绝对值
        System.out.println("Abs of x: " + Math.abs(x)); // 2.0
        
        // 求最大值和最小值
        System.out.println("Max of x and y: " + Math.max(x, y)); // 4.0
        System.out.println("Min of x and y: " + Math.min(x, y)); // 2.0
        
        // 求平方根
        System.out.println("Sqrt of x: " + Math.sqrt(x)); // 1.4142135623730951
        
        // 求幂
        System.out.println("x to the power y: " + Math.pow(x, y)); // 16.0
        
        // 求自然对数的底数e的幂
        System.out.println("e to the power x: " + Math.exp(x)); // 7.3890560989306495
        
        // 求对数
        System.out.println("Logarithm of x: " + Math.log(x)); // 0.6931471805599453
        
        // 求正弦、余弦和正切
        System.out.println("Sine of x: " + Math.sin(x)); // 0.9092974268256817
        System.out.println("Cosine of x: " + Math.cos(x)); // -0.4161468365471424
        System.out.println("Tangent of x: " + Math.tan(x)); // -2.185039863261519
        
        // 求反正弦、反余弦和反正切
        System.out.println("Arcsine of x: " + Math.asin(x)); // NaN
        System.out.println("Arccosine of x: " + Math.acos(x)); // NaN
        System.out.println("Arctangent of x: " + Math.atan(x)); // 1.1071487177940904
        
        // 求角度的弧度值
        double degrees = 45.0;
        double radians = Math.toRadians(degrees);
        System.out.println(degrees + " degrees in radians: " + radians); // 0.7853981633974483
        
        // π和自然对数的底数e
        System.out.println("Pi: " + Math.PI); // 3.141592653589793
        System.out.println("Euler's number e: " + Math.E); // 2.718281828459045
    }
}

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

3.5.2.3 数学函数和常量需要注意的问题

Java中的数学函数和常量是在java.lang.Math类中定义的。这些函数和常量可以对数值进行操作，实现各种数学运算。以下是使用Java数学函数和常量时需要注意的问题：

1. 函数参数和返回值的数据类型要匹配。例如，Math.sqrt函数的参数必须为double类型，返回值也是double类型。

2. 注意数学函数的精度问题。Java中的数学函数并不总是能够准确地计算出数字的值。因此，在进行数学运算时，应该注意精度问题。

3. 对于函数参数的范围限制要了解。例如，Math.log函数的参数必须为正数，否则会抛出异常。

4. 注意常量的值和含义。Java中定义了很多数学常量，如Math.PI和Math.E等。在使用这些常量时，要注意它们的值和含义。

5. 对于特殊情况要进行特殊处理。例如，Math.pow函数的底数为负数，指数为小数时，要进行特殊的处理。

总之，在使用Java数学函数和常量时，要仔细阅读文档，了解函数参数和返回值的数据类型、参数范围限制、精度问题等，以确保程序正确运行。

3.5.3 数值之间的转换

Java中有多种基本类型的数值，如int、double、float、long、short、byte等。在需要进行数值转换的情况下，我们可以使用Java的类型转换操作符。

Java中的类型转换分为隐式类型转换和显式类型转换两种方式。

1. 隐式类型转换：

隐式类型转换是指将一个小范围类型的值自动转换为大范围类型的值，例如将byte类型转换为int类型。

byte -> short -> int -> long -> float -> double
char --^

示例代码：

byte b = 10;
int i = b; // byte类型的值自动转换为int类型的值
System.out.println(i); // 输出10
1
2
3

2. 显式类型转换：

显式类型转换是指将一个大范围类型的值强制转换为小范围类型的值，例如将int类型转换为byte类型。

示例代码：

int i = 256;
byte b = (byte)i; // 将int类型的值强制转换为byte类型的值
System.out.println(b); // 输出0，因为byte类型的取值范围是-128到127，超出范围的值会被截断
1
2
3

需要注意的是，显式类型转换可能会造成精度丢失或溢出的情况，因此需要谨慎使用。

另外，Java中的数值转换也可能会出现以下问题：

1. 数据类型范围溢出：当转换的数值超出目标数据类型的范围时，会发生溢出，导致结果不正确。

2. 精度丢失：当转换的数值包含小数时，可能会出现精度丢失的情况。

3. 四舍五入问题：当进行浮点数转换时，可能会出现四舍五入问题，导致结果不准确。

4. 转换异常&