IDEA快捷键

• 创建main函数

psvm + Tab

• 创建printf函数

souf + Tab

• 创建println函数

sout + Tab

• 代码格式化

Ctrl + Alt + L

1 Java基础知识

1 Java特性

• Java语言是简单的

  • Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用。
  • Java丢弃了C++中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。
  • 特别地，Java语言不使用指针，而是引用，并提供了自动分配和回收内存空间的机制，使得程序员不必为内存管理而担忧。

• Java语言是面向对象的

  • Java语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。
  • Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。
  • 总之，Java语言是一个纯的面向对象程序设计语言。

• Java语言是分布式的

  • Java 语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。
  • Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。

• Java语言是健壮的

  • Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。
  • 对指针的丢弃是Java的明智选择。
  • Java的安全检查机制使得Java更具健壮性。

• Java语言是安全的

  • Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。
  • 除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java应用设置安全哨兵。

• Java语言是体系结构中立的：

  • Java程序（后缀为 java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。
  • 这种途径适合于异构的网络环境和软件的分发。

• Java语言是可移植的

  • 这种可移植性来源于体系结构中立性
  • Java还严格规定了各个基本数据类型的长度，使各个平台的基本数据类型长度统一。
  • Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。

• Java语言是解释型的：

  • 如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统中运行。
  • 在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
  • Java源程序（解释型）与编译型源程序（如C/C++）运行的区别

• Java是高性能的：

  • 与那些解释型的高级脚本语言相比，Java的确是高性能的。
  • 事实上，Java的运行速度随着JIT(Just-In-Time）编译器技术的发展越来越接近于C++。

• Java语言是多线程的：

  • 在Java语言中，线程是一种特殊的对象，它必须由Thread 类或其子（孙）类来创建。
  • 通常有两种方法来创建线程：其一，使用型构为Thread(Runnable) 的构造子类将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。
  • 值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。
  • 线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。

• Java语言是动态的：

  • Java 语言的设计目标之一是适应于动态变化的环境。
  • Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类，这也有利于软件的升级。
  • 另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

2 Java术语

• Java SE（Java Platform, Standard Edition）

Java SE是Java的标准版本，是JDK的具体实现，一般说的Java就是指Java SE。

• Java EE（Java Platform，Enterprise Edition）

Java EE是Java的企业版本，是在Java SE的基础上发展出来的一套接口规范

• Java ME（Java Platform，Micro Edition）

Java SE的微型版本，用于嵌入式设备

• JDK（Java Development Kit）

JDK包括Java程序设计语言、Java虚拟机和Java类库，是支持Java程序开发的最小环境

• JRE（Java Runtime Environment）

JRE包括Java虚拟机和Java类库中的Java SE API子集，是支持Java运行的标准环境

• Java版本号
  • Java版本号实际上指的是JDK的版本号
  • JDK从1.5版本开始，发行版本号启用了JDK 5这样的新命名方法。
  • 从JDK 10开始，JDK的开发版本号放弃了之前的1.x的命名形式

3 Java环境变量配置

• 环境变量定义

环境变量是在操作系统中一个具有特定名字的对象，它包含了一个或者多个应用程序所将使用到的信息。

• 我们通过一个具体的应用场景来理解：毫无疑问，想要运行一个软件，我们必须知道其启动程序程序的位置，同样的在命令行输入一个命令，计算机需要知道命令所在位置，否则会提示没有此命令。
• 当我们输入“notepad”打开记事本程序时，操作系统会去环境变量已保存的路径中查找是否存在notepad程序。
• 如果没有配置好环境变量，我们就必须告诉操作系统绝对路径：”C:\Windows\notepad”

• 环境变量配置

在初次安装Java后，为了更加方便的使用，需要配置环境变量。或者说安装了新版本的JDK后，使用java -version查看发现还是之前的版本，这也是环境变量配置的原因。
通常情况我们需要配置以下三个环境变量：

• 新建变量 **JAVA_HOME**：指向JDK的安装目录，作用是一些基于Java开发的工具会用到，比如tomcat、Eclipse，如果不用这些工具不需要配置。
• 追加变量 **PATH**：指向JDK安装目录下的bin目录，作用是指定命令搜索路径，bin目录下有编译、启动（javac/java）等命令。为了任何目录位置下都可以直接输入命令，而不用输入长长的路径了。如果配置了JAVA _HOME ，直接把%JAVA_HOME%/bin追加到PATH中即可。
• 新建变量 **CLASSPATH**：在于告诉Java执行环境，在哪些目录下可以找到我们所要执行的Java程序所需要的类或者包。不过在JDK1.5之后的版本完全可以不用设置CLASSPATH环境变量就能正常运行程序。

4 包

• Java允许使用包（package）将类组织在一个集合中（包可以说是类的集合），借助包可以方便地组织自己的代码，并将自己的代码与别人提供的代码库分开管理。

• 为什么使用包

  • 使用包的主要原因是确保类名的唯一性（防止命名冲突）。

如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字必须是不同的，不同的包中的类的名字可以是相同的。当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

• 包声明
  • 在每个.java文件的第一行需要使用package关键字标注所属包

如MyClass.java文件属于pers.first包，那么MyClass.java文件的内容应该为

package pers.first;
public class MyClass {
    ...
}

• 每个源文件只能有一个包声明
• 如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中（即使它放在某个包的目录中）

• 包的命名

为了保证包名的绝对唯一性，要用一个因特网域名（显然是唯一的）以逆序的形式作为包名，然后对于不同的工程使用不同的子包。

• 如根据域名horstmann.com，得到包名com.horstmann，然后可以再追加一个工程名，即可得包名**com.horstmann.corejava**
• 包名通常以全部小写字母来命名

• 类的存储路径与包名

  • 在本地编译代码时，源文件应该放到与完整包名匹配的子目录中（编译器会将类文件.class放到相同目录），即类存储在文件系统的子目录中，类的路径必须与包名匹配。例如：

    • A.B.C包中的类a应该放到子目录A\B\C中，即A\B\C\a.java
    • A.B包中的类b应该放到子目录A\B中，即A\B\b.java

  • 编译器在编译源文件的时候不检查目录结构，如果一个源文件开头为packge com.my，但是它却不在子目录com\my中，而且它不依赖于其他包，那么也可以进行编译。但最终程序无法运行，除非将所有类文件移到正确的位置上，因为包与目录不匹配时，虚拟机找不到类。

• 类的完全限定名

每个类有其“完全限定”名（全名），保证其唯一性，如java.util包内的Date类，其完全限定名就是java.util.Date

• 嵌套的包之间没有任何关系

如java.util包与java.util.jar包毫无关系，两个包都包含了多个类，都是独立的类集合。

• 常用的java内置包
  • java.lang包含基础的类
  • java.io包含输入输出功能的函数

5 类的导入

• 一个类可以访问所属包中的所有类，以及其他包中的公共类（public class）
  1. 同一个包内可以直接使用类名访问
  2. 访问另一个包中的公共类则有两种方式

使用类的完全限定名，不需要import相应包

  - 如`java.time.LocalDate today = java.time.LocalDate.now();`

使用**import**语句导入包中一个特定的类或者所有类。

  - 使用`import`语句后，就不必使用类的完全限定名了

• import语句应位于源文件的顶部，但位于package语句的后面。

• 在包名后面加上*，可以导入包中的所有类

如import java.time.*

• 这种方式语法简单，对代码的规模也没有任何负面影响。
• 只能使用*****导入一个包中的所有类，而不能使用import java.*或import java.*.*导入以java为前缀的所有包的所有类。
• 使用*导入包很方便，但在发生命名冲突时需要注意

• 静态导入

**import static**语句允许导入静态方法和静态字段，
如import static java.lang.Math.*

• 静态导入的方式可以直接使用类的静态方法和静态字段，而不必加类名前缀

如直接使用sqrt(x)而不是Math.sqrt(x)

• 有时使用静态导入会使代码看起来不太清晰。

2 Java的基本程序设计结构

2.1 我的第一个Java程序

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

• 类是构建所有Java应用程序的构建块。
• Java应用程序的全部内容都必须放置在类中。

即Java中的所有函数都是某个类的方法，所以main()方法必须有一个外壳类（shell）

2.2 代码规则

• 在Java中，每个句子必须用分号结束。

• 回车不是语句结束的标志，因此，可以将一条语句写在多行上。

注意：回车符不在一个完整的单词中间，只能在符号的前面或后面

• 点号.用于调用类/对象的方法

2.3 注释

• Java三种注释方式
  • **//**

这种方式，其注释内容从//开始到本行结尾

• **/* … */**

这种注释界定符可以将一段比较长的多行注释括起来

  - 该种注释**不能嵌套**

• **/** … */**

这种注释方式可以用来自动地生成文档

2.4 变量

• 与所有其他语言一样，Java也使用变量来存储值。变量就是申请内存来存储值，也就是说，当创建变量的时候，需要在内存中申请空间，内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
  • Java有两大类数据类型
    • 内置数据类型（基本数据类型）
    • 引用数据类型
  • 主要有如下三种类型的变量
    • 局部变量

类的方法中的变量

  - **类变量（静态变量）**

独立于方法之外的变量，用static修饰。

  - **实例变量（非静态变量）**

独立于方法之外的变量，不过没有static修饰。

• 可以在一行中声明多个变量，不过建议每行声明一个变量，可以提高程序的可读性。

• 变量的命名

  • 变量名必须以字母开头，同时建议以小写字母开头
  • 由多个单词组成的变量名，常采用驼峰命名法，如hireDay
  • 许多程序员将变量名命名为类型名的小写，或者在变量名前加前缀“a”

    Box box;
    Box abox;

• 变量的声明和初始化

  • 可以将变量的声明和初始化放在同一行，如int vacationDays = 12;
  • 变量的声明可以放在代码中的任何地方

局部变量

• 局部变量各概念

  • 局部变量的声明与可见性

    • 局部变量声明在类的方法或者方法的语句块中；
    • 局部变量只在声明它的方法、构造方法或者语句块中可见；

  • 生存周期

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

• 访问修饰符不能用于局部变量；

• 存储位置

局部变量是在栈上分配的。

• 局部变量没有默认值（包括对象和基本数据类型，都没有默认值），所以局部变量被声明后，必须经过初始化，才可以使用。

• 语句块内局部变量的可见性 ```java public class MyClass { public static void main(String[] args) throws IOException {

    for(int i = 0;i<1;i++) {
        int x = 0;    //仅声明此变量的大括号内可见
    }
    if(true){
        int y = 0;    ////仅声明此变量的大括号内可见
    }
    if(true)
        int z = 0;    //报错：Declaration not allowed here
    System.out.println(x);  //报错：Cannot resolve symbol 'x'
    System.out.println(y);  //报错：Cannot resolve symbol 'y'

  }

}

从上例中我们可以看到
   - **在如**`**if**`**、**`**for**`**、**`**while**`**等语句块中声明的变量，语句块外不可见，即使是在同一个方法中**
   - 如果想要在某个函数体内声明变量，必须加上大括号
- **var关键字**
   - 对于局部变量，如果可以从变量的初始值推导出它们的类型，那么可以用`var`关键字声明局部变量，而无需指定类型。
```java
var vacationDays = 12;    //vacationDays is an int
var greeting = "Hello";    //greeting is a String
var date = LocalDate.now();    //date is a LocalDate

• var关键字只能用于方法中的局部变量，方法的参数和类的实例字段的类型必须声明。

实例变量

• 实例变量声明在一个类中，方法之外；

• 生存周期

实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

• 实例变量对于类中的方法、构造方法或者语句块都是可见的。

• 一般情况下应该把实例变量设为private或protected

• 实例变量具有默认值（基础类型和对象都有默认值）。

• 实例变量可以直接通过变量名访问，但是在静态方法中不能直接访问

  • 静态方法访问实例字段

在静态方法中新建对象，然后通过对象名.变量名的方式可以访问实例字段

public class MyClass {
    private int a = 3;
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        System.out.println(myClass.a);    //静态方法访问实例字段，输出3
    }
}

