【后端开发】02-Java面向对象

Java面向对象

1. 概述

1.1. 程序设计思想

1.1.1. 面向过程编程

• 关注过程，即数据的操作步骤
• 以函数为单位组织代码
• 适用于简单程序设计

1.1.2. 面向对象编程

• 关注类，即事物的属性特征和行为特征
• 以类为单位组织代码
• 适用于复杂程序设计

1.2. 面向对象的基本元素

• 类：具有相同特征的事物的抽象描述，是抽象的
• 对象：也称实例，是实际存在的某类事物的个体，是具体的

2. 类和对象

2.1. 类的引入

类是一组相关属性和行为的集合，其中

• 属性：描述该类事物的状态信息
• 行为：定义该类事物能执行的操作

2.1.1. 类的定义

[modifier] class ClassName {
    ...
}

• modifier：修饰符，可以为public、default(缺省)等，内部类还可以用protected和private修饰
• ClassName：类名，遵循大驼峰命名法则

2.1.2. 类的实例化

ClassName objName = new ClassName();

• objName：对象名，遵守小驼峰命名法则

匿名对象

创建对象时，不定义对象的句柄（赋值给变量），这样的对象叫做匿名对象

• 使用场景：只进行一次方法调用的对象、作为实际参数的对象

2.2. 类的成员之属性

2.2.1. 属性定义

[modifier] type attrName [= value];

• modifier：修饰符，可以为public、protected、default(缺省)、private、static、finale等
• attrName：属性名，遵循小驼峰命名法则

说明

• 属性必须定义在类的内部、方法的外部
• 属性存储在堆中，会执行默认初始化
• 属性的作用域为所属的类，生命周期与类的对象相同

2.2.2. 属性访问

objName.attrName

2.2.3. 属性赋值顺序

默认初始化 >> 显示初始化 >> 构造器中初始化 >> objName.attrName或setter方法赋值

2.3. 类的成员之方法

2.3.1. 方法定义

[modifier] type methodName([params]) [throws exceptions] {
    ...
}

• modifier：修饰符，可以为public、protected、default(缺省)、private、static、abstract等
• type：方法的返回值类型，即return返回结果的类型，没有返回值则为void
• methodName：方法名，遵循小驼峰命名法则
• params：零个及以上参数type param构成的形参列表，中间用,隔开

说明

• 方法必须定义在类的内部、方法的外部，且不允许在方法内定义方法
• {}之前的部分称为方法签名，{}括起来的部分称为方法体，两者共同构成方法的定义
• 方法体中的返回值必须与返回类型相同（兼容），没有返回值时返回类型为void

扩展

• 方法存储在JVM的方法区，供所有对象共同使用

2.3.2. 方法调用

objName.methodName([params])

说明

• 方法调用时必须根据形参列表传入对应的参数

2.3.3. 方法重载（overload）

方法重载是指同一个类中，方法名相同而参数列表不同的现象

两个要素

1. 同一个类中的同名方法
2. 方法的参数列表不同，即形参的个数、类型、顺序不同

注意

• 方法重载与修饰符、返回值类型、形参的参数名无关

2.3.4. 可变形参（JDK 5.0新增）

methodName(type ... paramName)

说明

• 可变形参可接收零个及以上个数的参数
• 含有可变形参的方法中仍可以定义多个形参，但只能有一个可变形参且必须在最后
• JDK将可变形参转化为一维数组的引用，方法重载时该参数视为同类型的一维数组

2.3.5. 参数传递

形式参数：简称形参，是指在定义方法时，参数列表中定义的变量

实际参数：简称实参，是指在调用方法时，参数列表中传入的值、变量或表达式

Java中的参数传递机制为值传递，即将实际参数复制为形式参数并传入方法内，具体地

• 若形参是基本数据类型，则将实参中存放的“数据值”传递给形参
• 若形参是引用数据类型，则将实参中存放的“地址值”传递给形参

2.3.6. 递归方法

直接或间接调用自身的方法称为递归方法

