接口，继承，重写，重载，多态

继承

java支持的是一种单继承，不支持多继承，可以多重继承。

只有接口可以多继承接口

public interface InterfaceTest extends InterfaceB ,InterfaceA {
}

继承的特点

1. 子类具有父类的非private（私有）的属性和方法
2. 子类可以拥有自己的属性和方法，，即子类可以对父类进行扩展
3. 子类可以用自己的方式实现父类的方法, 即为重写（@Override）

如果一个类用final修饰，那么他不能被继承，如果类的方法被final修饰，那么不能被重写。
子类中调用父类的被重写方法时，使用 super 关键字。

重写（override）规则

• 参数列表和返回类型必须完全与重写方法相同
• 访问权限不能比父类中被重写的方法访问权限更低，子类的访问权限要和父类相同或更高
• 声明为final的方法不能被重写
• 声明为static的方法不能被重写，但是能够被再次声明

重载（OverLoad）

一个类中，方法名相同，形参列表不同为重载。

• 重载只要求形参列表不同，方法返回值可相同可不同
• 被重载的方法可以改变访问修饰符
• 被重载的方法可以声明新的或更广的检查异常

重写和重载区别比较

区别	重写(Override)	重载（OverLoad）
参数列表	必须和父类相同	一定不相同（相同就不叫重载了）
返回类型	必须和父类相同	没有限制
异常	可以减少或删除，一定不能抛出新的或者更广的异常	没有限制
访问	不能做更严格的限制（可以降低限制）	没有限制

总结，重载只要求形参列表不相同，其他一律不做限制。

多态

编译时多态：主要是方法的重载，通过参数列表的不同来区分不同的方法。

运行时多态：一般是指在执行期间（非编译期间）判断引用对象的实际类型，根据实际类型判断并调用相应的属性和方法。主要用于继承父类和实现接口时，父类引用指向子类对象。

多态的实现

Java实现多态有三个必要条件：继承、重写、向上转型（父类持有子类的应用）。

看一组例子：

父类定义如下：

public class ParentClass {
    public void fun1(){
        System.out.println("父类 的Fun1...");
        fun2();
    }
    public void fun2(){
        System.out.println("父类 的Fun2...");
    }
}

子类定义如下：

public class ChildClass extends ParentClass {
   //这里不是重写，形参列表和父类不同，这个方法只属于子类
   public void fun1(String a) {
        System.out.println("子类 的 Fun1...");
        fun2();
    }

    @Override
    public void fun2() {
        System.out.println("子类 的Fun2...");
    }
}

测试：

public class Main {
    public static void main(String[] args) {
        //父类持有子类的引用
        ParentClass a = new ChildClass();
        a.fun1();
    }
}

输出：

父类 的Fun1...
子类 的Fun2...

由于子类没有重写父类的fun1, 所以fun1不具多态性，直接执行父类fun1，打印父类… ， 父类fun1中虽然写的调用父类的fun2, 但是子类重写了fun2,那么会执行子类的fun2，打印出子类…

如果想要调用子类的fun1，那就只能是子类持有子类的引用才能调用，向上转型的给父类，父类是无法调用这个方法的。

只能通过：

 ChildClass b = new ChildClass();
        b.fun1("fde");

多态的经典实例

public class A {
    public String show(D obj) {
        return ("A and D");
    }
 
    public String show(A obj) {
        return ("A and A");
    }
}
 
public class B extends A{
//这个方法属于B自己的方法，不是重写的方法，因为其参数列表和父类不同
    public String show(B obj){
        return ("B and B");
    }
    @Override
    public String show(A obj){
        return ("B and A");
    }
}
 
public class C extends B{
 
}
 
public class D extends B{
 
}
 
public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b  = new B();
        C c  = new C();
        D d  = new D();
 
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}
 
output-------------------------------------------------
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

意思就是，父类p持有子类c的应用，使用父类取调用方法show时，会根据入参O，首先在子类中查看是否重写了这个方法，重写了那就调用子类方法，没有就调父类的方法，如果入参O在父类和子类都没找到完全匹配的方法，那就会对参会O做向上转型，然后再次检查子类是否有重写的方法，如果没有，再执行父类对应的方法。

依据这原则，我们分析第四条：

A a2 = new B();
System.out.println(“4–” + a2.show(b));
4–B and A

• 1 首先a2是子类对象A，持有了子类对象B引用
• 2 a2.show(b)。 那么先在子类中查找复写的方法：

 @Override
    public String show(A obj){
        return ("B and A");
    }

这个方法入参是A，但我们传入是B, 那么不匹配。

• 3 在子类A中找，也找不到匹配的， 这是只能把入参B向上转型为 A。然后继续在子类找复写的方法，这时候就是匹配的了。最终打印出 B
  and A

参考自博客 https://blog.youkuaiyun.com/yz_cfm/article/details/85262909

接口和抽象类的区别

1 接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法
2 接口中的实例变量默认是final类型的，而抽象类中则不一定。不能有变量，接口中的常量必须在定义时指定初始值。
3 一个类可以实现多个接口，但最多只能实现一个抽象类
4 一个类实现接口的话要实现接口的所有方法，而抽象类不一定
5 接口不能有构造方法，类方法（用 static 修饰的方法）。

什么情况一定要用接口？？？
参考自博客 https://www.cnblogs.com/3020815dzq/p/8509137.html