类变量（静态变量）

• 在非访问控制符一节也有关于类变量的介绍

• 类变量也称为静态变量，在类中以static关键字声明，声明在一个类中，方法之外；

• 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

• 静态变量除了被声明为常量外很少使用

静态常量是指声明为final和static类型的变量，很少单独使用**static**声明变量。

• 静态变量储存在静态存储区。

• 生存周期

静态变量在第一次被访问时创建，在程序结束时销毁。

2.5 基本数据类型

• Java是一种强类型语言，必须为每一个变量声明一种类型

• Java共有8种基本类型

  • 4种整形类型

int、short、long、byte

• 2种浮点类型

float、double

• 1种字符类型

char

• 1种布尔值类型

boolean

2.5.1 整型

• 4种整型的各项数据表 | 类型 | 存储需求 | 取值范围 | | —- | —- | —- | | int | 4字节 | -2 147 483 64 ~ 2 147 483 647（-2.1×10^-9 ~ 2.1×10^9） | | short | 2字节 | -32 768 ~ 32 767（-2^15 ~ 2^15-1） | | long | 8字节 | 9.2×10-18 ~ 9.2×1018（-2^63 ~ 2^63-1） | | byte | 1字节 | -128 ~ 127（-2^7 ~ 2^7-1） |

  • Java为了可移植性，数据类型的取值范围必须固定，与运行Java代码的机器无关

    C和C++中，int和long等类型的字节大小与处理器的位数有关

  • 实际上对于基本类型的取值范围（除了boolean类型），我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。如int的包装类Integer

    public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
       // int  
       System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
       System.out.println("包装类：java.lang.Integer");  
       System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
       System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
    }  
    }

    输出结果：

    基本类型：int 二进制位数：32
    包装类：java.lang.Integer
    最小值：Integer.MIN_VALUE=-2147483648
    最大值：Integer.MAX_VALUE=2147483647

• byte与short的使用

  • byte类型用在大型数组中节约空间，主要用于代替整数，因为byte变量占用的空间只有int类型的四分之一；
  • short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；

• Java没有任何无符号（**unsigned**）形式的数据类型

• 前缀

前缀用于

• 十六进制：0x或0X
• 八进制：0（八进制表示法容易混淆，所以最好不要使用八进制常数）
• 二进制：0b或0B

各进制转换成字符串后仍以十进制表示

• 后缀

一个数后面加上后缀l或L表示长整型数，如100000000L，但是这个后缀在给long类型变量赋值时不是必须的。

long x = 100;    //可以通过编译

• 可以在数字中间加下划线，使得某些较长的数字更易读，如
  • 用1_000_000表示100万
  • 用0b0010_1000表示32

2.5.2 浮点型

• Java的浮点型数据遵循IEEE754规范，

一个浮点数的所有位共分为三部分：符号位，指数位，尾数位

• 表示范围
  • 负指数决定了浮点数所能表达的绝对值最小的非零数；

正指数决定了浮点数所能表达的绝对值最大的数
由此指数的位数决定了浮点数的取值范围。

• 指数是补码形式，对于float来说，真实指数为：E-127
• float：-2128 ~ 2128，即±3.4×1038
• double：-21024 ~ 21024，即±1.79×10308

• 精度
  • 浮点数的精度是由尾数的位数来决定的。
  • 浮点数在内存中是按科学计数法来存储的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响。
  • float

223 = 8388608，一共七位，由于最左为1的一位省略了，这意味着最多能表示8位数。
2*8388608 = 16777216 ，8位有效数字，但绝对能保证的有7位，即float的精度为7~8位有效数字

• double

252 = 4503599627370496，一共16位，同理，double的精度为16~17位。

• 2种浮点型的各种数据表 | 类型 | 存储需求 | 取值范围 | 精度/有效位 | | —- | —- | —- | —- | | float | 4字节 | -2128 ~ 2128，即±3.4×1038 | 7 ~ 8位 | | double | 8字节 | -21024 ~ 21024，即±1.79×10308 | 16 ~ 17位 |

• 后缀

在浮点数后面加上f或F可以表示float类型浮点数，没有后缀的浮点数值默认为double类型。
为float类型变量赋值时，浮点数必须加上f或F后缀，这一点与long型整数不同

float f = 3.14f;    //通过编译
float f = 3.14;        //错误，无法通过编译

• 底层的二进制数不能精确表示所有的小数，有时会产生一些意想不到的问题，如：

  0.99999999f==1f //true 
  0.9f==1f        //false

  因此，不能使用**==**判断两个浮点数是否相等

• 由于float类型的精度较小，只有很少情况适合使用float数据，使用浮点数通常使用**double**类型。

• 浮点数值不适用与无法接受舍入误差的计算，如果在数值计算中不允许有任何舍入误差，应该使用**BigDecimal类。**

2.5.3 字符型

• 使用单引号''括起来的值是char型值

• char类型用于表示单个字符和Unicode字符

• 尽量不要在程序中使用**char**型数据，表示字符时请使用String类。

2.5.4 布尔型

• boolean类型有两个值：false和true，用来判定逻辑条件。

• 整型值和boolean值之间不能进行相互转换。

2.5.5 各类型数据的默认值

