JAVA中的继承与多态

1.继承

当我们创建类时，有一些类会存在重复的成员变量或方法，此时为了减少重复代码的编写，我们可以使用继承。被继承的类称为父类，去继承的类称为子类，使用extends关键字进行。

public class a {
    int a = 10;
    int b = 20;
}

public class b extends a {
    int c = 2;
}

当子类继承父类之后，可以通过实例化子类，直接使用父类里的成员变量和成员方法。 

1.1.super的使用

当子类与父类存在相同的成员变量时，优先使用子类的成员变量，若想使用父类的成员变量，需要使用super关键字。

public class a {
    int a = 10;
    int b = 20;
}

public class b extends a {
    int c = 2;
    int a = 1;
    System.out.println(super.a);
}

需要注意的是，当父类存在构造方法时，我们使用子类时，要帮助父类使用构造方法，此时，需要使用super()关键字。 

public class a {
    int a = 10;
    int b = 20;
    public a() {
        super(2);
        this.a = 2;
        this.b = 4;
    }
}

public class b extends a {
    int c = 2;
    public b(int c) {
        this.c = c;
    }
    System.out.println(super.a);
}

与之前我们写的普通类的构造方法一样，当我们不写构造方法时，编译器会为我们提供一个默认的构造方法存在于子类之中。

public c() {
    super();
}

super()与this()一样，需要存在于构造方法的第一行，因此，当我们使用super()时，就不能再使用this()了。

1.2.代码的执行顺序

与普通的类一样，父类和子类中也会存在静态代码块，实例代码块，构造方法。而它们的执行顺序是先使用父类的静态代码块，再使用子类的静态代码块，然后使用父类的实例代码块和构造方法，最后使用子类的实例代码块和构造方法。

1.3.JAVA中继承的特性

JAVA只支持单继承，不支持多继承。

1.4.final的使用

当我们想定义一个常量时，可以使用final关键字来修饰变量。

final int a = 10;

而当我们定义一个类不想它被继承时，也可以使用final来修饰它。

public final class Dog {
}

2.多态 

多态通俗来说就是多种状态，即完成同一个行为，不同的对象完成该行为的状态不同。而实现多态需要我们完成向上转型和方法的重写。

2.1.向上转型 

当类与类之间存在继承时，向上转型和向下转型也就由此产生了。例如，当我们实例化父类对象时，引用了子类时，就完成了向上转型。而将这一步骤往反方向进行，便执行了向下转型。完成向上转型有三种方法，分别为直接赋值，方法的传参，返回值。

直接赋值

Animal animal = new Dog();

方法的传参 

public static void func(Animal animal) {
    
}
Dog dog = new Dog();
func(dog);

返回值 

public static Animal func() {
    Dog dog = new Dog();
    return dog;
}
Animal animal = func();

需要注意的是，向上转型之后，实例化的对象只能调用父类的方法，不能调用子类特有的方法。

2.2.重写 

当子类和父类的方法，达成方法名相同，参数列表相同，返回值相同这三个条件时，就构成了重写。

2.3.动态绑定

 当运行代码的时候，通过父类引用，调用了父类和子类重写的那个方法，结果实际调用了子类的方法，此时，我们把这个情况叫做动态绑定。由于子类通常是有多个的，从某种意义上来说，我们通过动态绑定实现了父类的多种形态。

2.4.重写的注意事项 

1.被重写的方法不能是一个静态方法。

2.被final修饰的方法，是不能被重写的。

3.如果子类重写父类的方法，子类的权限要大于等于父类的权限。

4.被private修饰的方法是不能被重写的。

3.其他

向下转型是要进行强制类型转换。