2021-07-22

java 多态与继承

继承

class 父类 {
}
 
class 子类 extends 父类 {
}

关键字：extend,implements, super,this,final

implements
implements 相当于多继承（一个子类有多个父类）

public interface if1 {
    public void method1();
}
 
public interface if2 {
    public void method2();
}
 
public class if3 implements if1,if2 {
}

super：引用当前父类成员
this：引用当前类
final：定义为不可继承的

特性

1.子类不继承父类的private属性和方法
2.子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表
3.如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

多态

向上转型：不需要面对子类类型

父类类型 变量名=new 子类类型()

向下转型：当要使用子类特有功能时。

子类类型 变量名=（子类类型） 父类类型的变量；
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法

    Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat,eat 为animal的属性
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work，work为cat的属性
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

其中 abstract 表示抽象类： (public) abstrat class xx{}

1. 它没有自己的主体（没有{}包起来的业务逻辑），跟接口中的方法有点类似。所以我们没法直接调用抽象方法
2. 抽象方法不能用private修饰，因为抽象方法必须被子类实现（覆写），而private权限对于子类来说是不能访问的，所以就会产生矛盾
3. 抽象方法也不能用static修饰，试想一下，如果用static修饰了，那么我们可以直接通过类名调用，而抽象方法压根就没有主体，没有任何业务逻辑，这样就毫无意义了。
4. 抽象类与接口（interface）有很大的不同之处，接口中不能有实例方法去实现业务逻辑，而抽象类中可以有实例方法，并实现业务逻辑，比如我们可以在抽象类中创建和销毁一个线程池。
5. 抽象类不能使用final关键字修饰，因为final修饰的类是无法被继承，而对于抽象类来说就是需要通过继承去实现抽象方法，这又会产生矛盾.