• 如果只声明了一个变量，而没有对其显式赋值，那么变量将根据其类型而被赋予默认值

  • 注意，这里只限于类的实例变量或类变量；局部变量没有默认值，不初始化就不能使用（除了局部数组变量，其在任何位置都可以被赋予默认值）。 ```java public class MyClass {

    private static int a;

    public static void main(String[] args) { int b; System.out.println(a); //编译通过 System.out.println(b); //因为b没有被初始化，编译不通过 }

}

- **各类型对应的默认值表**
| **数据类型** | **默认值** |
| --- | --- |
| **byte** | 0 |
| **short** | 0 |
| **int** | 0 |
| **long** | 0L |
| **float** | 0.0f |
| **double** | 0.0 |
| **char** | 'u0000' |
| **boolean** | false |
| **any object** | null |
<a name="e91c060c0c25d5ac53569620cb7b9641"></a>
### 2.5.6 包装类
- 一般地，当需要使用数字的时候，我们通常使用内基本据类型，如：`byte`、`int`、`long`、`double`等。
**在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形**。为了解决这个问题，**Java语言为每一个内置数据类型提供了对应的包装类。**
- 数字类基本类型都是抽象类`Number`的子类，`boolean`和`char`则不然，具体看下图
![](https://cdn.nlark.com/yuque/0/2021/png/1169704/1615286240563-4363283f-b235-4aa0-97cf-066aaa338506.png#crop=0&crop=0&crop=1&crop=1&height=235&id=a9dr0&originHeight=235&originWidth=545&originalType=binary&ratio=1&rotation=0&showTitle=false&size=0&status=done&style=none&title=&width=545)
- 由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型**装箱**为包装类。相似的，编译器也可以把一个对象**拆箱**为内置类型。
   - **实例**
```java
public class Test{
    public static void main(String[] args){
      Integer x = 5;    //当x被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱
      x =  x + 10;    //为了使x能进行加运算，所以要对x进行拆箱
      System.out.println(x);    //输出15
   }
}

• 由于装箱与拆箱操作的存在，包装类和基本数据类型可以混用

如double Math.abs(double d)明确要求参数类型是基本数据类型，但也可以使用Double实例作为参数

Double d = -0.05;
d = Math.abs(d);    //编译通过，经历了拆箱：Math.abs(d)和装箱：d = 0.05

• 包装类与基本类型比较

包装类变量在与基本数据类型变量比较时，包装类会自动拆拆箱为基本类型，然后进行比较，实际上就是两个基本类型变量进行比较。

• **Integer**类型变量引用的地址

  • Java 会对[-128, 127]范围内的整数进行缓存，所以当定义两个Integer变量初始化值位于[-128, 127]之间时，两个Integer变量使用了同一地址：

    Integer a=123;
    Integer b=123;
    System.out.println(a==b);        //out: true
    System.out.println(a.equals(b));//out: true

  • 当两个 Integer 变量的数值超出[-128, 127]范围时, Integer变量使用了不同地址：

    Integer a=1230;
    Integer b=1230;
    System.out.println(a==b);        //out: false
    System.out.println(a.equals(b));//out: true

###Number类（java.lang包）

• Number类是抽象类，方法在类中并没有实现，而是由各种包装类实现的。
• 这一节还包括一些包装类自己实现的方法。

动态方法
**number**指代任意数字基本型的包装类实例，如**Integer number;**

• xxx number.xxxValue()

将number转换为xxx数据类型的值并返回，xxx可以是6种数字基本类型

Integer a = 10;
System.out.println(a.doubleValue());    //输出10.0

• String number.toString()

用于将数字转为字符串

• 重写了Object类的toString()方法，直接返回number的字符串形式
• 也可以使用String类的静态方法String.valueOf() ```java Integer i = 857; System.out.println(i.toString().equals(“857”)); //out: true

Double d = 0.556; System.out.println(d.toString().equals(“0.556”)); //out: true

**静态方法**<br />`**Number**`**指代任意数字包装类，如**`**Integer**`
- `Short Short.valueOf(short i)`
- `Integer Integer.valueOf(int i)`
- `Long Long.valueOf(long i)`
- `Float Float.valueOf(float i)`
- `Double Double.valueOf(double i)`
- `Byte Byte.valueOf(byte i)`
- `**Number Number.valueOf(String s)**`
这几个方法是包装类的**静态工厂方法（包装类构造方法已弃用）**
   - 前6个方法可以将基本数据类型转换为相对应的包装类（不太常用，一般直接使用`=`号赋值）
      - 无法将参数转换为非对应的包装类，如`Integer.valueOf(0.0)`无法通过编译）
   - **最后一个函数最常用，用于将字符串转为字面数值。**
      - 这里所有6个数字包装类都可以接受并转换字符串参数
```java
Double d = Double.valueOf(6.0);    //等价于Double d = 6.0
Double d = Double.valueOf("100.99");    //d == 100.99
Integer i = Integer.valueOf("9875");    //i == 9875

• 参数为字符串时，实际上调用的是parseXxx()方法，如Integer.valueOf(String str)的源码为

  public static Integer valueOf(String s) throws NumberFormatException {
  return Integer.valueOf(parseInt(s, 10));
  }

• **number Number.parseNumber(String s)**

将字符串解析为数字

int x =Integer.parseInt("9");    //x == 9
double c = Double.parseDouble("5");    //c == 5.0

###Character类API（java.lang包）

静态方法

• boolean Character.isLetter(char ch)

如果字符为字母，则返回true；否则返回false。

• boolean Character.isDigit(char ch)

如果字符为字母，则返回true；否则返回false。

• boolean Character.isWhitespace(char ch)

如果字符为空白字符，则返回true；否则返回false。

• boolean Character.isUpperCase(char ch) / boolean Character.isLowerCase(char ch)

如果字符为大写字母/小写字母，则返回true；否则返回false。

• char Character.toUpperCase(char ch) / char Character.toLowerCase(char ch)

返回转换后字符的大写/小写形式，如果有的话；否则返回字符本身。

2.6 数学问题

2.6.1 运算符

• 计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：
  • 算术运算符
  • 关系运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符
  • 其他运算符

算术运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。
表格中的实例假设整数变量A的值为10，变量B的值为20：

关系运算符
下表为Java支持的关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：

位运算符
位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

赋值运算符
下面是Java语言支持的赋值运算符：

条件运算符（?:）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。
该运算符的主要是决定哪个值应该赋值给变量。

• 语法格式：

  variable x = (expression) ? value if true : value if false

instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类或接口）。

• instanceof运算符使用格式如下：

  (对象) instanceof (类/接口名)

  • 如果运算符左侧变量所指的对象，是操作符右侧类或接口（class/interface）的一个对象，那么结果为真。

    String name = "James";
    boolean result = name instanceof String; // 由于name是String类型，所以返回true

  • 如果被比较的对象兼容于右侧类型,该运算符仍然返回true。 ```java class Vehicle {}

public class Car extends Vehicle { public static void main(String[] args){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println(result); //输出true } }

**运算符优先级**
- 当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
- **下表列出了运算符的优先级和结合性**
| **优先级** | **运算符类别** | **运算符** | **结合性** |
| --- | --- | --- | --- |
| 1 | 后缀 | ()、[]、.（点操作符） | 左到右 |
| 2 | 一元 | +（正号）、-（符号）、!、~、++、-- | 右到左 |
| 3 | 乘性  | *、/、％ | 左到右 |
| 4 | 加性  | +、- | 左到右 |
| 5 | 移位  | >>、<<、>>>  | 左到右 |
| 6 | 关系、类型 | >、>=、<、<=、instanceof  | 左到右 |
| 7 | 相等  | ==、!= | 左到右 |
| 8 | 按位与 | ＆ | 左到右 |
| 9 | 按位异或 | ^ | 左到右 |
| 10 | 按位或 | &#124; | 左到右 |
| 11 | 逻辑与 | && | 左到右 |
| 12 | 逻辑或 | &#124;&#124; | 左到右 |
| 13 | 条件 | ?: | 右到左 |
| 14 | 赋值 | =、+=、-=、*=、/=、％=、 >>=、<<=、＆=、 ^=、&#124;= | 右到左 |
<a name="340f35056bdd25994b73f1659725a6f7"></a>
### 2.6.2 自动类型转换
- 各基本数据类型的数据（除`boolean`类型）可以进行混合运算。
**运算中，不同类型的数据先转化为同一类型，然后进行运算**。
- **操作数类型的转换优先级为**
`byte`、`short`、`char` → `int` → `long` → `float` → `double`
   - 如`double`和`int`运算时，`int`会自动转换为`double`类型。
- **自动类型转换的内在规则**
   - 必须满足**转换前的数据类型的位数要低于转换后的数据类型**，例如: `short`数据类型的位数为16位，就可以自动转换位数为32的`int`类型，同样`float`数据类型的位数为32，可以自动转换为64位的`double`类型。
   - 这样可以**保证转换后不会丢失任何信息**
<a name="a1610b108d50f63fa66acc5a23836219"></a>
### 2.6.3 强制类型转换
- 我们在进行运算时，`int`类型的值有可能会自动地转换为`double`类型，这种自动转换并不会丢失信息。
但有时，我们也需要将`double`转换为`int`，这种转换有可能会丢失一些信息。<br />可能丢失信息的，显式地类型转换要通过**强制类型转换（cast）**来完成。
- **能够强制类型转换的条件**
转换前后的数据类型必须是兼容的
   - 不能把对象类型转换成不相关类的对象
- **语法格式**
**强制类型转换的语法格式是在圆括号中给出想要转换的目标类型**，后面紧跟待转换的变量名<br />如`int x = (int) 1.5;`
- 如果试图将一个数值的类型强制转换为另一种类型，同时又超出了目标类型的表示范围，结果就会被截断成一个完全不同的值。
```java
double x = 9.997;
int ax = (int) x;    //ax = 9

