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

Java面向对象

文章目录

1. 概述

1.1. 程序设计思想

1.1.1. 面向过程编程
  • 关注过程,即数据的操作步骤
  • 函数为单位组织代码
  • 适用于简单程序设计
1.1.2. 面向对象编程
  • 关注类,即事物的属性特征和行为特征
  • 为单位组织代码
  • 适用于复杂程序设计

1.2. 面向对象的基本元素

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

2. 类和对象

2.1. 类的引入

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

  • 属性:描述该类事物的状态信息
  • 行为:定义该类事物能执行的操作
2.1.1. 类的定义
[modifier] class ClassName {
    ...
}
  • modifier:修饰符,可以为publicdefault(缺省)等,内部类还可以用protectedprivate修饰
  • ClassName:类名,遵循大驼峰命名法则
2.1.2. 类的实例化
ClassName objName = new ClassName();
  • objName:对象名,遵守小驼峰命名法则

匿名对象

创建对象时,不定义对象的句柄(赋值给变量),这样的对象叫做匿名对象

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

2.2. 类的成员之属性

2.2.1. 属性定义
[modifier] type attrName [= value];
  • modifier:修饰符,可以为publicprotecteddefault(缺省)privatestaticfinale
  • attrName:属性名,遵循小驼峰命名法则

说明

  • 属性必须定义在类的内部、方法的外部
  • 属性存储在堆中,会执行默认初始化
  • 属性的作用域为所属的类,生命周期与类的对象相同
2.2.2. 属性访问
objName.attrName
2.2.3. 属性赋值顺序

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

2.3. 类的成员之方法

2.3.1. 方法定义
[modifier] type methodName([params]) [throws exceptions] {
    ...
}
  • modifier:修饰符,可以为publicprotecteddefault(缺省)privatestaticabstract
  • 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:权限修饰符publicprotecteddefault(缺省)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.与同名的方法区分,不能使用thissuper
  • 可以被子类继承,但不能被子类重写
  • 方法调用只看编译时类型,即与对象类型无关

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);

说明

  • 成员内部类的权限修饰符还包括privateprotected,其他修饰符及作用与类相同
  • 成员内部类可以调用外部类的属性/方法(在静态内部类调用外部类的非静态属性/方法除外)
  • 成员内部类中,使用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:修饰符,可以为publicdefault(缺省)等,内部类还可以用protectedprivate修饰
  • 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. 权限修饰符

publicprotecteddefault(缺省)private,其访问范围如下

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

说明

  • 外部类只能使用publicdefault(缺省)控制访问权限
7.1.2. 属性封装

私有属性

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

好处

  • 可以在方法中添加控制逻辑,限制对成员变量的不合理访问
  • 可以进行数据检查,保证对象信息的完整性
  • 便于修改,提高代码的可维护性
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. 方法重写(overrideoverwrite

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

@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提供了基本数据类型的引用类型,叫做包装类(封装类)

基本数据类型包装类缓存对象
byteByte-128~127
shortShort-128~127
intInteger-128~127
longLong-128~127
floatFloat
doubleDouble
booleanBoolean0~127
charCharactertruefalse

说明

  • 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种,其中简单工厂模式是工厂方法的简化版,不是经典模式的一种

image-20231008105335284
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
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值