• 直接递归：方法直接调用自身
• 间接递归：方法调用的其他方法中调用了自身

说明

• 递归通常包括递归体和递归出口，前者通过调用自身来解决问题，后者提供了停止调用的条件
• 递归调用会反复调用自身，消耗较多时间和内存

2.4. 类的成员之构造器

构造器的作用是在实例化时为实例变量赋值

2.4.1. 语法格式

[modifier] ClassName([params]) {
    ...
}

• modifier：权限修饰符public、protected、default(缺省)、private

说明

• 构造器名必须与其类名相同，且可以重载
• 构造器没有返回值，即不包含return语句且不指定返回类型

2.4.2. 特殊说明

• 若未显式定义构造器，则使用默认的无参构造器，且该构造器的修饰符与类修饰符相同
• 如果显式定义构造器，则默认的无参构造器失效，若要使用则需显示定义

2.5. this关键字

this关键字指代当前对象，仅在类的内部使用

2.5.1. 访问属性

this.attrName

说明

• 使用this指代当前对象的属性，常用于区分对象的属性和方法（构造器）的局部变量
• 在不混淆的形况下，this关键字可以省略

2.5.2. 调用方法

this.methodName(params)

说明

• 在不混淆的形况下，this关键字可以省略

2.5.3. 调用构造器

this(params)

说明

• 必须是构造器的第一条语句
• this调用构造器不能出现递归

2.6. static关键字

用于修饰类的属性、方法、代码块和内部类，使其1）随类的加载而加载，从而独立于对象而存在；2）被所有对象共享；3）直接通过ClassName.调用

2.6.1. 静态属性（类属性）

[modifier] static type attrName [= value];

说明

• 被类的所有对象共享，存放在堆中（JDK6以前存放在方法区）
• 可以在本类的任意构造器、方法和代码块中访问
• 在本类外可通过ClassName.（推荐）或objName.两种方式访问
• getter/setter方法也是静态的，通过ClassName.attrName与同名的局部变量区分
• 属性访问只看编译时类型，即与对象类型无关

2.6.2. 静态方法（类方法）

[modifier] static type methodName([params]) [throws exceptions] {
    ...
}

说明

• 可以在本类的任意构造器、方法和代码块中调用
• 方法体中只能访问静态属性/方法，不能访问非静态属性/方法
• 在本类外可通过ClassName.（推荐）或objName.两种方式调用
• 通过ClassName.与同名的方法区分，不能使用this和super
• 可以被子类继承，但不能被子类重写
• 方法调用只看编译时类型，即与对象类型无关

2.7. 类的成员之代码块

代码块也叫初始化块，用于对类或对象进行初始化，可分为静态/非静态代码块

2.7.1. 语法格式

[static/default] {
	...
}

说明

• 静态代码块用于对类进行初始化，非静态代码块用于对对象执行初始化
• 静态代码块在类加载时执行且仅执行一次，非静态代码块在创建对象时执行
• 静态代码块不能调用非静态的属性/方法，非静态代码块可以调用任意属性/方法
• 多个代码块按照出现的顺序依次执行

2.7.2. 属性初始化顺序

1. 定义时默认初始化
2. 定义时显式初始化/代码块中初始化
3. 构造器中初始化

2.8. final关键字

final可用于修饰类、属性、方法、形参以及局部变量，表示最终的，不可修改

• 修饰类：表示类不能被继承，即没有子类，如String类、StringBuffer类、System类
• 修饰方法：表示该方法不能被子类重写
• 修饰变量：表示该变量是常量，变量名为全部大写，只能执行一次赋值，其中修饰类的属性时可以用显式初始化、代码块、构造器三种方式初始化

2.9. abstract关键字

2.9.1. 抽象类

[modifier] abstract class ClassName {
    ...
}

说明

• 抽象类不能创建对象，其构造器供子类调用
• 抽象类的子类必须是抽象的或重写父类的所有抽象方法

2.9.2. 抽象方法

[modifier] abstract type methodName([params]);

说明