• 对于浮点型转整型的强制类型转换，浮点数的小数部分将被直接截断，仅保留整数部分。
• 如果想要得到浮点数最接近的整数，需要使用Math.round()方法对浮点数进行舍入计算

  double x = 9.997;
  //ax = 10，这里仍然使用了强制类型转换是因为Math.round()返回long类型数据
  int ax = (int) Math.round(x);

• 不能在**boolean**类型与任何数值类型之间进行强制类型转换，可能会出现错误

2.6.4 溢出与出错

• 表达式**n%m**

当变量n（整数或浮点数类型）为负数时，无论m是多少都不会出错，但会有以下两种情况

• m等于2

表达式的结果为-1

• m等于除2以外的任何数

表达式结果为0
当n为正数时，m不能为0，否则会报错
当n为0时，m不能为0，但无论m为除0外的任何数，**0%m**的结果都为0

• 对于计算出现溢出或出错，整型和浮点型产生的结果完全不同
  • 溢出
    • 整型

正溢出结果直接变为负数，负溢出结果直接变为正数

  - **浮点型**

正溢出和分溢出的结果分别是Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY，这两个常量的值是±Infinity

• 出错
  • 整型

整型数计算出错时，编译器直接报错并退出

  - **浮点型**

浮点型数计算出错时，返回结果Double.NaN，其值为NaN（表示结果是非数值）

• 实例

  public class MyClass {
  public static void main(String[] args) {
     double x = -1.7E308;
     double y = -1.7E308;
     System.out.println(x + y);    //out: -Infinity
     int z = 2147483647;
     int w = 1;
     System.out.println(z + w);    //out: -2147483648
     System.out.println(3.0 / 0);    //out: Infinity
     System.out.println(0.0 / 0);    //out: NaN
     System.out.println(Math.sqrt(-1));    //out: NaN
     System.out.println(0 / 0);    //编译器报错退出，无输出
  }
  }

• 不能直接使用==检测一个特定值是否等于Double.NaN，检测的结果将永远是false，如

0.0 / 0 == Double.NaN的结果永远是false，因为所有“非数值”的值都可以认为是不同的。

  - 可以使用`Double.isNaN()`方法来判断一个值是否是“非数值”

###Math类API（java.lang包）

• Math类包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
• Math类的方法都被定义为 static 形式，通过Math类可以直接调用。
• 添加**import static java.lang.Math.***，静态导入Math类，即可直接使用Math类的方法和常量而不用添加前缀“Math”。

静态方法

• **xxx Math.abs(xxx x)**

返回参数的绝对值，参数的类型xxx可以是6种基本数字类型

• 参数类型和返回值类型完全一致

  double d = Math.abs(-0.05)
  int i = Math.abs(-5)
  float f = Math.abs(0.3f);    //float f = Math.abs(0.3)无法通过编译，因为0.3是double类型

• **double Math.ceil(float/double x)**

对x向上取整，返回大于等于x的整数，类型为double

System.out.println(Math.ceil(3.3));    //输出4.0

• **double Math.floor(float/double x)**

对x向下取整，返回小于等于x的整数，类型为double

• **int Math.round(float x)**
• **long Math.round(double x)**

对浮点数进行四舍五入计算，得到最接近的整数

• 其内部算法相当于实现Math.floor(x + 0.5)

  Math.round(11.5);    //out: 12    因为11.5+0.5再向下取整为12
  Math.round(-11.5);    //out: -11    因为-11.5+0.5再向下取整为-11

• **xxx Math.max(xxx a, xxx b)**、**xxx Math.min(xxx a, xxx b)**

返回两个参数中的较大值、较小值

• **double Math.sqrt(double x)**

计算数值x的平方根。

• **double Math.pow(double x, double a)**

计算x的a次幂（x­a）

• **double Math.random()**

返回带有正号的double值，从[0.0, 1.0)范围均匀分布伪随机地选择返回值。

• 用n乘以这个浮点数，就可以得到[0.0, n)范围内的一个随机浮点数。

• **Math.PI**、**Math.E**

这两个常量是Math类提供的两个π和e的近似值。

2.7流程控制

2.7.1 循环结构

• Java中有三种主要的循环结构：

  • while循环
  • do…while循环
  • for循环

• for each循环

Java提供了一种增强型的for循环，称为for each循环，用于遍历实现了Iterable接口的类对象

• 语句格式：for(variable : collection) statement
• 在数组一节将更详细的介绍该循环

• 在循环中，检测两个浮点数是否相等时需要格外小心，如下面的例子

  for (double x = 0; x != 10; x += 0.1) 
    ...

  • 由于舍入的误差，浮点数可能永远达不到精确的最终值
  • 上例就永远不会结束，因为0.1无法精确地用二进制表示，所以x将从9.9999…跳到10.0999…

2.7.2 break和continue

• 带标签的**break**

带标签的break用于跳出多重嵌套的循环语句。

jump_flag:  //标签
while (true)
{
    for(int i = 0; i< 100; i++)
    {
        if(i == 10)
            break jump_flag;    //跳出标签jump_flag紧跟的循环
    }
}

• 标签必须放在希望跳出的最外层循环之前，并且必须紧跟着一个冒号**:**。
• 执行带标签的break后会跳转到带标签的语句块末尾。

• **continue**语句

continue将中断正常的循环流程，将控制转移到最内层循环的首部。

• while循环内使用跳至“判断”部分

for循环内使用则跳至“更新”部分，然后再进行“判断”。

• 带标签的continue将跳到与标签匹配的循环的首部。

• 事实上，可以将标签应用到任何语句，如下例子

  label:
  {
    ...
    if(condition)
        break label;    //跳出语句块
  }
  //当condition满足，跳至此处

2.7.3 条件语句

• Java使用if...else...语句实现条件判断，具体细节同C++

2.7.4 switch case语句

• switch case语句用于判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

• 语法格式

  switch(variable){
    case value1:
       ...
       break; //可选
    case value2:
       ...
       break; //可选
    ...    //可以有任意数量的case语句
    default : //可选
        ...
  }

• switch case语句有如下规则：

  • **switch**语句中的变量类型可以是

byte、short、int、char或String（不可以是浮点数！）

• case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量。
• case语句不必须要包含break语句。
• 当变量的值与某个case语句的值相等时，那么该case语句之后的语句开始执行，如果该case语句没有break语句，那么继续执行后续case语句以及default语句，并且跳过判断过程，直到break语句出现才跳出。
• switch语句可以包含一个default分支，该分支一般是switch语句的最后一个分支（可以在任何位置，但建议在最后一个）。default在没有case语句的值和变量值相等的时候执行。

3 Java常用内置类

3.1 字符串String

• 在Java中字符串属于对象，Java提供了String类来操作字符串。

• 创建字符串

创建字符串有两种方式

• 直接将字符串常量赋值给字符串变量

  String str = "Hello world!";

• 使用构造函数

  String str = new String("Hello world!");

• 通过赋值创建的字符串存储在公共池中，而构造函数创建的字符串对象在堆上：

  String s1 = "Runoob";              // String直接创建
  String s2 = "Runoob";              // String直接创建
  String s3 = s1;                    // 相同引用
  String s4 = new String("Runoob");   // 构造函数创建
  String s5 = new String("Runoob");   // 构造函数创建

  

• 每个用双引号**""**括起来的字符串，都是String类的一个实例。

  • 故在表示char类型数据时，必须使用单引号''

• 当将一个字符串与一个非字符串的值进行拼接时，后者会转换成字符串

  • 任何一个Java对象都可以转换成字符串

• String类没有提供修改字符串中某个字符的方法，即String类对象是不可变的。

• 检测字符串是否相等的方法（equals和==的区别）

  • 使用**string.equals(String s2)**检测s1和s2是否完全相等。
  • 使用**equalsIgnoreCase()**方法，检测两个字符串是否相等，但不区分大小写。
  • 不能使用**==**运算符检测，其只能确定两个字符串是否存放在同一个位置上。
  • 实际上所有引用类型都有这一特性，如数组等。

• 空串

  • 空串**“”**是一个String对象，有自己的串长度（0）和内容（空）。
  • String变量还可以存放一个特殊的值**null**，表示没有任何对象与该变量关联。
  • 空串**“”**不等于**null**

• 字符串与基本数据类型的互相转化

  • 基本数据类型转字符串

使用String类的静态方法valueOf()/使用基本类型包装类的toString()方法

• 字符串转基本数据类型

使用基本数据类型的包装类中的parseXxx()方法，常用函数如下

Byte.parseByte(String s);
//以radix为基底，将s转换为byte。比如说Byte.parseByte("11", 16)会得到17 
Byte.parseByte(String s, int radix);
Double.parseDouble(String s); 
Double.parseFloat(String s);
Integer.parseInt(String s); 
Long.parseLong(String s);

