JAVA面向对象 - 多态

所谓多态，就是指一个引用(类型)在不同情况下的多种状态。你也可以这样理解，多态是指通过指向父类的指针，来调用在不同子类中实现的方法。比如：Animal animal = new Pig();
Animal a = new new Rabbit(); 。多态的好处提高了代码的扩展性，前期定义的代码可以使用后期的内容。

//原先代码
abstract class Animal
{
    abstract void eat();
}

class Dog extends Animal
{
    void eat()
    {
        System.out.println("啃骨头");
    }
    void lookHome()
    {
        System.out.println("看家");
    }
}

class Cat extends Animal
{
    void eat()
    {
        System.out.println("吃鱼");
    }
    void CatchMouse()
    {
        System.out.println("抓鱼");
    }
}

class Dome
{
    public static void main(String[] args)
    {
        Dog dog = new Dog();
        method(dog);
        Cat cat = new Cat();
        method(cat);
    }
    
    public static void method(Cat cat)
    {
        cat.eat();
    }
    public static void method(Dog dog)
    {
        dog.eat();
    }
}

//修改后的代码
abstract class Animal
{
    abstract void eat();
}

class Dog extends Animal
{
    void eat()
    {
        System.out.println("啃骨头");
    }
    void lookHome()
    {
        System.out.println("看家");
    }
}

class Cat extends Animal
{
    void eat()
    {
        System.out.println("吃鱼");
    }
    void CatchMouse()
    {
        System.out.println("抓鱼");
    }
}

class Dome
{
    public static void main(String[] args)
    {
        Animal animal = new Cat();
        Animal a = new dog();
        method(animal);
        method(a);
        
    }
    
    public static void method(Animal a)
    {
        a.eat();
    }
}

通过上面的例子了解更多的多态的弊端：前期定义的内容不能使用（调用）后期子类的特有内容。
多态的前提：1.必须有关系，继承，实现；2.要有覆盖；

像上面的子类特有方法lookHome()与CatchMouse()在Animal animal = new Cat();与Animal a = new dog();就不能使用。

 

类型转换

     注意：对于转型，自始至终都是子类对象在做着类型的变化

Animal a = new Cat();//自动类型提升，猫对象提升了动物类型
                     //作用就是限制对特有功能的访问
                     //专业讲：向上转型

Cat c = (Cat)a;
c.eat();
c.catchmouse();
//如果还想用具体动物猫的特有功能
//你可以将该对象进行向下转型
//向下转型的目的是为了使用子类中的特有方法。

成员变量

　　编译时：参考引用类型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
　　运行时： 参考引用类型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
　　简单说：编译和运行都参考等号的左边。

class Father
{
    int num = 3;
}
class Son extends Father
{
    int num = 4;
}

class Dome
{
    public static void main(String[] args)
    {
        Father father = new Father();
        System.out.println(father.num);
        //这里输出3
    }
}

成员函数(非静态)
　　编译时:参考引用类型变量所属的类中的是否有调用的函数，没有，编译失败
　　运行时:参考引用类型变量所属的类中的是否有调用的函数
　　简单说:编译看左边，运行看右边。

class Father
{
    void show()
    {
        System.out.println("Father show");
    }
}
class Son extends Fahter
{
    void show()
    {
       System.out.println("Son show");
    }
}

class Dome 
{
    public static void main(String[] args)
    {
         Father father = new Son();
         father.show();//输出Son show
    }
}

上面这个程序会输出“Son show”,因为子类的方法覆盖了父类的方法，要是父类的show方法不存在，则会编译失败。

静态函数
　　编译时:参考引用类型变量所属的类中的是否有调用静态方法
　　运行时:参考引用类型变量所属的类中的是否有调用静态方法
　　简单说：编译和运行都看左边
　　其实静态方法是不需要对象的，直接用类名调用即可。

class Father
{
    static void show()
    {
        System.out.println("Father show");
    }
}

class Son
{
    static void show()
    {
        System.out.println("Son show");
    }
}

class Dome
{
    public static void main(String[] args)
    {
        Father father = new Son();
        Son son = new Son();
        father.show();
        //输出Father show
        son.show();
        //输出Son show
    }
}

 

实例

package com.beekc.www;

public class Beekc {
    public static void main(String[] args) {
        Master master = new Master();
        master.food(new Dog(),new Bone());
        master.food(new Cat(),new Fish());
    }
}

//主人
class Master
{
    public void food(Animal an, Food f)
    {
        an.cry();
        f.showName();
    }
}

//食物
class Food
{
    public String Name;
    public void showName()
    {

    }
}

class Fish extends Food
{
    public void showName()
    {
        System.out.println("爱吃鱼");
    }
}

class Bone extends Food
{
    public void showName()
    {
        System.out.println("爱吃骨头");
    }
}

//动物
class Animal
{
    private int age;
    private String name;
    public void cry()
    {
        System.out.println("我是动物,系统不知道怎么叫！");
    }
}

class Cat extends Animal
{
    public void cry()
    {
        System.out.println("猫猫，喵喵叫~");
    }
}

class Dog extends Animal
{
    public void cry()
    {
        System.out.println("狗狗，汪汪叫~");
    }
}

 

运行结果