• 抽象方法没有方法体（包括{}）
• 包含抽象方法的类必须是抽象类
• 子类中重写父类的抽象方法过程叫做实现方法

2.10. 类的成员之内部类

将一个类定义在另一个类的内部，那么前者称为内部类，后者称为外部类

根据定义的位置，内部类可以分为

• 成员内部类：包括静态成员内部类、非静态成员内部类
• 局部内部类：包括匿名局部内部类、非匿名局部内部类

2.10.1. 成员内部类

定义语法

[modifier] class OuterClass {
	[modifier] [static] class InnerClass {
		...
	}
	...
}

实例化

// 静态成员内部类
OuterClass.InnerClass objName = new OuterClass.InnerClass(params);

// 非静态成员内部类
OuterClass.InnerClass objName = outerClassObj.new InnerClass(params);

说明

• 成员内部类的权限修饰符还包括private和protected，其他修饰符及作用与类相同
• 成员内部类可以调用外部类的属性/方法(在静态内部类调用外部类的非静态属性/方法除外)
• 成员内部类中，使用OuterClass.this.调用外部类的属性/方法，OuterClass.调用外部类静态的属性/方法
• 编译后成员内部类的字节码文件名称为OuterClass$InnerClass.class

2.10.2. 局部内部类

非匿名局部内部类

[modifier] class OuterClass {
	method/constructor/block {
        [final/abstract] class InnerClass {  // 定义
            ...
        }
        InnerClass objName = new InnerClass(params);  // 实例化
		...
	}
	...
}

匿名局部内部类

[modifier] class OuterClass {
	method/constructor/block {
        SuperClass/Interface objName = new SuperClass/Interface(params) {
            ...
        };  // 定义和实例化
	}
	...
}

说明

• 局部内部类不能使用权限修饰符，其他修饰符及作用与类相同
• 局部内部类的作用域为所在的代码块内部，故可存在多个同名的局部内部类
• 局部内部类能调用所在方法/构造器/代码块中可以调用的外部类的属性/方法
• 编译后局部内部类的字节码文件名称为OuterClass + $ + <No> + InnerClass或 + .class

3. 接口

接口的本质是标准、规范，定义的是一组规则

3.1. 接口的定义

[modifier] interface InterfaceName {
	...
}

• modifier：修饰符，可以为public、default(缺省)等，内部类还可以用protected和private修饰
• InterfaceName：接口名，遵循大驼峰命名法则

说明

• 接口不能创建对象

3.1.1. 接口的属性

• 公共的静态常量：修饰符public static final可以省略

3.1.2. 接口的方法

• 公共的抽象方法（JDK8以下）：修饰符public abstract可以省略
• 公共的默认方法（JDK8新增）：修饰符public default中的public可以省略
• 公共的静态方法（JDK8新增）：修饰符public static中的static可以省略
• 私有方法（JDK9新增）

3.1.3. 接口的多继承

[modifier] interface InterfaceName extends InterfaceList {
	...
}

• InterfaceList：接口列表，接口之间用,隔开

说明

• 一个接口能继承另一个或多个接口（使用extends关键字）

3.2. 接口的使用

3.2.1. 使用步骤

1. 创建类实现接口，该类称为接口的实现类

   [modifier] class ClassName implements InterfaceName {
   	...
   }
   

   说明

   • 实现接口的类必须是抽象类或重写接口的所有抽象方法
   • default关键字仅用于接口的默认方法，实现类中重写时应省略
   • 类可以在继承父类的同时实现接口，此时遵循类优先原则：一个类父类中的成员方法与实现接口中的方法签名相同时，子类就近选择执行父类的成员方法

2. 创建实现类对象来调用属性或方法

   // 访问接口的静态属性
   InterfaceName.attr;
   
   // 调用接口的静态方法
   InterfaceName.methodName(params);
   
   // 调用接口的非静态方法
   classObj.methodName(params);
   

3.2.2. 接口的多实现

[modifier] class ClassName implements InterfaceList {
	...
}

说明

