1. 接口和继承

public interface In {
    void doSomething();
}

父类：

public class T{
    private In in;

    public void setIn(In in){
        this.in = in;
    }

    // 需要子类重写的普通方法
    protected void layoutChildren() {
    }

    public void Hello(){
    	// 用子类对象，会调用子类实现方法
        layoutChildren();
        // 调用接口方法
        in.doSomething();
    }

}

子类：

public class CT extends T implements In {

    @Override
    protected void layoutChildren() {
        System.out.println("HAHAHA");
    }

    @Override
    public void doSomething() {
        System.out.println("Do Something.");
    }

    @Test
    public void getT(){
        setIn(this);
        Hello();
    }
}

结果：

2. 即常规做法，讲子类对象直接传进去，但没人这么写代码；
3. 将父类需要调用的方法，在子类中写为public static，但更加离谱，因为父类不关心子类，不应该知道子类的类名，更不应该知道子类的方法。
4. 既然可以父类通过类名来调用静态，那么也就可以使用反射的方式。但还是很离谱，原因同上。

所以一般而言使用为上面的两种方式，注意到在父类中的layoutChildren方法我们没有实现，可以申明为抽象方法，即：

public abstract class T{
    private In in;

    public void setIn(In in){
        this.in = in;
    }

    // 需要子类重写
    protected abstract void layoutChildren();

    public void Hello(){
        layoutChildren();
        in.doSomething();
    }
}

那么，我们父类在调用layoutChildren方法的时候，就是调用子类的实现，但具体是哪个子类的实现，其实父类并不关心。接口也是如此的思想。也就是：

• 行为由父类/接口控制，子类实现。

当然上面代码的接口方式我感觉写的不好，感觉可以尝试使用Spring的DI方式。

我们先进行了解Java的动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型进行绑定
2. 当调用对象属性的时候，没有动态绑定机制，在哪里声明就在哪里使用。属性没有动态绑定机制

现在定义三个类 Person作为父类 Student类和Teacher类是子类 两个子类都有自己特有的属性和方法 并且重写父类say()方法

• 分别是 Person类

package www.polyarr;
//创建Person类
public class Person {
    private String name;//设置两个成员变量 name 和 age 并增加get set方法
    private int age;
    public Person(String name , int age) {// 类构造器
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String say() {//say方法 返回name和age值
        return "name"+getName()+"age"+getAge();
    }
    
} 

• Student类

package www.polyarr;

public class Student extends Person{//继承Person类
    private double scores;//定义成员变量 scores（成绩）
    public Student(String name, int age, double scores) {//继承父类构造器 并加入自己的变量
        super(name, age);
        this.scores=scores;
        // TODO Auto-generated constructor stub
    }
    public double getScores() {
        return scores;
    }
    public void setScores(double scores) {
        this.scores = scores;
    }
    public String say() {//重写父类say（）方法
        return "学生"+super.say()+"scores="+getScores();
    }
    public void student() {//写入student方法 
        System.out.println("学生"+getName()+"正在学习");
    }
}

• Teacher类

package www.polyarr;

public class Teacher extends Person{//继承Person类
    private int salary;//定义成员变量 salary（薪水）
    public Teacher(String name, int age,int salary) {//继承父类构造器 并加入自己的变量
        super(name, age);
        this.salary=salary;
        // TODO Auto-generated constructor stub
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    public String say() {//重写父类say（）方法
        return "老师"+super.say()+"salary="+getSalary();
    }
    public void teacher() {//写入teacher方法 
        System.out.println("老师"+getName()+"正在教书");
    }
}

• 在主类中定义一个Person类的数组 存入一个Person类对象 两个Student类对象 和两个Teacher类对象循环调用say()方法 在运行是调用运行类型的方法 依次输出信息

name张三age16
学生name小明age18score=100.0
学生name小强age19score=80.0
老师name张兰age28salary=6000
老师name王明age32salary=8000

• 此时 如果我想调用两个子类特有的方法 是无法被调用到的 此时我们使用if判断 使用instanceof 比较当前类是否等于Students类
• 如果等于的话 将当前类向下转型并调用它特有的方法 Teahcer类同理

package www.polyarr;

public class Polyarr {
    public  static void main(String[]arge) {
        Person person[]=new Person[5];//定义一个Person数组  进行赋值
        person[0]=new Person("张三",16);
        person[1]=new Student("小明",18,100);
        person[2]=new Student("小强",19,80);
        person[3]=new Teacher("张兰",28,6000);
        person[4]=new Teacher("王明",32,8000);
        for (int i = 0; i < person.length; i++) {
            System.out.println(person[i].say());//循环输出say方法  此时输出的say（）方法是按照引用类型 就是进行new的实例化类型调用的
            if (person[i] instanceof Student) {//进行判断 是否为Student类
                ((Student)person[i]).student();//对Person数中的对象 进行向下转型 并调用student方法
            } else if(person[i] instanceof Teacher){//进行判断 是否为Teacher类
                ((Teacher)person[i]).teacher();//对Person数中的对象 进行向下转型 并调用teacher方法
            }else {
                System.out.println("类型不正确");
            }
        }
    }
}

• 最后输出

name张三age16
类型不正确
学生name小明age18score=100.0
学生小明正在学习
学生name小强age19score=80.0
学生小强正在学习
老师name张兰age28salary=6000
老师张兰正在教书
老师name王明age32salary=8000
老师王明正在教书