2.44.final 修饰符

final 修饰符最见不得变化
final 修饰类：不可被继承

inal 修饰方法：不可被子类覆盖

final 修饰变量：不可被赋值。这个最难理解

被final修饰的变量其实就相当于定义了一个常量，无法被修改的变量，如果final修饰的是一个基本数据类型的变量，那么这个变量的值就定了，不能变了，而如果修饰的是一个引用变量，那么该变量存的是一个内存地址，该地址就不能变了，但是该内存地址所指向的那个对象还是可以变的，就像你记住了人家的门牌号，但你不能管人家家里人员数量

// >> TODO 用final 修饰类看看？
public class Phone extends MerchandiseV2 {

    // >> TODO 用 final 修饰成员变量看看？
    private double screenSize;
    private double cpuHZ;
    private int memoryG;
    private int storageG;
    private String brand;
    private String os;
    // >> TODO 用 final 修饰静态变量看看？
    private final static int MAX_BUY_ONE_ORDER = 9;
    // >> TODO 用 final 修饰引用，最难理解
    private final MerchandiseV2 gift;


    // >> TODO 构造方法不能用 final 修饰
    public Phone(
            String name, String id, int count, double soldPrice, double purchasePrice, MerchandiseV2 gift,
            double screenSize, double cpuHZ, int memoryG, int storageG, String brand, String os
    ) {
        super(name, id, count, soldPrice * 1.2, purchasePrice);
        this.screenSize = screenSize;
        this.cpuHZ = cpuHZ;
        this.memoryG = memoryG;
        this.storageG = storageG;
        this.brand = brand;
        this.os = os;
        this.gift = gift;
    }

    // >> TODO 用 final 修饰方法看看？
    // >> TODO 用 final 修饰形参看看？
    // >> TODO 用 final 修饰局部变量看看？
    public double buy(final int count) {
        System.out.println("Phone里的buy(int count)");
        if (count > MAX_BUY_ONE_ORDER) {
            System.out.println("购买失败，手机一次最多只能买" + MAX_BUY_ONE_ORDER + "个");
            return -2;
        }

        final double cost;
        cost = super.buy(count);
        return cost;
    }

    public String getName() {
        return this.brand + ":" + this.os + ":" + super.getName();
    }

    public void describe() {
        System.out.println("此手机商品属性如下");
        super.describe();
        System.out.println("手机厂商为" + brand + "；系统为" + os + "；硬件配置如下：\n" +
                "屏幕：" + screenSize + "寸\n" +
                "cpu主频" + cpuHZ + " GHz\n" +
                "内存" + memoryG + "Gb\n" +
                "存储空间" + storageG + "Gb");

        System.out.println("赠品信息为：");
        gift.describe();
    }

    public MerchandiseV2 getGift() {
        return gift;
    }

//    public void setGift(MerchandiseV2 gift) {
//        this.gift = gift;
//    }

    public boolean meetCondition() {
        return true;
    }

    public double getScreenSize() {
        return screenSize;
    }

    public void setScreenSize(double screenSize) {
        this.screenSize = screenSize;
    }

    public double getCpuHZ() {
        return cpuHZ;
    }

    public void setCpuHZ(double cpuHZ) {
        this.cpuHZ = cpuHZ;
    }

    public int getMemoryG() {
        return memoryG;
    }

    public void setMemoryG(int memoryG) {
        this.memoryG = memoryG;
    }

    public int getStorageG() {
        return storageG;
    }

    public void setStorageG(int storageG) {
        this.storageG = storageG;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getOs() {
        return os;
    }

    public void setOs(String os) {
        this.os = os;
    }

    public static void staticNoOverride() {

        System.out.println("staticNoOverride in Phone");
    }

}

用final 修饰类看看？

用 final 修饰成员变量看看？
用 final 修饰静态变量看看？
用 final 修饰方法看看？
用 final 修饰形参看看？
用 final 修饰局部变量看看？

用 final 修饰引用，最难理解

构造方法不能用 final 修饰

final在Java中是一个保留的关键字，可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final，你将不能改变这个引用了，编译器会检查代码，如果你试图将变量再次初始化的话，编译器会报编译错误。

根据上下文环境，java的关键字final也存在着细微的区别，但通常指的是“这是无法改变的。”