Java的多态

 

 

　　多态,即对象的多种形态
　　1.引用多态
　　　　父类引用可以指向本类的对象
　　　　父类引用可以指向其子类的对象
　　2.方法多态
　　　　创建本类对象是，调用的方法为本类的方法
　　　　创建子类对象时，父类的引用指向子类对象，调用的方法为子类重写的方法，若没有重写则调用继承的方法
　　　要点:Java的函数是会默认进行动态绑定,而C++必须将相应函数显示声明为虚函数
　　　PS:所谓动态绑定是指当基类指针或引用指向派生类对象时，如果子类重写了调用的方法，则调用的是重写后的方法，若子类没有重写该方法，则调用的是从基类继承来的方法

　　注意：若子类在继承的基础上添加了父类中没有的方法(即使是以重载的方式实现也不行,因为父类中没有重载这个函数)，此时是无法通过父类引用来实现调用的(因为父类压根没有这个方法)

 

参考代码：

 

父类Animal的内容：

package com.hao;

public class Animal {
    String name = "";
    int age = 0;
    
    /* （非 Javadoc）
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    /* （非 Javadoc）
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Animal other = (Animal) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    Animal(){}

    /**
     * @param name 动物的姓名
     * @param age 动物的年龄
     */
    public Animal(String name, int age) {
        super(); //其super类其实为Object类
        this.name = name;
        this.age = age;
    }
    
    public void eat(){
        System.out.println("Animal can eat!");
    }
    
    public void information(){
        System.out.printf("%s is a Animal, it's %d years old!\n", name, age);
    }
    
    

}//Animal

 

子类Dog的内容:

package com.hao;

public class Dog extends Animal {

    /**
     * 默认构造函数
     */
    public Dog() {
        super();
        // TODO 自动生成的构造函数存根
    }

    /**
     * @function 带参构造函数
     * @param name 狗的姓名
     * @param age 狗的年龄
     */
    public Dog(String name, int age) {
        super(name, age);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.hao.Animal#eat()
     */
    @Override
    public void eat() {
        // TODO 自动生成的方法存根
        //super.eat();
        System.out.println("Dog can eat!");
    }
    

    /* （非 Javadoc）
     * @see com.hao.Animal#information()
     */
    @Override
    public void information() {
        // TODO 自动生成的方法存根
        //super.information();
        System.out.printf("%s is a Dog, it's %d years old!\n", name, age);
    }

    
    
    


    
}

 

子类Cat的内容:

package com.hao;

public class Cat extends Animal {

    /**
     * 默认构造函数
     */
    public Cat() {
        super();
        // TODO 自动生成的构造函数存根
    }

    /**
     * @param name 猫的姓名
     * @param age 猫的年龄
     */
    public Cat(String name, int age) {
        super(name, age);
        // TODO 自动生成的构造函数存根
    }
    
}

 

包含主函数的Main类内容:

package com.hao;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Animal A = new Animal("A", 10);
        Animal B = new Dog("B", 20);
        Animal C = new Cat("C", 30);
        
        //动态绑定,如果子类重写了调用的方法,则调用的是重写后的方法,若没有重写,则调用的是从父类继承来的方法的
        A.information(); //指向本类对象，调用的父类的方法
        B.information(); //指向子类对象，且Dog重写了该方法，调用重写后的方法
        C.information(); //指向子类对象,但Cat类没有重写该方法，调用是Animal类中继承类的方法
        
    }

}