java面向对象之---多态

package com.b_duotai;

/**
 * 测试多态
 * 第一次测试
 */

class Person{
    public void fun1()
    {
        System.out.println("fun1--来自父类");
    }
    public void fun2()
    {
        System.out.println("fun2--来自父类");
    }
}

class Son extends Person{
    /**
     * 定义一个和父类相同的方法，
     *  达到了重写父类方法的目的
     */
    public void fun1(){
        System.out.println("fun1--来自子类");
    }

    public void fun3()
    {
        System.out.println("fun3--来自子类");
    }
}
public class test1 {
    public static void main(String[] args) {
        /**
         * 等号左边创建了一个Person对象
         * 但是右边接收了一个没有名字的儿子的对象
         * 因此P既可以拥有自己的方法
         * 也可以拥有子类的方法，前提是子类的方法
         * 进行了重写
         * 比如，P就不可以调用fun3
         */
        Person p = new Son();
        p.fun1();
        p.fun2();
    }
}

运行结果：

1. 多态的思想

多态分为方法的多态和对象的多态。

重载就是方法的多态的一种体现，两个方法，方法名相同，返回值相同，但是参数列表不同，就是多态的一种体现。

对象的多态，即父类对象的引用需要通过子类对象实例化来实现，此时父类的引用再去调用方法时，如果子类对父类的方法进行了重写，则调用子类的方法，反之调用父类自己的方法。

2. 具体例子

2.1 方法的多态：

package c_duotai;

public class Demo1 {
    public static void main(String[] args) {
        int i = 2;
        int j = 3;
        Function function = new Function();
        /**
         * 1.虽然方法名称相同，但是由于传进去的参数不同，在运行的时候就会调用不同
         * 的方法
         * 2.不在同一个类里，你需要new一个对象，然后让该类的对象调用该类的方法。
         */
        function.sum(i);
        function.sum(4,6);
    }
    static class Function
    {
        //两个方法，只有参数不同
        void sum(int i){
            System.out.println("两数的和为：" + i);
        }
        void sum(int i,int j)
        {
            System.out.println("两数的和为：" + (i+j));
        }
    }
}

2.2 对象的多态

package c_duotai;

/**
 * 对象的多态体现在
 * 1. 父类引用指向子类
 * 2. 如果子类对父类的方法进行了重写，则会调用子类的方法
 *
 */
class Animal{
    public void move()
    {
        System.out.println("动物移动");
    }
}
class Fish extends Animal{
    public void move()
    {
        System.out.println("鱼儿游");
    }
}
class Bird extends Animal{
    public void move()
    {
        System.out.println("鸟儿飞");
    }
}
class Horse extends Animal{
    public void move()
    {
        System.out.println("马儿跑");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Animal a;
        //父类引用指向子类new出来的对象
        a = new Fish();
        a.move();
        a = new Bird();
        a.move();
        a = new Horse();
        a.move();
    }
}

 运行结果：

程序分析：父类里面的move（）方法在子类里面全部进行了重写，在main函数里，父类的引用来自子类new的对象，因此父类调用move（）方法的时候，等于调用了子类重写的方法。如果子类不进行重写，则无法调用。如下所示：

注释掉Fish类里面的方法，即使接收了也无法调用。

注释掉

运行：

3. 总结

由上述例子可以看出，父类依据传入不同的子类对象，调用对应的子类的方法。如果子类没有对这个方法进行重写，父类就只能调用自己的；同理，子类自己独有的方法，父类也不能调用。多态是父类调用不同的子类的方法，继承是子类调用父类的方法。