• 一个类可以同时实现多个接口
• 实现多个接口时，重名的抽象方法只需要重写一次即可
• 接口冲突：多个接口中默认方法的方法签名相同时，实现类必须重写该方法
• 实现类中用InterfaceName.super.methodName(params)调用接口中的方法

3.2.3. 接口的多态性

接口与实现类的对象构成多态引用

4. 枚举

枚举类型本质上是对象的数量有限且固定的一种类

4.1. 类方式定义（JDK5.0以前）

4.1.1. 定义步骤

1. 定义属性，修饰符推荐使用private final
2. 私有化类的构造器，保证类外部不能创建对象
3. 创建类的对象，并使用public static final修饰，保证对象可在类外部、使用类名调用且不可修改

4.1.2. 语法格式

[modifier] class EnumName {
    // 属性
    [modifier] type attr;
    ...
    
    // 私有构造器
    private EnumName(params) {
        ...
    }
    ...
    
    // 类的对象
    public static final EnumName instance = new EnumName(params);
    ...
}

• EnumName：枚举类名，遵循大驼峰命名法则

4.2. enum方式定义（JDK5.0之后）

4.2.1. 定义步骤

1. 定义属性，修饰符推荐使用private final
2. 定义类的构造器，初始化属性
3. 类的首行使用objName(params)创建常量对象，对象之间使用,隔开

4.2.2. 语法格式

[modifier] enum EnumName {
    // 常量对象列表
    objName(params)[, ...;]
    
    // 属性
    [modifier] type attr;
    ...
    
    // 构造器
    [modifier] EnumName(params) {
        ...
    }
    ...
}

说明

• 常量对象的修饰符为public static final，不需要显式指定

• 常量对象列表末尾;在后方没有其他代码是可以省略

• 构造器的权限为private，可以省略但不可修改

• 枚举类默认继承java.lang.Enum类，故不能再继承其他类，但可以实现接口

5. 注解

注解是从JDK5.0开始引入，以@AnnotationName形式在代码中存在，可以用修饰包、类、构造器、方法、属性、参数、局部变量的声明，可以在类编译、运行时加载，实现不同功能

• 注解的参数值以键值对name=value的形式存放
• 注解可以被编译器或其他程序读取，并做响应的处理

注解的组成

1. 注解的定义
2. 注解的使用
3. 注解的处理

5.1. 注解的定义

[meta-annotation]
[modifier] @interface AnnotationName {
    [memberList]
}

• AnnotationName：注解名，遵循大驼峰命名法则
• memberList：成员列表

说明

• 注解可以被java.lang.annotation中定义的标准元注解修饰

• 方法成员又称配置参数，使用无参数、有返回值的抽象方法形式定义

  type methodName() [default value];
  

  • 返回值类型包括基本数据类型、String类型、Class类型、枚举类型、注解类型及其数组
  • 可以使用default关键字为抽象方法指定默认返回值
  • 如果只有一个抽象成员方法，推荐使用value作为方法名

• 使用含有配置参数的注解时必须指定返回值（格式为methodName = returnValue）或设置默认值，且只有一个名为value的方法名时，可以省略value=

常见元注解

注解	说明
@Target	描述注解的使用范围，使用枚举类型ElementType的10个常量指定
@Retention	描述注解的生命周期，使用枚举类型RetentionPolicy的3个常量指定
@Documented	表明注解应该被javadoc工具记录
@Inherited	表明允许子类继承父类中的注解

5.2. 注解的使用

// 不指定返回值
@Annotation

// 指定返回值
@Annotation(returnValues)

5.3. 注解的处理

自定义注解只能使用反射机制读取，具体处理方法见反射部分

6. 包

Java中包是用于管理类、接口等结构的机制，关键字package

包的作用

1. 划分项目层次，便于管理
2. 解决命名冲突问题
3. 控制访问权限

6.1. 包的声明

package pkgname;

• pkgname：包名，全部小写，不同层次间用.分隔

说明

