继承与多态

public class Animal {
    public String name;
    public int age;

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

    public void  eat(){
        System.out.println(this.name+"正在吃饭");
    }

}

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

    public void meme(){
        System.out.println(this.name+"正在咪咪叫");
    }
}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark(){
        System.out.println(this.name+"正在汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
              Animal animal = new Animal("小白",2);
              animal.bark();
        }
}

通过父类引用，只能调用父类自己特有的成员，方法或成员变量

2.2.1 什么是向上转型

把子类的对象给到父类，这个过程称为向上转型

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄",2);
        Animal animal = dog;
    }

可以直接这样写

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog("大黄",2);
    }

因为Animal与Dog之间存在继承关系，所以可以这样赋值

这里表示animal这个引用指向了dog这个引用所指向的对象

这个过程中就把子类对象给到了父类类型的引用，这就是向上转型

2.2.1.1 常见的可以发生向上转型的三个时机：

1. 直接赋值

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog("大黄",2);
    }

2. 作为方法的参数，传参的时候向上转型

public class Main {
    public static void func1(Animal animal){

    }
    public static void main(String[] args) {
        Dog dog = new Dog("小黄",2);     
        func1(dog);     
    }

3. 作为方法的返回值时向上转型

public class Main {
    public static Animal func2(){
        Dog dog = new Dog("测试",10);
        return dog;
    }
    public static void main(String[] args) {
        Animal animal = new Dog("大黄",2);
        Animal animal1 = func2();
    }

public class Animal {
    public String name;
    public int age;

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


   void  eat(){
        System.out.println(this.name+"正在吃饭");
    }

}

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

    public void meme(){
        System.out.println(this.name+"正在咪咪叫");
    }
    @Override
    public void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

   @Override
    protected void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

也没有报错

  @Override
    private void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

报错了

public class Animal {
    public String name;
    public int age;

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


   private void  eat(){
        System.out.println(this.name+"正在吃饭");
    }

}

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

    public void meme(){
        System.out.println(this.name+"正在咪咪叫");
    }
    @Override
    private void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

public class Animal {
    public String name;
    public int age;

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


   public  static void  eat(){
        System.out.println("正在吃饭");
    }

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

    public void meme(){
        System.out.println(this.name+"正在咪咪叫");
    }
    @Override
    public private void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

public class Animal {
    public String name;
    public int age;

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


   public  final void  eat(){
        System.out.println(this.name + "正在吃饭");
    }

}

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

    public void meme(){
        System.out.println(this.name+"正在咪咪叫");
    }
    @Override
    public final void eat(){
        System.out.println(this.name+"正在吃猫粮");
    }
}

这里形式一致也报错

说明被private或static或final修饰的方法不可以被重写

那么还有没有其他情况呢？

 public Animal test(){
        return null;
    }

@Override
    public Cat test(){
        return null;
    }

并没有报错

这说明

实现重写的条件：

1. 最基本的返回值，参数列表，方法名必须一样

2.被重写的方法的访问限定修饰符在子类中要大于等于父类的访问限定修饰符

3.被private或static或final修饰的方法不可以被重写

4.被重写的方法返回值类型可以不同，但是必须是具有父子关系的（协变类型）

5.构造方法不能被重写

注：

认为所有类的父类都是Object

到这里就可以提到之前笔者类与对象中重写toString

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog("大黄",2);
        System.out.println(dog);
    }
}

2.3.1 重载与重写的区别

2.3.2 重写的设计原则

例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示

的时候，不仅仅可以显示号码，还可以显示头像，地区等。在这个过程当中，我们不应该在原来老

的 类上进行修改，因为原来的 类，可能还在有用户使用 ，正确做法是： 新建一个新手机的类，对来

电 显示这个方法重写就好了，这样就达到了我 们当今的需求了 。

2.3.3 动态绑定与静态绑定

静态绑定 ：也称为前期绑定 ( 早绑定 ) ，即在编译时，根据用户所传递实参类型就确定了具体调用那

个方法。典型代表函数重载。

动态绑定 ：也称为后期绑定 ( 晚绑定 ) ，即在编译时，不能确定方法的行为，需要等到程序运行时，

才能够确定具体调用那个类的方法。

这就是静态绑定

public class Main {

   public static void main(String[] args) {
        Animal animal = new Dog("大黄",2);
        animal.eat();
    }
}