Java 面向对象高级抽象类、接口

一、final 关键字

final关键字意为最终的，可以修饰类、方法和变量，起到不同的限制作用。

修饰类 ：被final修饰的类为最终类，不能被继承。例如：

java 复制代码

final class FinalClass {
    // 类的内容
}
// 以下代码会报错，因为FinalClass不能被继承
// class SubClass extends FinalClass {}

修饰方法：修饰后的方法为最终方法，不能被重写。示例如下：

java 复制代码

class Parent {
    final void finalMethod() {
        System.out.println("这是一个final方法");
    }
}
class Child extends Parent {
    // 以下代码会报错，final方法不能被重写
    // @Override
    // void finalMethod() {
    //     System.out.println("尝试重写final方法");
    // }
}

修饰变量：变量有且仅能被赋值一次。修饰基本类型变量时，其存储的数据不能改变；修饰引用类型变量时，变量存储的地址不能改变，但地址指向对象的内容可以改变。

java 复制代码

class FinalVariableExample {
    final int basicFinalVar = 10;
    final StringBuilder referenceFinalVar = new StringBuilder("初始内容");

    void testFinalVar() {
        // 以下代码会报错，基本类型的final变量不能重新赋值
        // basicFinalVar = 20; 
        referenceFinalVar.append("，追加内容");
        System.out.println(referenceFinalVar); 
    }
}

二、常量

使用static final修饰的成员变量即为常量，通常用于记录系统配置信息。

java

arduino 复制代码

public class Constant {
    public static final String SCHOOL_NAME = "传智教育";
}

常量名建议用大写英文单词，多个单词用下划线连接。其优势在于提高代码可读性和可维护性，程序编译后，常量会被 "宏替换"，使用常量和直接用字面量性能相同。

三、单例类（设计模式）

设计模式是针对特定问题的最优解决方案，单例设计模式确保某个类只能创建一个对象。

（一）饿汉式单例

java 复制代码

public class EagerSingleton {
    // 定义静态变量记住类的一个对象，在类加载时就创建对象
    private static EagerSingleton instance = new EagerSingleton();
    // 私有构造器，防止外部创建对象
    private EagerSingleton() {}
    // 提供静态方法返回对象
    public static EagerSingleton getInstance() {
        return instance;
    }
}

饿汉式单例在获取对象时，对象已创建好，优点是实现简单，缺点是可能造成资源浪费，若对象一直未使用，也会在类加载时创建。

（二）懒汉式单例

java 复制代码

public class LazySingleton {
    // 定义静态变量用于存储对象，初始值为null
    private static LazySingleton instance;
    // 私有构造器
    private LazySingleton() {}
    // 提供静态方法返回对象，在调用时才创建对象
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

懒汉式单例延迟加载对象，在需要时才创建，节省资源，但在多线程环境下可能出现线程安全问题，需额外同步机制处理。

四、枚举类

枚举是特殊类，用于定义取值有限的类型。

java 复制代码

public enum Gender {
    MALE, FEMALE
}
class Person {
    private String name;
    private Gender gender;
    public Person(String name, Gender gender) {
        this.name = name;
        this.gender = gender;
    }
    // 省略get/set方法
}
class EnumTest {
    public static void main(String[] args) {
        Person person = new Person("张三", Gender.MALE);
        System.out.println(person);
    }
}

枚举类第一行罗列对象名称，本质是常量，记住枚举类的对象。枚举类是最终类，继承java.lang.Enum类，构造器私有，不能对外创建对象。编译器为其新增values()、valueOf(String)等方法，方便获取枚举常量。

五、抽象类

使用abstract关键字修饰类或成员方法，修饰类时为抽象类，修饰方法时为抽象方法。

java 复制代码

abstract class Animal {
    // 抽象方法，只有方法签名，无方法体
    public abstract void move();
}
class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("狗四条腿跑路");
    }
}
class Chicken extends Animal {
    @Override
    public void move() {
        System.out.println("鸡两条腿跑路");
    }
}

抽象类好处在于支持多态，父类定义抽象方法，让子类重写实现。抽象类不一定要有抽象方法，但有抽象方法的类必须是抽象类。抽象类不能创建对象，作为特殊父类供子类继承，子类继承抽象类需重写全部抽象方法，否则子类也需定义为抽象类。

六、模板方法设计模式

提供完成某功能的模板方法，封装通用步骤，不确定步骤由子类实现。

java 复制代码

abstract class Singer {
    // 模板方法，用final修饰防止子类重写
    public final void sing() {
        goOnStage();
        turnOnMicrophone();
        singSong();
        turnOffMicrophone();
        bow();
    }
    // 抽象方法，由子类实现具体演唱内容
    protected abstract void singSong();
    // 通用方法，具体实现可在子类中根据情况调整
    protected void goOnStage() {
        System.out.println("上台");
    }
    protected void turnOnMicrophone() {
        System.out.println("打开话筒");
    }
    protected void turnOffMicrophone() {
        System.out.println("关闭话筒");
    }
    protected void bow() {
        System.out.println("鞠躬");
    }
}
class Cxk extends Singer {
    @Override
    protected void singSong() {
        System.out.println("唱《只因你太美》");
    }
}
class DaoLang extends Singer {
    @Override
    protected void singSong() {
        System.out.println("唱《2002年的第一场雪》");
    }
}

通过模板方法设计模式，提高代码复用性，简化子类设计。

七、接口

使用interface关键字定义接口，接口中可定义成员变量（常量）和成员方法（抽象方法）。

java 复制代码

public interface Printable {
    void print();
}
class Student implements Printable {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    @Override
    public void print() {
        System.out.println("学生：" + name);
    }
}

接口弥补类单继承的不足，一个类可实现多个接口，使类功能更强大。接口用于解耦合，让程序面向接口编程，便于切换业务实现。

（一）JDK8 开始接口新增的方法

默认方法 ：用default修饰，默认加public修饰，由接口实现类对象调用。

java 复制代码

public interface NewInterface {
    default void defaultMethod() {
        System.out.println("这是一个默认方法");
    }
}
class InterfaceImplement implements NewInterface {}
class Main {
    public static void main(String[] args) {
        InterfaceImplement implement = new InterfaceImplement();
        implement.defaultMethod(); 
    }
}

静态方法 ：用static修饰，默认加public修饰，通过接口名调用。

java 复制代码

public interface StaticMethodInterface {
    static void staticMethod() {
        System.out.println("这是一个静态方法");
    }
}
class Main {
    public static void main(String[] args) {
        StaticMethodInterface.staticMethod(); 
    }
}

私有方法 ：JDK9 开始支持，用private修饰，只能在接口内部调用。

java 复制代码

public interface PrivateMethodInterface {
    private void privateMethod() {
        System.out.println("这是一个私有方法");
    }
    default void callPrivateMethod() {
        privateMethod(); 
    }
}
class Main {
    public static void main(String[] args) {
        PrivateMethodInterface implement = new PrivateMethodInterface() {};
        implement.callPrivateMethod(); 
    }
}

这些新增方法增强了接口能力，便于项目扩展和维护。

（二）接口的注意事项

接口不能创建对象，接口与接口可以多继承，一个接口可同时继承多个接口。实现接口的类必须重写接口中的全部抽象方法，否则该类需定义为抽象类。