• package语句应是源文件的第一条语句
• 一个源文件只能有一个package语句，如果缺省则为无名包
• 同一个包下结构（类、接口）的名称必须不同，不同包下可以相同

注意

• 取包名时不要以java为顶层包名

6.2. 包的导入

为了在其他的包中使用定义好的Java类，需要使用import语句显式导入

import pkgname.ClassName;

说明

• import语句位于包的声明之后、类的定义之前
• 导入多个结构时将import语句并列，且结构名称相同时按语句先后顺序生效
• 如需使用多个同名的结构，则应使用全类名pkgname.ClassName
• 使用*表示当前包下的所有结构，可在包的层次中使用
• 使用已导入包的子包下的类仍需要将子包导入

6.2.1. 导包原则

• java.lang和当前包下类不需要显式导入
• import static组合使用可以调用指定类或接口下的静态属性或方法

7. 三大特性

7.1. 封装性

所谓封装，就是把客观事物封装成抽象概念的类，且类的数据和方法只对可信的类或者对象开放，对其他类或者对象隐藏，是“高内聚、低耦合”思想的体现

Java的封装性通过权限修饰符实现

7.1.1. 权限修饰符

public、protected、default(缺省)和private，其访问范围如下

修饰符	类内	包内	其他包子类	其他包非子类
private	√	×	×	×
default(缺省)	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

说明

• 外部类只能使用public、default(缺省)控制访问权限

7.1.2. 属性封装

私有属性

1. 使用private修饰属性
2. 提供getXxx和setXxx方法访问属性

好处

• 可以在方法中添加控制逻辑，限制对成员变量的不合理访问
• 可以进行数据检查，保证对象信息的完整性
• 便于修改，提高代码的可维护性

7.1.3. 方法封装

私有方法

使用private修饰方法，仅供类内部调用

7.2. 继承性

一个类继承另一个类后，前者拥有后者的所有属性和方法，且可定义新的属性和方法，其作用是：1）能够减少代码冗余，提高代码的复用性；2）有利于类功能的扩展

7.2.1. 语法格式

[modifier1] class SuperClass {
	...
}

[modifier2] class SubClass extends SuperClass {
	...
}

• SuperClass：父类，或称超类、基类
• SubClass：子类，或称派生类

说明

• 子类继承父类的所有属性和方法，其中同名属性同时存在而同名方法重载/重写
• 子类对象访问方法或属性时按照子类 > 父类的顺序查找（就近原则）
• 子类不能直接访问父类中的私有属性和方法
• 子类只能继承一个父类即单继承，但一个父类可以有多个子类
• 子类可以（作为父类）被其他类继承，即多层继承
• 子类构造器的第一条语句必定是本类或父类构造器的调用，即this(params)和super(params)

7.2.2. 方法重写（override或overwrite）

子类重新定义从父类中继承的方法的过程叫做方法的重写，也称方法的覆盖

@Override  // （非必须）用于语法检查的重写注解
[modifier] type methodName([params]) [throws exceptions] {
    ...
}

重写规则

• 访问权限必须不低于所继承方法的权限
• 返回类型必须不大于所继承方法的返回类型
• 方法名和参数列表必须与所继承方法相同
• 抛出异常的类型必须不大于父类方法的异常类型
• 只有子类中可见的实例方法支持重写

7.2.3. super关键字

super关键字指代当前对象所属类的（直接或间接）父类，仅在类的内部使用

访问父类属性

super.attrName

说明

• 使用super指代当前对象所属类的父类，常用于区分父类和子类的（可见）属性
• 在不混淆的形况下，super关键字可以省略

调用父类方法

super.methodName(params)

• 在不混淆的形况下，super关键字可以省略

调用父类构造器

super(params)

说明

• 必须是子类构造器的第一条语句

7.3. 多态性

多态性是编译时类型与运行时类型不一致的现象

变量有编译时类型和运行时类型：编译时变量的类型由定义时的类型决定，运行时变量的类型由实际赋给该变量的值决定（编译看左边，运行看右边）

7.3.1. 两个前提

