面对对象编程3：多态

认识多态之前，先看一下什么是向上转型：父类引用   引用子类对象

看代码：有注释

class Animal {
    public String name;
    private int age;
    public Animal(String name){
        this.name = name;
    }
    public void eat() {
        System.out.println(this.name+"eat()");
    }
}
class Cat extends Animal{
     public Cat(String name){
        super(name);  //显示调用父类的构造方法
    }
     public void eat() {
        System.out.println(this.name+"cat::eat()");
    }

    public void func() {
        System.out.println(super.name);
        super.eat();
    }
}
public class TestDeom {
    public static void main(String[] args) {
        /*Animal animal = new Animal("小甜甜"); //父类引用父类对象
        Cat cat = new Cat("咪咪");*/            //子类引用引用自己的对象
        Animal animal = new Cat("咪咪"); //父类引用引用子类对象   这就是向上转型，把子类的对象给父类
       
    }
}

public static void main(String[] args) {
        Animal animal = new Animal("小甜甜"); //父类引用父类对象
        animal.eat();
        Cat cat = new Cat("咪咪");           //子类引用引用自己的对象
        cat.eat();
        Animal animal2 = new Cat("咪咪");    //父类引用引用子类对象   这就是向上转型，把子类的对象给父类
        animal2.eat();
    }

Animal animal2 = new Cat("咪咪");     

Animal里面有eat，Cat里面也有eat，所以Animal可以调用Cat的eat。

此时发生了动态绑定： 

一、当前的方法，需要重写。

重写：1、方法名称相同 2、参数列表相同  3、返回值相同  4、父类的访问修饰限定符不能是私有的（private) 5、子类的要大于等于父类的（public>protected>默认>private)  6、static关键字

重载：1、方法名称相同 2、参数列表不同  3、返回值不做要求

向上转型一般有3种：1、直接赋值 （就如同上面的代码）

2、方法的传参 

public static void func1(Animal animal) {

    }
public static void main2(String[] args) {
        Dog dog = new Dog("旺财");
        func1(dog);

    }

3、方法的返回值

public static Animal func2(){
        Dog dog = new Dog("旺财");
        return dog;
    }

 

到底什么是动态绑定呢？

父类引用取引用子类对象，同时 通过父类引用 去调用父类和子类的同名覆盖（重写）方法，此时运行会调用子类的方法。

Animal animal2 = new Cat("咪咪");    
        animal2.eat();

 

额外讲一下反汇编：

做下角点击Terminal    

cd src           cd com        cd extendseg      

  javac -enconding utf-8 TestDemo.java            javap -c TestDemo

重写的快捷键自动生成：Alt + Insert              Override Methods(快捷键为Ctrl+O)     回车    

向下转型：把父类给子类

public static void main(String[] args) {
        Animal animal2 = new Cat("mimi");
        animal2.eat();
        func1(animal2);
        Cat cat =(Cat) animal2;       //向下转型
        cat.func();
    }

向下转型发生的前提是已经发生过向上转型，向下转型不安全，有时会发生类型转换异常。一般写程序不会写向下转型

理解多态：
 

class Shape { 
 public void draw() { 
 } 
} 
class Cycle extends Shape { 
 @Override 
 public void draw() { 
 System.out.println("○"); 
 } 
} 
class Rect extends Shape { 
 @Override 
 public void draw() { 
 System.out.println("□"); 
 } 
} 
class Flower extends Shape { 
 @Override 
 public void draw() { 
 System.out.println("♣"); 
 } 
} 
//分割线// 
public class Test { 
 public static void main(String[] args) { 
 Shape shape1 = new Flower(); 
 Shape shape2 = new Cycle(); 
 Shape shape3 = new Rect(); 
 drawMap(shape1); 
 drawMap(shape2); 
 drawMap(shape3); 
 } 
 // 打印单个图形
 public static void drawShape(Shape shape) { 
 shape.draw(); 
 } 
}