final 关键字

在Java 中 final称为终结器，在Java 里面可以使用 final定义类、方法和属性，用于表示不可变性。

final类： 当一个类被声明为final时，意味着该类不能被继承。换句话说，不能创建该类的子类。通常将类声明为final的主要原因是防止其他类修改或扩展该类的行为。

final方法: 当一个方法被声明为final时，意味着该方法不能被子类重写或覆盖。这种限制可以保护方法的实现，确保不会被修改。
通常情况下，一个方法被声明为final是因为它的实现在父类中已经足够完善，不希望子类对其进行修改；

final变量: 当一个变量被声明为final时，意味着该变量的值不能被更改就成为了常量。一旦给final变量赋值，就不能再修改它的值。

通常将变量声明为final是为了防止其被重新分配或重新赋值，保持其不可变性。

final变量可以是基本类型（如int、double等）或引用类型（如对象、数组引用等），但引用类型的final变量指的是不能被重新分配，即不能再指向其他对象，但仍然可以修改对象的状态。

全局常量: 所谓全局常量指的就是使用了"public"、“static”、“final”3个关键字联合定义的常量,例如：

public static final String ERR_MSG = "权限不足";

static 修饰的数据保存在公共数据区，所以此处的常量就是一个公共常量。在定义常量时必须对其进行初始化赋值，否则将出现语法错误。

抽象类

抽象类可以明确地定义子类需要覆写的方法。

普通类可以直接产生实例化对象，并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分，抽象方法指的是没有方法体的方法，同时抽象方法还必须使用 abstract 关键字进行定义。拥有抽象方法的类一定属于抽象类。

类中有抽象方法，那么类就必须定义为抽象类。
抽象类只是比普通类多了抽象方法的定义，其他结构与普通类完全一样。
抽象类是不能直接进行对象实例化操作。

抽象类不能使用 final定义，因为抽象类必须有子类，而 final定义的类不能有子类；

抽象类应用案例—模板设计模式

抽象类：
定义模板方法(固定流程) + 抽象方法(字类必须实现) + 钩子方法(可选)

具体实现类：
重写抽象方法，实现自己逻辑

public abstract class AbstractTransferTemplate {

    // 模板方法：final 防止子类篡改流程
    public final void transfer() {
        checkUser();     // 1.校验用户
        checkBalance(); // 2.校验余额
        doTransfer();   // 3.**执行转账（子类实现）**
        recordLog();    // 4.记录日志
    }

    // 固定不变
    protected void checkUser() {
        System.out.println("统一校验用户身份、风控...");
    }

    // 抽象方法：子类必须实现
    protected abstract void **doTransfer**();

    // 固定不变
    protected void checkBalance() {
        System.out.println("统一校验余额充足...");
    }

    protected void recordLog() {
        System.out.println("统一记录转账流水日志...");
    }
}

public class SameBankTransfer extends AbstractTransferTemplate {
    @Override
    protected void doTransfer() {
        System.out.println("本行转账：本地事务直接扣减+增加");
    }
}

public class CrossBankTransfer extends AbstractTransferTemplate {
    @Override
    protected void doTransfer() {
        System.out.println("跨行转账：发送MQ/银联异步清算");
    }
}

接口

利用抽象类可以实现对子类覆写方法的控制，但是抽象类的子类存在一个很大的问题——单继承局限，所以为了打破这个局限，就需要用 Java 中的接口来解决。

同时在开发中为了将具体代码的实现细节对调用处进行隐藏，也可以利用接口来进行方法视图的描述。

接口应用—工厂设计模式

工厂模式 = 把 “创建对象” 的逻辑封装起来，外部只通过工厂拿对象，不 new
核心目的：解耦、统一管理、便于扩展、符合开闭原则

工厂模式 3 种形态

1.简单工厂（静态工厂）
一个工厂 + 一个接口 + 多个实现类，工厂根据类型返回不同实现

public interface Pay {
    void pay(); // 支付方法
}

public class WxPay implements Pay {
    @Override
    public void pay() {
        System.out.println("微信支付");
    }
}

public class AliPay implements Pay {
    @Override
    public void pay() {
        System.out.println("支付宝支付");
    }
}

封装工厂类

public class PayFactory {
    // 静态方法获取支付实例
    public static Pay getPay(String type) {
        if ("wx".equals(type)) {
            return new WxPay();
        } else if ("ali".equals(type)) {
            return new AliPay();
        }
        return null;
    }
}

使用如下：

Pay pay = PayFactory.getPay("wx");
pay.pay();

工厂方法（接口化、可扩展、企业常用）

public interface Pay {
    void pay();
}

public interface PayFactory {
    Pay createPay();
}

实现工厂类

public class WxPayFactory implements PayFactory {
    @Override
    public Pay createPay() {
        return new WxPay();
    }
}

实现工厂类

public class AliPayFactory implements PayFactory {
    @Override
    public Pay createPay() {
        return new AliPay();
    }
}

PayFactory factory = new WxPayFactory();
Pay pay = factory.createPay();
pay.pay();

接口的应用——代理设计模式 (Proxy)

Spring AOP、事务、日志、权限 必用
核心：接口定义行为 → 真实类实现 → 代理类实现同一接口并包裹真实对象
作用：权限控制、日志、事务、限流、监控、懒加载

// 银行转账接口
public interface BankTransfer {
    void transfer(String money);
}

// 真正转账的类
public class RealTransfer implements BankTransfer {
    @Override
    public void transfer(String money) {
        System.out.println("执行转账：" + money);
    }
}

// 代理类：增强权限、日志、审计
public class TransferProxy implements BankTransfer {

    private BankTransfer realTransfer;

    public TransferProxy(BankTransfer realTransfer) {
        this.realTransfer = realTransfer;
    }

    @Override
    public void transfer(String money) {
        // 前置增强
        System.out.println("【代理】权限校验、日志记录、风控检查");

        // 调用真实方法
        realTransfer.transfer(money);

        // 后置增强
        System.out.println("【代理】转账完成，记录流水");
    }
}

public class Test {
    public static void main(String[] args) {
        BankTransfer real = new RealTransfer();
        BankTransfer proxy = new TransferProxy(real);
        
        proxy.transfer("1000元");
    }
}

hashCode()方法

hashCode()方法用于计算对象的哈希码值。
在Java中，哈希码用于加快查找和比较对象的速度
Object类中的hashCode()方法返回对象的内存地址的整数表示形式

finalize()方法

finalize()方法在垃圾回收器将对象从内存中清除之前被调用

getClass()方法

getClass()方法返回对象所属的类的Class对象。