(JAVA)一个类没有直接实现接口，为什么可以这样为父接口实例化呢？

Question

@tcxu 你好，想跟你请教个问题：

package jiu;

interface A { // 定义一个接口
    String INFO = "Hello World .";

    void print(); // 抽象方法
}

interface B { // 定义一个接口
    public abstract void get();
}

abstract class C implements A, B { // 抽象类实现了A和B接口
    public abstract void fun(); // 抽象方法一共有三个
}

interface D extends A, B { // 同时继承两个接口
    public void printD();
}

class X extends C implements D { // 先继承后实现
    public void print() {
        System.out.println(INFO);
    }

    public void get() {
        System.out.println("你好！");
    }

    public void fun() {
        System.out.println("抽象类C实现接口A,B");
    }

    public void printD() {
        System.out.println("接口D继承两个接口A,B");
    }
}

public class AbstractInterfaces {
    public static void main(String args[]) {
        X x = new X(); // 实例化子类对象
        A a = x; // 为父接口实例化(引用接口指向实现类，多态)
        B b = x; // 为父接口实例化
        C c = x; // 为抽象类实例化(引用父类指向子类对象，多态)
        D d = x; // 父接口实现化
        a.print();
        b.get();
        c.fun();
        d.printD();
    }
}

类X没有直接实现接口A和B，为什么可以A a = x; （直接为父接口实例化）呢？这样却不报错，是什么原因呢？

Answer 1

1. 任意一个类 M  成功实现了某个接口 N1 或 N2，就可以将 接口 N1，或 接口N2  当成 类 M 的父类看待。进而，子类 M 的对象 m，自然也就是 N1 或 N2 类型的 实例 (或 引用 referene)。这叫向上转型 upcasting。比如，父类 Person 的子类 Student 的对象是 李明， 李明既是学生 Student 类型 (的引用)，也是 人 Person 类型 (的引用)。
2. 在 楼主的案例 里，类 C 要同时实现 接口 A 和 B，但 它不但未能完成要求定义的抽象方法的方法体，而且自身又添加了一个抽象方法。因此，类 C 要冠以 关键词 abstract。
3. 在 楼主的案例 里，接口 D 同时继承 接口 A 和 B。
4. 最后，在 楼主的案例 里，类 X 不但成功继承了 类 C， 同时还 实现了接口 D，也就是同时实现了接口 A 和 B。
5. 这样一来，在 楼主的案例 里，类 X 就可以看作是 接口 A、B、类 C、以及 D 的子类 (subclass/derived_class)，类 X 的对象/实体，自然也就可以当做是  接口 A、B、类 C、以及 D 的类型的引用：a、b、c、d ( 这种转变成为 向上转型 upcasting )。用这些引用，自然可以调用相关的方法。

    总之，就楼主的案例而言，虽然 类 class X 没有直接实现接口 interface A 和 interface B ，但是它成功继承了 实现 接口 interface A 和 interface B  的抽象类 abstract C。由此，类 class X 便是其父类 C，以及其父接口   interface A 和 interface B  的子类。于是，类 class X 的 实体/对象 x, 就可以向上转型为 其父类、父接口类型的引用， 即楼主所说的 "为父接口实例化"。     

参考：

在java 中，什么叫向上转型

Answer 2

你自己也说了，类X没有直接实现接口A和B，但是类X实现的接口D已经继承了接口A和B。

A a = x; 这一行，并没有发生实例化。实例化的含义是创建对象，这一行并没有创建对象。这一行实际做的是，让引用a指向引用x所指向的对象。对象并没有增加。

因为类X实现了接口D，而接口D已经继承了接口A和B，所以这一行不会报错。