###String类API（java.lang包）

构造方法

• **String()**

构造一个空字符串对象

• **String(String original)**

构造一个值为original的字符串对象

• **String(byte[] bytes)**
• **String(char[] values)**

通过byte数组或char数组构造字符串对象

• byte数组的元素应该是哈希值，构造函数将把哈希值转换为对应的字符

• **String(StringBuffer buffer)**

通过StringBuffer对象构造字符串对象

静态方法

• **String String.valueOf(xxx x)**

该方法可以将8种基本数据类型转换为String类

• 也可以传入Object对象obj，效果几乎等同于obj.toString()，但是当obj是null时，采用该方法不会报错，但是直接使用obj.toString()会抛出NullPointerException异常。

可以参考String.valueOf(Object obj)的源码

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

动态方法

• **char str.charAt(int index)**

返回指定索引处的字符。索引范围为从0到length() - 1。

• 注意，返回的是char类型

• **int str.compare(String other)**

按照字典顺序，如果字符串位于other之前，则返回一个负数，相等返回0。

• **boolean str.blank()**、**boolean str.empty()**

判断字符串是否为空或者由空格组成，是返回true

• **int str.indexOf(String str2, int fromIndex)**

返回与字符串str2匹配的第一个子串的开始位置，从索引0或fromIndex开始匹配。

• 如果原始字符串**str**不存在**str2**，返回**-1**。
• 如果子串**str**是空串**""**，返回**0**

• **int str.length()**

返回str代码单元的个数。

• String类没有size()方法

• **String str.replace(String oldString, String newString)**

返回一个新字符串，这个字符串用newString代替原始字符串str中所有的oldString。

• **String str.substring(int beginIndex, int endIndex)**

返回一个新字符串，这个字符串包含原始字符串str中从beginIndex到endIndex-1的所有代码单元。

• **String str.toLowerCase()**、**String str.toUpperCase()**

返回一个新字符串，这个字符串将原始字符串中的所有大写字母改为小写字母，或将所有小写字母改为大写字母，原始字符串不变。

• **String str.strip()**

返回一个新字符串，这个字符串将原始字符串str头部和尾部的空格删除。

• **String str.join(String delimiter, String elements)**

返回一个新字符串，用给定的定界符连接所有元素

• **String str.repeat(int count)**

返回一个新字符串，其内容是重复count次的str。

• **char[] str.toCharArray()**

将字符串str转换为字符数组并返回

• **byte[] str.getBytes()**

  使用平台的默认字符集将str编码为byte序列，并将结果存储到一个新的byte数组中。

  • byte[]数组中存放的是字符串相应位置字母的哈希值，如字符串中的字母a对应byte[]数组中的97

3.2 StringBuilder和StringBuffer

• 当需要对字符串进行修改，或者需要用许多字符串来拼接成一个字符串时，需要使用StringBuilder类或StringBuffer类

  • **String**、**StringBuilder**和**StringBuffer**的异同
    • String长度、内容不可变；StringBuffer和StringBuilder长度、内容可变
    • **StringBuffer**线程安全；**StringBuilder**线程不安全
    • **StringBuffer**速度慢；**StringBuilder**速度快
    • StringBuilder和StringBuilder提供的方法相同，并且基本都实现了String的方法
  • 应该在几乎所有的情况下选择使用**StringBuilder**

• 字符串构建器**StringBuilder**

  • 如果需要用许多小段的字符串来构建一个字符串，那么需要用到字符串构建器。因为字符串多次使用+拼接效率低
  • String类是不可改变的，如果需要对字符串做很多修改，那么应该选择使用StringBuilder类，因为StringBuilder能够被多次原地修改，不产生新的未使用对象。
  • 实例 ```java //构建一个空的字符串构建器 StringBuilder builder = new StringBuilder();

//当每次需要添加一部分内容时，就调用append()方法 builder.append(‘a’); builder.append(‘b’); builder.append(‘c’);

//当字符串构建完成时，调用toString()方法即可得到一个String对象 System.out.println(builder.toString()); //out: abc builder.reverse(); System.out.println(builder.toString()); //out: cba

<a name="28844f93f688cf6e63bb820620697bbb"></a>
### ###StringBuffer类API###
**构造方法**
- `**StringBuilder(CharSequence seq)**`
返回一个StringBuilder对象，其值为seq
   - **实现了CharSequence接口的类都可以传入，即**`**String**`**、**`**StringBuilder**`**或**`**StringBuffer**`
**动态方法**
- 在使用`StringBuilder`类时，**每次都会对**`**StringBuilder**`**实例本身进行原地操作**
- `StringBuilder sb.append(String s)`
- `**StringBuilder sb.append(char[] s)**`
- `StringBuilder sb.append(char c)`
- `StringBuilder sb.append(int s)`
...<br />将指定的参数原地追加到此字符序列。
- `StringBuilder sb.reverse()`
原地反转字符序列
- `**StringBuilder sb.delete(int start, int end)**`
原地移除字符序列位置在[start, end)的字符。
- `StringBuilder sb.insert(int pos, XXX x)`
将参数`x`（可以是`String`、`char`、`int`等多种类型）插入此序列的`pos`位置。
- `StringBuilder sb.replace(int start, int end, XXX x)`
使用给定参数替换此序列位置在[start, end)的字符。
<a name="8f21d30658d54f8dbde668f44c3e1a4b"></a>
## 3.3 控制台输入与输出
<a name="a2ccf987be2b9106ca0d1e138f9839f0"></a>
### 3.3.1 控制台输入
- **读取“标准输入流”**`**System.in**`
```java
//创建与System.in关联的Scanner对象。
Scanner in = new Scanner(System.in);

• 构造完成后就可以使用**Scanner**类的各种方法读取输入了。

• **next()**

下面的实例是一个最简单的数据输入，并通过Scanner类的next()方法获取输入的字符串，在读取前我们一般需要使用hasNext()判断是否还有输入的数据

public class MyClass {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //从键盘接收数据
        //next方式接收字符串
        System.out.println("next方式接收：");
        //判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}

• 上述代码的输出为(next()方法以空格作为结束符)

  next方式接收：
  cui yi chen
  输入的数据为：cui

• **nextDouble()**、**nextInt()**…

除了使用next()接收字符串，还可以使用nextXxx()接收数字，如nextDouble()、nextInt()等。
以下实例我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：

public class MyClass {
    public static void main(String[] args) {
        System.out.println("请输入数字：");
        Scanner scan = new Scanner(System.in);
        double sum = 0;
        int m = 0;
        while (scan.hasNextDouble()) {
            double x = scan.nextDouble();
            m = m + 1;
            sum = sum + x;
        }
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));
        scan.close();
    }
}

• 上述实例的输出为

  请输入数字：
  1 2 3
  #
  3个数的和为6.0
  3个数的平均值是2.0

• **nextLine()**

上面的方法都是以空格为结束输入的标志，那么如果想要获得一整行可以带有空格的输入，则需要使用nextLine()方法，该方法以换行符为结束标志

public class MyClass {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("nextLine方式接收：");
        if (scan.hasNextLine()) {
            String str1 = scan.nextLine();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}

• 上述代码输出为

  nextLine方式接收：
  cui yi chen
  输入的数据为：cui yi chen

nextLine()与其他方法的区别

• **nextLine()**与其他方法的区别

其他方法（如**next()**、**nextInt()**等）：

• 一定要读取到有效字符后才可以结束输入（只输入空白符无法结束）。
• 对输入有效字符之前遇到的空白，会自动将其去掉。
• 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next()不能得到带有空格的字符串。

**nextLine()**：

• 以换行符为结束符,也就是说**nextLine()**方法返回的是输入回车之前的所有字符。
• 在读取到有效字符前可以结束输入，即如果直接输入换行符，将会直接结束。
• 可以获得空白，即空白也作为有效字符。

• 所有方法都不接收其本次输入对应的结束符，即nextLine()不接收换行符，其他方法不接收空白符。

需要注意的是，**nextLine()**会把其结束符从输入缓存中剔除，而其他方法并不会把其结束符从输入缓存中剔除

Scanner scan = new Scanner(System.in);
System.out.print("输入：");
System.out.println("next()接收到的：" + scan.next());
System.out.println("nextLine()接收到的：" + scan.nextLine());
System.out.print("输入：");
System.out.println("nextLine()接收到的：" + scan.nextLine());
scan.close();

• 上述代码的输出为

  输入：cui yi chen
  next()接收到的：cui
  nextLine()接收到的： yi chen
  输入：yi chen
  nextLine()接收到的：yi chen

• **nextLine()**与**next()**、**nextInt()**等混合使用时需要特别注意

由于除了nextLine()外，其他方法不会把其结束符从输入缓存中剔除，因此**nextLine()**可能会接收到**next()**等方法的结束符，如空格，换行符等，如果是换行符，那么**nextLine()**将直接结束接收，如下例子

public class MyClass {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int i = scan.nextInt();
        String line = scan.nextLine();
        System.out.println("nextInt()接收到的：" + i);
        System.out.println("nextLine()接收到的：" + line);
        scan.close();
    }
}

