java继承与多态使接口通用化

其实这里还没有真正对接口进行优化，只为记录一次学习继承与多态的笔记
请上三位实体：
【父类】

/**
 * 被继承的抽象类
 * Author:FangKunSen
 * Time:2020-07-06,09:08
 */
public abstract class AbstractClassBeExtends {
    public abstract String abstractMethod();
    public void publicMethod(){
        System.out.println("默认方法");
    }
    public void readAbstractMethod(){
        System.out.println("读取抽象方法..."+this.abstractMethod());
    }
}

【子类一 Impl 】

/**
 * Author:FangKunSen
 * Time:2020-07-06,09:11
 */
public class Impl extends AbstractClassBeExtends {
    /**
     * 要求必须覆写的抽象方法
     */
    @Override
    public String abstractMethod() {
        return "Impl类实现覆写abstractMethod";
    }

    /**
     * 可选覆写的父类方法
     */
    @Override
    public void publicMethod() {
        System.out.println("Impl类实现覆写publicMethod");
    }
}

【子类二 AnotherImpl 】

/**
 * Author:FangKunSen
 * Time:2020-07-06,09:45
 */
public class AnotherImpl extends AbstractClassBeExtends {
    @Override
    public String abstractMethod() {
        return "AnotherImpl类实现覆写abstractMethod";
    }

    public String privateMethod(){
        return "私有方法测试向下转型";
    }
}

我们用父类作为一个通用方法的入参：

    public void AbstractTestParam(@NotNull AbstractClassBeExtends abstractClassBeExtends){
        System.out.println(abstractClassBeExtends.abstractMethod());
        //如果传入的为子类
        if(abstractClassBeExtends instanceof Impl){
            abstractClassBeExtends.publicMethod();
            abstractClassBeExtends.readAbstractMethod();
        }
        if(abstractClassBeExtends instanceof AnotherImpl){
            abstractClassBeExtends.publicMethod();
            abstractClassBeExtends.readAbstractMethod();
        }
    }

此时，我们在调用的时候，用子类去作为入参调通用方法，利用debugger或者log可以看到正常调用进入覆写的方法：

		AbstractTestParam(new Impl());
        AbstractTestParam(new AnotherImpl());

向上/向下转型：

//以抽象父类定义一个实现子类，该过程称为向上转型
        log.info("以抽象父类定义一个实现子类，该过程称为向上转型");
        AbstractClassBeExtends me = new AnotherImpl();
        me.readAbstractMethod();//此时抽象方法会被子类必须地覆写
        //向下转型（半强转），可以正常读取子类内的方法
        log.info("向下转型（半强转），可以正常读取子类内的方法");
        AnotherImpl another = (AnotherImpl) me;
        log.info(another.privateMethod());

以抽象父类定义一个实现子类，该过程称为向上转型，此时调用父类内的抽象方法会被子类（必须地覆写父类的抽象方法）的方法执行。并且该变量me可以被向下转型为子类，且调用子类的方法。