1. 变量和值所属的类具有继承关系
2. 子类重写父类的方法

7.3.2. 对象多态

将子类的对象赋值给父类即父类的引用指向子类对象，称为对象的多态性，主要用于以下场景

1. 利用多态性为局部变量复制
2. 利用多态性为定义方法形参（实现开闭原则OCP）
3. 利用多态性定义方法返回类型

说明

• 对象的多态性仅在类的方法中体现，即根据引用对象的类型调用不同的方法
• 利用对象的多态性无法访问子类特有的属性和方法

7.3.3. 类型转换

• 向下转型（强制转换）：引用类型由父类转换为子类，转换后无法调用子类特有的方法
• 向上转型（自动完成）：引用类型由子类转换为父类，转换时可能抛出异常

7.3.4. instanceof运算符

判断对象是否是一个类或其子类的实例，如果是返回true；否则，返回false

objName instanceof ClassName

7.3.5. 虚方法

虚方法是指在编译阶段不能确定入口地址的方法

• 静态链接（晚期绑定）：JVM装载字节码文件时，被调用的目标方法在编译期已经确定且运行期间保持不变，故将调用方法的符号引用转换为直接引用，该过程叫做静态链接
• 动态链接（早期绑定）：JVM装载字节码文件时，被调用的目标方法在编译期无法确定，只能在运行期间将调用方法的符号引用转换为直接引用，该过程叫做动态链接

8. 包装类

Java提供了基本数据类型的引用类型，叫做包装类（封装类）

基本数据类型	包装类	缓存对象
byte	Byte	-128~127
short	Short	-128~127
int	Integer	-128~127
long	Long	-128~127
float	Float	无
double	Double	无
boolean	Boolean	0~127
char	Character	true和false

说明

• Byte、Short、Integer、Long、Float、Double的父类为Number

8.1. 自定义包装类

public class MyType {
    type value;
    
    public MyType() {
    }
    
    public MyType(type value) {
        this.value = value;
    }
    
    @override
    public String toString() {
        return String.valueOf(value);
    }
}

8.2. 拆装箱

8.2.1. 装箱

基本数据类型转换为包装类

Xxx obj = new Xxx(value);  // 已过时
Xxx obj = Xxx.valueOf(value);  // 推荐

• Xxx：包装类

8.2.2. 拆箱

包装类转换为基本数据类型

xxx var = obj.xxxValue();

• xxx：基本数据类型

8.2.3. 自动拆装箱

从JDK5.0开始，基本数据类型与包装类之间赋值时自动完成拆装箱操作

注意

• 自动拆装箱仅支持基本数据类型和对应的包装类，不支持自动类型提升
• 包装类的对象不可改变，自动拆装箱通过创建新的对象实现
• 拆箱的优先级高于装箱的优先级

8.3. 基本数数值、包装类与字符串转换

8.3.1. 转字符串

基本数值

• 调用String.valueOf(value)方法
• 拼接空字符串

包装类

• 调用String.valueOf(value)方法
• 调用toString()方法

8.3.2. 字符串转

基本数值

• 调用包装类的parseXxx(str)方法（Character类除外），无法转换则抛出NumberFormatException异常

包装类

• 调用包装类的valueOf(str)方法，无法转换则抛出NumberFormatException异常
• 创建包装类对象，无法转换则抛出NumberFormatException异常

8.4. 缓存对象

如果能够使用缓存对象，创建的多个包装类对象是同一个，体现“享元设计模式”

9. 常用API

9.1. 常用类

9.1.1. java.lang.Object

• 任何一个Java类都直接或间接的继承了Object类，可以省略不写
• Object类是所有Java类的根父类，其中定义结构具有通用性
• Object类中提供了一个空参构造方法，没有定义属性

常用方法

方法	说明
String toString()	返回当前枚举常量名
static EnumClass[] values()	返回枚举类型EnumClass的所有常量对象
static EnumClass valueOf(String name)	返回name在枚举类型EnumClass中的常量对象
final String name()	返回当前枚举常量名
final int ordinal()	返回当前枚举常量的次序（从0开始）