• 上述代码输出（在输入5后直接回车）

  输入：
  5
  nextInt()接收到的：5
  nextLine()接收到的：

###Scanner类API（java.util包）

• 当使用的类不是定义在基本java.lang包中时，一定要使用import指令导入相应的包。
• Scanner类定义在java.util包中，故程序的最前面应添加**import java.util.***

构造函数

• **Scanner(InputStream source)**

构造一个从输入流中读取数据的Scanner对象

• 我们常需要从键盘读取数据，那么就可以将标准输入流System.in作为参数传入

• **Scanner(Path p, String encoding)**

构造一个使用给定字符编码从给定路径的文件中读取数据的Scanner对象。

• 第一个参数常使用静态方法**Path.of(String filePath)** (java.nio.file.*)，将String转换为Path

动态方法

• **String scnr.nextLine()**

读取输入的下一行内容（读取的内容包括一行内的空格，以换行符作为结束符）

• **String scnr.next()**

读取输入的下一个字符串（以空白符作为结束符）

• **int scnr.nextInt()、**``**double scnr.nextDouble()**

读取并转换下一个表示整数或浮点数的内容（以空白符作为结束符）

• **boolean scnr.hasNext() / scnr.hasNextInt() / scnr.hasNextDouble()**

检测是否还有下一个字符串/整数/浮点数。

3.3.2 控制台输出

• 打印“标准输出流”**System.out** ```java //可以使用以下语句将内容x打印到“标准输出流（即控制台窗口）” System.out.print(x); System.out.println(x); System.out.printf(x);

//Java沿用了C语言函数库中的printf方法，可以进行格式化的输出 //%s转换符可以将任意对象格式化为字符串。 System.out.printf(“name: %s score: %8.2f”, name, score);

   - **对于日期与时间的格式化选项**，应使用java.time包中的方法。
- **创建指定格式的字符串**
可以使用`**String.format()**`方法创建一个指定格式的字符串，而不打印输出
```java
String message = String.format(“name: %s score:%8.2f”, name, score);

3.5 大数

• java.math包中的两个类**BigInteger**（大整数）和**BigDecimal**（大实数）可以处理包含任意长度数字序列的数值。

• 创建大数实例

A. 使用上述两个类的静态方法valueOf(num)可以将普通的数值转换为大数。如：

BigInteger a = BigInteger.valueOf(1000);

B. 对于过大/精密而无法使用基本类型表示的数，可以使用带字符串参数的构造器。如：

BigInteger b = new BigInteger("12345678910111213141516");

• 大数的计算

不能使用人们熟悉的算术运算符计算大数或是比较大数，而应该使用大数类提供的计算方法。如big1.add(big2)

###BigInteger类API（java.math包）

构造函数

• BigInteger BigInteger(String num)

构造一个值为num的大整数

静态方法

• BigInteger BigInteger.valueOf(int num)

返回一个值为num的大整数

动态方法

• BigInteger bi.add(BigInteger bi2)
• BigInteger bi.subtract(BigInteger bi2)
• BigInteger bi.multiply(BigInteger bi2)
• BigInteger bi.divide(BigInteger bi2)
• BigInteger bi.mod(BigInteger bi2)

返回大整数bi和另一个大整数bi2的和、差、积、商以及余数

• BigInteger bi.sqrt()

得到大整数bi的平方根

• int bi.compareTo(BigInteger bi2)

如果大整数bi与另一个大整数bi2相等，返回0；如果bi小于bi2，返回负数；否则，返回正数。

###BigDecimal类API（java.math包）

构造函数

• BigDecimal(String num)

构造一个值为num的大实数

静态方法

• BigDecimal.valueOf(int/float/double num)

返回一个值为num的大实数

动态方法

• BigDecimal bd.add(BigDecimal bd2)
• BigDecimal bd.subtract(BigDecimal bd2)
• BigDecimal bd.multiply(BigDecimal bd2)

返回大实数bd与bd2的和、差、积。

• BigDecimal bd.divide(BigDecimal bd2)
• BigDecimal bd.divide(BigDecimal bd2, RoundingMode mode)

返回大实数bd与bd2的商。

• 如果商是个无限循环的小数，第一个divide方法会抛出一个异常。
• 要得到一个舍入的结果，就要使用第二个方法，即向函数传入指定的舍入方法。（RoundingMode.HALF_UP是四舍五入的方式）

• int bd.compareTo(BigDecimal bd2)

如果大实数bd与另一个大实数bd2相等，返回0；如果bd小于bd2，返回负数；否则，返回正数。

3.6 数组

• 什么是数组？

  • 数组是存储相同类型值的序列
  • 数据类型后紧跟[]表示数组类型（如int[]、String[]等）
  • 数组类型不属于基本类型，和其他类一样，继承自Object类

• 数组声明

  int[] a;

  • 这条语句只声明了变量a，并没有将a初始化为一个真正的数组。
  • C语言风格的声明也是可行的，即int a[]，但不常用。

• 数组初始化 ```java //方法一 int[] a = new int[100]; //声明并初始化了一个可以存储100个整数的数组

//方法二 int[] b = {1,2,3,4,5}; //这种方式不需要使用new，也不用指定长度

   - **数组长度不要求是常量**，new int[n]会根据变量n的大小创建数组。
   - 一旦初始化了数组，就**不能再改变它的长度**。
   - 程序运行中**如果需要扩展数组的大小**，则**应使用数组列表（ArrayList）**这一数据结构。
   - **方法二仅适用于变量声明时初始化**，声明变量后将无法使用方法二初始化，但是可以使用匿名数组的方式
```java
int[] i = new int[3];
int[] j;
int[] k = {1, 2, 3};    //编译通过
i = {1, 2, 3};  //编译不通过
j = {1, 2, 3};  //编译不通过
i = new int[]{1, 2, 3};    //编译通过

• 数组默认值

初始化数组但没有为其赋初始值时，数组将被赋予默认值，不同的数组类型默认值不同

• 数组变量无论是局部变量、类变量还是实例变量，如果没有被初始化，都会被赋予默认值

这里与普通的变量不同（普通变量是局部变量时不会被赋予默认值）

• 数字数组：默认值为0
• boolean数组：默认值为false
• 对象数组：默认值为一个特殊值null，表示这些元素还未存放任何对象

• 数组长度

数组长度使用数组的属性**length**来获取

int[] a = new int[10];
System.out.println(a.length);    //out: 10

• String的长度使用**str.length()**获取

• 匿名数组

匿名数组是一个没有名字的数组，不需要为其指定变量名（也可以指定），一般适用于仅使用一次的情况

System.out.println(Arrays.toString(new String[]{"abc", "de"}))

• for each循环

  • for each循环可以依次处理数组（或其他的元素集合）中的每个元素，而不必考虑指定下标值。

  • for each循环的语句格式：for(variable : collection) statement

    • 该语句定义一个变量**_variable_**用于暂存集合中的每一个元素，并且必须指定其元素类型。
    • **_collection_**这一集合表达式必须是一个数组或者是实现了Iterable接口的类对象
    • eg：

      int[] ar = {1, 2, 3, 4};
      //打印数组的每个元素
      for (int element : ar)
      System.out.print(element);

  • 如果不希望遍历整个集合，或者在循环内部需要使用下标值时，传统的for循环更为适用

• 数组的拷贝

  • 使用**=**将一个数组变量直接拷贝到另一个数组变量时，两个变量将引用同一个数组
  • 如果希望将一个数组的所有值拷贝到一个新的数组中去，则要使用Arrays类的**copyOf()**方法。

• 多维数组/不规则数组

  • 多维数组初始化时必须给出第一维的长度，如int[][][] ar = new int[3][][];
  • Java支持不规则数组，即数组除了第一维外，其他维的长度可以不统一，如下例子

    int[][] odds = new int[max + 1][];
    //分别为每一维分配空间
    for (int n = 0; n <= max; n++)
    odds[n] = new int[n + 1];

• 输出数组内容/将数组转为字符串

A. 循环数组，逐元素输出
最简单、常用的方式，可以使用for循环或for each循环遍历数组

int[] a = {1, 2, 3};
for (int i = 0; i < a.length; i++)
    System.out.print(a[i]);
//输出123

B. 将数组转为字符串，作为整体输出
数组不能直接输出，也不能直接使用.toString()方法将其转换为字符串

• Java里，所有的类，不管是java库里面的类，或者是你自己创建的类，全部是从Object这个类继承的。

Object类一个方法就是toString()，那么所有的类创建的时候，都有一个toString()的方法。

• Java输出用的函数print()/println()，是不接受对象直接输出的，只接受字符、字符串或者数字之类的输出。

