继承和多态

一.继承

1.语法

子类继承父类可访问的成员变量和成员方法，同时可以修改父类的成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。
在Java中如果要表示类之间的继承关系，需要借助extends关键字，如下：

修饰符 class 子类 extends 父类{
}

例1.

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name + "吃食物");
    }
}
class Dog extends Animal{
    public void bark(){
        System.out.println(this.name + "汪汪");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog d= new Dog();//
        System.out.println(d.name);//继承了Animal父类的name
        System.out.println(d.age);//继承了Animal父类的age
        d.eat();//继承了Animal的方法
        d.bark();
    }
}

2.父类成员的访问

如若子类想要访问父类的成员（方法），需要关键字super
例2：

class A{
    int a = 10;
    int b = 20;
}
class B extends A{
    int a = 30;
    public void fun(){
        System.out.println(a);
        System.out.println(super.a);
    }

}
public class Test2 {
    public static void main(String[] args) {
     B b = new B();
     b.fun() ;
    }
}

在例2的子类中，先访问自己的，如若没有访问父类的，若相同，则需要super.成员（方法）来访问父类。
总结：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找
super的构造方法
例3：

class A{
    int a ;
    double b ;

    public A(int a, double b) {
        this.a = a;
        this.b = b;
    }
}
class B extends A{
    int c;

    public B(int a, double b, int c) {
        super(a, b);
        this.c = c;
    }
    public void  Mprint(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}
public class Test2 {
    public static void main(String[] args) {
        B b = new B(1 ,2.0,3);
        b.Mprint();
    }
}

构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，满足先有父再有子。

3.继承方式

在Java中只支持以三种继承方式（比较简单，不作详细介绍）：

• 单继承
• 多层继承
• 不同类继承同一个类

二.多态

1.实现多态

实现条件：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
   如例4：

class Animal2{
    private String name;
    private int age;

    public Animal2(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"吃食物");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
class Cat extends Animal2{

    public Cat(String name, int age) {
        super(name, age);
    }

    public void eat(){
        System.out.println(super.getAge() + "岁的" + super.getName() + "吃猫粮");
    }
}
class Dog1 extends Animal2{
    public Dog1(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(super.getAge() + "岁的" + super.getName() + "吃狗粮");
    }
}


public class Test3 {
    public  static void punc(Animal2 animal){//向上转型
        animal.eat();
    }

    public static void main(String[] args) {
       Dog1 d = new Dog1("大飞",4);
       Cat c = new Cat("白糖",3);
       punc(d);
       punc(c);
    }
}

例4实现调用同一个方法，所实现的效果不同，这就是多态。

2.向上转型

向上转型：创建一个子类对象，将其当成父类对象来使用。
语法：父类类型 对象名 = new 子类类型()（直接赋值）。
分为三种：

1. 直接赋值
2. 方法传参
3. 方法返回

1.方法传参：形参为父类型引用，可以接收任意子类的对象
2.方法返回：返回任意子类对象
如例4：

class Animal{
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public void eat(){
        System.out.println(this.getName() + "吃食物");
    }
    public void barks(){
        System.out.println(this.getName()+"叫");
    }
 }
 class Dog extends Animal{
     public Dog(String name, int age) {
         super(name, age);
     }
     public void eat(){
         System.out.println(this.getName() + "吃狗粮");
     }


     public void barks() {
         System.out.println(this.getName()+"汪汪");
     }

 }
public class Test1 {
//方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void func(Animal a){
        a.eat();
    }
//返回值：返回任意子类对象
    public static Animal func1(int a){
        if(a == 1){
            return new Dog("白糖",3);
        }else{
            return null;
        }
    }
    public static void main(String[] args) {
     Dog d = new Dog("大飞",4);
     func(d);
     Animal a = func1(1);
     a.barks();
    }
}

向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法

3. 方法的重写

规则：

• 父类被static、private，final修饰的方法、构造方法都不能被重写
• 访问权限不能比父类中被重写的方法的访问权限更低.
• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致