9.1.2. java.lang.Enum

常用方法

方法	说明
protected Object clone()	创建并返回当前对象的复制品
protected void finilize()	（过时）对象回收前自动调用该方法执行清理操作
boolean equals(Object obj)	判断obj与当前对象的地址是否相等（即同一个对象）
String toString()	返回当前对象的字符串表示
final Class<?> getClass()	返回当前对象的运行时类型

9.1.3. 包装类java.lang.Xxx

常用属性

属性	说明	类
static final int MAX_VALUE	最大值	除Boolean外
static final int MIN_VALUE	最小值	除Boolean外

常用方法

方法	说明	类
static int compare(arg1, arg2)	比较两个指定的数值	所有
static char toUpperCase(char ch)	返回字符参数ch的大写字符(Character类)	Character
static char toLowerCase(char ch)	返回字符参数ch的小写字符	Character
static String toBinaryString(arg)	返回参数arg的二进制表示	Integer、Long
static String toOctalString(arg)	返回参数arg的八进制表示	Integer、Long
static String toHexString(arg)	返回参数arg的十六进制表示	Integer、Long

9.2. 常用注解

文档注释相关

注解	说明
@author	标明该模块的开发者，使用,分隔
@version	标明该模块的版本
@see	参考转向，即相关主题
@since	表示从哪个版本增加的
@param	对方法中的参数进行说明，没有参数时不写
@return	对方法的返回值进行说明，没有返回值时不写
@exception	对方法可能抛出的异常进行说明，没有显式抛出异常时不写

编译检查相关

注解	说明
@Override	限制重写父类方法，否则编译报错
@Deprecated	表示修饰的结构已过时，不推荐使用
@SuppressWarnings	抑制编译器警告

10. 扩展

10.1. JavaBean

所谓JavaBean是指符合以下标准的类

1. 类是公共的
2. 含有一个无参、公共的构造器
3. 有属性及其getter、setter方法

10.2. 设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式

经典的设计模式有23种，其中简单工厂模式是工厂方法的简化版，不是经典模式的一种

10.2.1. 单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，某个类只存在一个对象实例，并且该类只提供一个获取其实例的方法

实现思路

1. 设置该类构造器的访问权限为private
2. 在类内部创建该类的对象实例
3. 调用static方法返回该类的对象实例
4. 设置该类的对象实例为static

两种实现

• 饿汉式
  • 特点：立即加载，即在使用类时已经将对象创建完毕
  • 优点：实现简单；不存在线程安全问题
  • 缺点：特定条件下耗费内存空间
• 懒汉式
  • 特点：延迟加载，即首次调用静态方法时才创建实例
  • 优点：实现简单；特定条件下节约内存空间
  • 缺点：存在线程安全问题，不能保证单例的唯一性

应用场景

• Java的Runtime类
• Android用户界面的Application类
• Windows的Task Manager（任务管理器）、Recycle Bin（回收站）

10.2.2. 模板方法设计模式

所谓模板方法设计模式是指当功能内部的一部分实现是确定的，另一部分是不确定的时，把确定的部分在父类中实现而不确定的部分让子类去实现

实现思路

1. 定义抽象类，实现确定的功能并用抽象方法暴露不确定的功能
2. 定义子类，重写父类中的抽象方法，实现不确定的功能

应用场景

• Spring中JDBCTemplate、HibernateTemplate
• JavaWeb的Servlet中doGet/doPost方法调用
• 数据库访问的封装

10.3. JUnit的使用

1. 添加JUnit库（jar包）
2. 使用@Test注解修饰单元测试方法，该方法需满足
   • 所在类是public、非抽象且包含唯一的无参构造器
   • 修饰的方法必须是public、非抽象、非静态，且无返回值、无参数
3. 编译和运行单元测试方法

参考资料

1. 尚硅谷Java零基础全套视频教程(宋红康2023版，java入门自学必备)_哔哩哔哩_bilibili