2.43.继承专属的访问控制：protected

继承专属的访问控制：protected
看例程：学习 protected 可见性 = default + 对子类可见

看例程：覆盖可以，但是不能让可见性更低

public class TestVizAppMain {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);

        // >> TODO 不同包里的代码，不可以访问缺省和protected
        Phone ph = (Phone) superMarket.getMerchandiseOf(10);
//        System.out.println(ph.screenSize);
//        System.out.println(ph.memoryG);

        ShellColorChangePhone scp = (ShellColorChangePhone) superMarket.getMerchandiseOf(100);
//        System.out.println(scp.screenSize);
//        System.out.println(scp.memoryG);

    }

}

public class Phone extends MerchandiseV2 {

    // >> TODO 使用不同的可见性定义Phone中的属性，protected = default + 继承者可见
    protected double screenSize;
    protected double cpuHZ;
    int memoryG;
    int storageG;
    private String brand;
    private String os;
    private static int MAX_BUY_ONE_ORDER = 5;

    // >> TODO 构造方法可以是protected，但是如果是private，子类就不可以覆盖了。
    //    TODO 如果父类只有一个private的构造方法，相当于这个类不能有子类
    protected Phone(
        String name, String id, int count, double soldPrice, double purchasePrice,
        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;
    }

    public double buy(int count) {
        System.out.println("Phone里的buy(int count)");
        if (count > MAX_BUY_ONE_ORDER) {
            System.out.println("购买失败，手机一次最多只能买" + MAX_BUY_ONE_ORDER + "个");
            return -2;
        }
        return super.buy(count);
    }

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

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

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

public class TestVizSamePkgAppMain {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);

        // >> TODO 同一个包里的代码，可以访问缺省和protected
        Phone ph = (Phone) superMarket.getMerchandiseOf(10);
        System.out.println(ph.screenSize);
        System.out.println(ph.memoryG);

        // >> TODO 同一个包里的代码，可以访问缺省和protected，子类也没问题
        ShellColorChangePhone scp = (ShellColorChangePhone) superMarket.getMerchandiseOf(100);
        System.out.println(scp.screenSize);
        System.out.println(scp.memoryG);

    }
}

public class OnlineSpecialPhone extends Phone {

    public OnlineSpecialPhone(String name, String id, int count, double soldPrice, double purchasePrice, double screenSize, double cpuHZ, int memoryG, int storageG, String brand, String os) {
        super(name, id, count, soldPrice, purchasePrice, screenSize, cpuHZ, memoryG, storageG, brand, os);
        this.screenSize = 99;
    }

    // >> TODO 子类覆盖父类的方法，不可以用可见性更低的修饰符，但是可以用更高的修饰符
    // >> TODO 原因是什么呢？
   public String getNameOfPhone(){
        return super.getNameOfPhone();
   }
}

不同包里的代码，不可以访问缺省和protected

使用不同的可见性定义Phone中的属性，protected = default + 继承者可见

构造方法可以是protected，但是如果是private，子类就不可以覆盖了。
如果父类只有一个private的构造方法，相当于这个类不能有子类

同一个包里的代码，可以访问缺省和protected，子类也没问题

子类覆盖父类的方法，不可以用可见性更低的修饰符，但是可以用更高的修饰符
原因是什么呢？

包可见性汇总

类内部	本包	子类	外部包
private
default	default
protected	protected	protected
public	public	public	public