当**print()**检测到输出的是一个非String对象而不是字符串、字符或数字时，那么它会去调用这个对象类里面的toString()方法，输出结果为“类型@哈希值”，如[I@7c30a502。

将数组转换为字符串，转换结果有两种形式

• 形式1：“[1, 2, 3]”

使用Arrays.toString()方法，转换的结果是带格式的

• 形式2：“123”

有两类方法进行转换
a) 将数组作为构造String的数据或调用String类的**valueOf()**方法
只适用于数组类型为char[]或byte[]的数组

char[] data = {'a', 'b', 'c'};
//将数组作为构造String的数据
String str = new String(data);
调用String.valueOf()方法
String str2 = String.valueOf(data)

b) 循环遍历数组配合字符串构造器**StringBuilder**
适用于所有基本数组类型

int[] a = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0; i < a.length; i++)
    builder.append(String.valueOf(a[i]));
String str = builder.toString();

• 杂项
  • 长度为0的数组与null并不相同，即new int[0]≠null
  • 数组.length将返回数组的长度。

###Arrays类API（java.util包）

• **Arrays**类能方便地操作数组，它提供的所有方法都是静态的。

静态方法

• T[]可以指代基本数据类型和引用数据类型的数组

• String Arrays.toString(T[] a)

返回包含a中元素的一个字符串，这些元素用中括号包围，并用逗号分隔。

• 将a转换为字符串时，不能直接使用Object类的toString()方法

• **void Arrays.sort(T[] a)**

使用优化的快速排序算法对数组进行原地排序。

• **int Arrays.binarySearch(T[] a, T v)**
• **int Arrays.binarySearch(T[] a, int start, int end, T v)**

使用二分查找算法在有序数组a中查找指定值v。

• 如果找到v，返回相应的下标，否则返回一个负数值r（r = -(应插入位置) - 1）。

• **void Arrays.fill(T[] a, T v)**

将数组的所有元素原地设置为v

• **boolean Arrays.equals(T[] a, T[] b)**

如果两个数组大小相同，并且下标相同的元素都对应相等，返回true。

• 和String的比较一样，数组类型变量直接使用==进行比较，实际上是判断两个变量是否引用同一地址。

• **List<T> Arrays.asList(T[] a)**

将数组a转为List

• **T[] Arrays.copyOf(T[] original, int newLength)**

返回一个新的数组，其内的值复制original数组中的值，如果新数组的长度超过原数组的长度，则超出部分的值为默认值

4 类与对象

1 类概述

• 类（class）

类是构造对象的模板。

• 类构造（construct）对象的过程称为创建类的实例（instance）。
• 对象中的数据称为实例字段（instance field），操作数据的过程称为方法（method）。
• 在Java中，所有的方法都必须在类的内部定义。（与C++不同）
• 作为一个类的实例，特定对象都有一组特定的实例字段值，这些值的集合就是这个对象的当前状态，只要在对象上调用一个方法，它的状态就有可能发生改变。

• 封装（encapsulation）

封装就是将数据和行为组合在一个包中，并对对象的使用者隐藏具体的实现方式。

• 实现封装的关键在于，绝对不能让类中的方法直接访问其他类的实例字段。程序只能通过对象的方法与对象数据进行交互。
• 封装是提高重用性和可靠性的关键，即其他对象不会知道也不用关心这个类的变化。

• 继承（inheritance）

通过扩展一个类来建立另一个类的过程称为继承。这个扩展的新类具有被扩展的类的全部属性和方法

• 所有类，不管是Java库里面的类，或者是你自己创建的类，都继承自Object类。

• 识别类

面向对象程序设计时没有所谓的“顶部”（过程式程序中的main函数），而是从“识别类”开始，然后再为各个类添加方法。

• 识别类的一个简单经验是在分析问题的过程中寻找名词，类对应着名词，而类的方法对应着动词。

• 并不是所有类都表现出面向对象的所有典型特征

比如预定义类Math，我们可以直接使用Math类的方法。

• Math类只封装了功能，它不需要也不必隐藏数据。
• 由于没有数据，因此也不必考虑创建对象和初始化它们的实例字段，因为根本没有实例字段。这也是Math类只包含静态方法的原因。

• 类与类之间有三大关系

1. 依赖（uses-a）
   • 如果一个类的方法使用或操纵另一个类的对象，我们就说一个类依赖于另一个类。
   • 应该尽可能地将相互依赖的类减至最少，也就是减少类之间的耦合。
2. 聚合（has-a）
   • 包容关系意味着类A的对象包含类B的对象。
3. 继承（is-a）
   • 如果类A扩展类B，类A不但包含从类B继承的方法，还会有一些额外的功能。

可以采用UML（Unified Modeling Language，统一建模语言）绘制类图，用来描述类之间的关系。

1 Object类

• Object类是Java所有类的祖先，每个类都直接或间接继承自Object，包括数组和自定义类。
  • 所有类都继承自Object类的目的主要是使用Object类的方法，这些方法对所有类具有普适性。

当然，很多类需要根据实际情况重写继承自Object类的方法。

• Java只支持单继承，如果类未声明指定的父类，默认为Object。

• Object的变量可以保存任何类的对象的引用

但是其运行期类型仍是其保存的对象引用的真实类型

Object str = "Good";
Object nowDate = LocalDate.now();
//输出java.time.LocalDate
System.out.println(nowDate.getClass().getName());

• 当**return**类型声明为Object时，可以返回任意类型的对象

  • 但是接收返回的变量必须是Object类型，除非对返回值进行强制类型转换

    public class MyClass {
    public static void main(String[] args) throws IOException {
       String str = (String) returnObject();    //str = "Good"
       String astr = returnObject();    //编译错误
    }
    public static Object returnObject() {
       return "Good";
    }
    }

2 （待）###Object类API（java.lang包）

动态方法

• **final Class obj.getClass()**

返回一个对象的运行期类型。
常使用**String class.getName()**方法获取类型名

Object str = "sdasds";
//输出运行期类型class java.lang.String而不是class java.lang.Object
System.out.println(str.getClass());    
//输出java.lang.String
System.out.println(str.getClass().getName());

• **（待）boolean obj.equals(Object obj1)**

判断两个obj的地址是否相同，或者说是否引用了同一个对象

• 这里Object类原始的equals()方法并不是从逻辑上判断对象是否相等的，而是通过地址。

equals()源码：

public boolean equals（Object obj）{
    return（this==obj）
}

从源码可以看到，原始的**equals()**方法效果等同于**==**

• 重写**equals()**

由于obj.equals()等价于==，因此，几乎所有类都需要重写**equals()**方法，实现判断两个对象是否逻辑相等（内容相等）的功能
如果要重写**equals()**方法，就必须重写**hashCode()**方法，具体见https://blog.csdn.net/We_chuan/article/details/96426273

  - 如String类的`equals()`方法源码

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String aString = (String)anObject;
            if (coder() == aString.coder()) {
                return isLatin1() ? StringLatin1.equals(value, aString.value)
                                  : StringUTF16.equals(value, aString.value);
            }
        }
        return false;
    }

• **（待）int obj.hashCode()**

返回对象的hash码

• hash码表示对象在hash表上位置（注意：该位置可以挂载多个不同的对象），不是内存地址

因此，hash码不能够代表内存地址，如下例，两个对象hash码相等，但引用的不是一个对象

LocalDate ld = LocalDate.of(1900, 1, 1);
LocalDate ld2 = LocalDate.of(1900, 1, 1);
System.out.println(ld.hashCode() == ld2.hashCode());    //输出true
System.out.println(ld == ld2);    //输出false

• 同一个对象与hashCode

• 内容相等的对象与hashCode

对于各种预定义类重写过的equals()方法来说
两个内容相同的对象（两个相等的对象）equals()方法一定为true（但hashCode不一定相等）
结论：
对象相等 ⇏ hashCode相等
hashCode相等⇏ 对象相等

• 关于hashCode更详细的内容，见https://www.cnblogs.com/zhchoutai/p/8676351.html

• **String obj.toString()**

返回对象信息

• 源码

  public String toString() {
  return getClass().getName() + "@" + Integer.toHexString(hashCode());
  }

• Object类中的toString()方法只是返回类的类名和hashCode

如数组的toString()方法是继承自Object类的

int a = {1, 2, 3};
System.out.println(a.hashCode());    //输出[I@7f63425a

• 可以重写toString()方法（部分需要打印的类重写了**toString()**方法），来实现自己所需要的打印信息功能。
• 如LocalDate类重写了toString()方法，方便打印该类所存时间

  public final class LocalDate
  implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {
  ...
  @Override
  public String toString() {
     int yearValue = year;
     int monthValue = month;
     int dayValue = day;
     int absYear = Math.abs(yearValue);
     StringBuilder buf = new StringBuilder(10);
     if (absYear < 1000) {
         if (yearValue < 0) {
             buf.append(yearValue - 10000).deleteCharAt(1);
         } else {
             buf.append(yearValue + 10000).deleteCharAt(0);
         }
     } else {
         if (yearValue > 9999) {
             buf.append('+');
         }
         buf.append(yearValue);
     }
     return buf.append(monthValue < 10 ? "-0" : "-")
         .append(monthValue)
         .append(dayValue < 10 ? "-0" : "-")
         .append(dayValue)
         .toString();
  }
  ...
  }

• **protected Object obj.clone()**
  • 创建一个新对象，然后将当前对象的非静态字段复制到该对象
  • 如果字段类型是值类型（基本类型）的，那么对该字段进行复制；
  • 如果字段是引用类型的，则只复制该字段的引用而不复制引用指向的对象。

此时新对象里面的引用类型字段相当于是原始对象里面引用类型字段的一个副本，原始对象与新对象里面的引用字段指向的是同一个对象
上述描述属于浅克隆方式

• 源码

  protected native Object clone() throws CloneNotSupportedException;

• 使用**clone()**

如果想要在自己的类外调用自己类实例的**clone()**方法，需要实现**Cloneable**接口，同时需要重写**clone()**方法（需要抛出**CloneNotSupportedException**异常）。

  - **派生类必须实现**`**Cloneable**`**接口的原因：**

Cloneable接口是空的，它仅仅是一个标志，派生类实现了这个接口后，在类外使用clone方法就不会抛出**CloneNotSupportedException**异常了。

  - **必须要重写**`**clone()**`**方法的原因：**

Object类中的**clone(**)方法是**protected**权限，只能在本包的子类外部或者在其它包的子类内部访问，这里重写一下，虽然还是**protected**的，但是可以在本包的子类外部访问了（当然也可以重写为**public**）

• 根据实际情况的不同，重写**clone()**方法有两种思路

**
实现Cloneable()接口，然后在重写的clone()方法内直接调用obj.clone()方法

//此处实现Cloneable接口
class MyClass implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();    //调用obj.clone()
    }
}

B. 深克隆——clone()方式
如果对象中有引用数据类型，就必须使用深度克隆（防止类的封装性被破坏）。
具体来说，就是在**clone()**方法内部把该对象实例变量中引用的其他对象也要clone一份，这就要求被实例变量引用的对象也必须要实现**Cloneable**接口并且重写**clone**方法。

public class MyClass implements Cloneable {
    private B b;
    private C c;
    //深克隆
    protected Object clone() throws CloneNotSupportedException {
        MyClass myclass = null;
        try {
            myclass = (MyClass) super.clone();    //浅克隆，clone对象本身是基础
            myclass.b = (B) this.b.clone();    //手动clone成员对象引用b，并赋值给新MyClass对象
            myclass.c = (C) this.c.clone();    //手动clone成员对象引用c，并赋值给新MyClass对象
        } catch (CloneNotSupportedException e) {
        }
        return myclass;
    }
}
class B {
    //浅克隆
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class C {
    //浅克隆
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

  - 这种方法的缺点就是当一个类里面有很多引用类型时，需要手动调用很多`clone()`，而且如果引用类型内部还有引用类型时，那么代码将会很恶心，量也很大。。。
  - 所以**这种方式一般用于引用类型变量较少的时候**。

对于很多引用类型，可以使用序列化对象的方式进行深拷贝。

C. 深克隆——序列化方式
这种方式其实就是将对象转成二进制流，然后再把二进制流反序列成一个Java对象，这时候反序列化生成的对象是一个全新的对象，里面的信息与原对象一样，但是所有内容都是一份全新的。
这种方式需要注意的地方主要是除了实现都需要实现Cloneable接口外还需要实现Serializable接口，以便进行序列化操作。

2 对象与对象变量

• 对象的定义
  • 对象是类的一个实例。
  • 所有的Java对象都存储在堆中。
  • 对象的三个特征
    • 对象的行为（behaivor）

用可调用的行为来定义。

  - 对象的**_状态（__state__）_**

状态就是对象描述当前状况的信息

  - 对象的**_标识（__identity__）_**

对象的状态并不能完全描述一个对象，每个对象都有一个唯一的标识。

• 构造对象

要想使用对象，首先必须构造对象，然后对对象应用方法。
要使用构造器（或称构造函数）构造新实例。

• 构造器的名字应该与类名相同
• 要想构造一个对象，需要在构造器前面加上new操作符，如new Date()。

• 对象变量

通常需要多次使用我们构造的对象，因此需要将对象存放在一个变量中

//构造了一个Date对象，并存入today变量，其被初始化为当前日期和时间
Date today = new Date();

• 对象变量today引用了新构造的Date对象。
• 在对象与对象变量之间存在着一个重要的区别：

变量在引用对象前（被初始化前）不是一个对象，其值为null，表示没有引用任何对象，此时还不能在这个变量上使用任何对象的方法

• 对象变量被初始化后，并没有实际包含一个对象，它只是引用一个对象。

表达式new Date()构造了一个Date类型的对象，它的值是对新创建对象的一个引用，这个引用存储在变量today中。

可以把Java中的对象变量看作类似于C++的对象指针。 Date* birthday = new** **Date(); _//C++_

• 对象的复制 ```java Date date = new Date(); Date copy1 = date; Date copy2 = (Date) date.clone();

System.out.println(date == copy1); //输出true System.out.println(date == copy2); //输出false

   - 上述语句中，`date`和`copy1`引用的是**同一个对象**。
因此，如果通过某个变量修改对象的实例字段，另一个变量所引用对象的实例字段将有完全相同的改变。
   - 因此，在Java中，必须使用Object类的`**clone()**`**方法**获得**对象的完整副本**
      - 注意`clone()`返回Object类型，需要强制转换类型。
   - 可以使用双等号`==`来比较两个对象变量所引用的地址是否相同，进而判断是否引用了同一个对象。
<a name="t0qg3"></a>
### 1 关于null引用
- 我们已经知道，一个对象变量**包含一个对象的引用**，或者**包含一个特殊值**`**null**`
   - `**null**`**表示对象变量没有引用任何对象**
   - 基本数据类型不可能是`null`
   - `null`可以被强制转换为任何Java类型
- `null`引用是一种处理特殊情况的便捷机制，然而使用`null`值必须非常小心
**如果对值是**`**null**`**的对象变量应用一个方法，会产生一个**`**NullPointerException**`**异常**。正常情况下，程序并不捕获这些异常，出现此异常程序就会终止。
- 定义一个类时，**需要清楚地知道哪些字段可能为**`**null**`
```java
public class Employee {
    private String name;
    private LocalDate hireDay;
    private double salary;
    public Employee(String n, double s, intyear, int month, int day) {
        name= n;
        salary= s;
        hireDay= LocalDate.of(year, month, day);
    }
}

• 在上述代码中，我们不希望name和hireDay字段为null。
• hireDay字段肯定是非null的，因为它初始化为一个新的LocalDate对象，salary字段也不用担心，因为它是基本类型。
• name可能是null类型

• 当类中某些字段可能是**null**，有两种方案可以应对

  • “宽容型”方案：把null参数转换为一个适当地非null值

    public class Employee {
    private String name;
     public Employee(String n) {
       if (n == null)
           name ="unknow";
       else
           name= n;
    }
    }

    **Objects**类提供了一个替代上述代码的便利方法：

    name = Objects.requireNonNullElse(n,"unknown");

  • “严格型”方案：拒绝null参数 ```java

public class Employee { private String name; public Employee(String n) { Objects.requireNonNull(n, “The name cannot be null!”); //当n是null时报错 name = n; } }

      - 当参数`n`的值是`null`时，就会产生`NullPointerException`异常**，**且异常报告会提供这个问题的描述和指出问题发生的位置**。**
      - 否则，`NullPointerException`异常可能会在其他地方出现，而很难追踪到真正导致问题的这个构造器参数。
<a name="kxbkX"></a>
### 2 ###Objects类API（java.util包）###
- **Objects类用于“优雅地”处理**`**null**`
**静态方法**
- `static <T> void **requireNonNull**(T obj)`
- `static <T> void **requireNonNull**(T obj, String message)`
如果obj为`null`，这些方法会抛出一个`NullPointerException`异常，同时不提供或提供一则给定的message。
- `static <T> T **requireNonNullElse**(T obj, T defaultObj)`
如果obj不为`null`则返回obj，否则返回默认的obj。
<a name="DctBC"></a>
## 3 类详解
- **最简单的类定义形式：**
```java
class ClassName
{
    //实例字段和类字段
    field1
    field2
    ……
    //构造器
    constructor1
    constructor2
    ……
    //方法
    method1
    method2
    ……
}

• 要想构建一个完整的程序，一般会结合使用多个类。

1 public class和class

• 如果一个源文件包含多个类，且其中某个类带有public修饰符，则源文件名必须与public类的名字相匹配。
  • 在一个源文件中，只能有一个public class，但可以有任意数目的class（非公共类）。
  • 当编译代码时，编译器会为每个类创建类文件，如a.class和b.class。
  • 许多程序员习惯将每一个类存放在一个单独的源文件中，如将a类存放在文件a.java中，将b类存放在b.java中。

2 类名的命名规范

• Java类名标准的命名规范是驼峰命名法

类名是以大写字母开头的名词，如果名字由多个单词组成，每个单词的第一个字母都应该大写