Java的三大特性之多态__渣渣的Java学习之路

多态

指把类中具有相似功能的不同方法使用同一个方法名来实现，从而可以使用相同的方式来调用这些具有不同功能的同名方法

多态的几种表现形式：

• 方法重载与多态

• 继承、重写与父类指向子类对象实现多态

• 接口指向实现类对象

1.方法重载与多态

下面是一个例子，child给animal喂食

public class test {
    public static void main(String[] args) {
        Child child = new Child();
        Dog dog = new Dog();
        Cat cat = new Cat();
        Pig pig = new Pig();
        child.feed(cat);
        child.feed(dog);
        child.feed(pig);
    }

}

Child类

public class Child {

    /**
     * 对于feed，必然要面对不同的animal，当传入的对象不同时必然不能用同一个方法，因此利用重载使得不同的对象都可以传入
     * 当然此处也可以去掉animal类，不使用继承与重写，直接使用dog，pig，cat三个类的对象
     */
     //对feed进行重载，可以传入不同动物的对象
    public void feed(Dog dog){
        dog.eat();
    }
    public void feed(Cat cat){
        cat.eat();
    }
    public void feed(Pig pig){
        pig.eat();
    }
}

Animal父类

public class Animal {
    public void eat(){
        System.out.println("Animal eat...");
    }

}

Dog，Pig，Cat类继承Animal类并重写eat方法

public class Dog extends  Animal{
    @Override//强制检索是否重写
    public void eat(){//对父类方法的重写
        System.out.println("Dog eat...");
    }

}

public class Pig extends Animal {
    @Override//强制检索是否重写
    public void eat(){//对父类方法的重写
        System.out.println("Pig eat...");
    }

}

public class Cat extends Animal{
    @Override//强制检索是否重写
    public void eat(){//对父类方法的重写
        System.out.println("Cat eat...");
    }

}

这个小例子中通过重载实现了多态。

2.继承、重写与父类指向子类对象实现多态

事实上在上面的小例子中Child可以通过父类指向子类对象的方式达到不用方法重载。只需把Child类做一点小修改。

public class Child {
    /**
     * 将父类的对象作为了方法的参数，因此animal的所有子类的对象全部都可以传入
     * 又因为子类都对feed方法进行了重写，所以调用的时候优先使用子类。
     * 这样没有过多的重载
     */
    public void feed(Animal animal){
        animal.feed();
    }

}

修改后
Test.java文件

    public class Test {
        public static void main(String[] args) {
            Child child = new Child();
            Dog dog = new Dog();
            Cat cat = new Cat();
            Pig pig = new Pig();
            child.feed(cat);
            child.feed(dog);
            child.feed(pig);
        }

    }

Child.java文件

Child.java文件
public class Child {
    public void feed(Animal animal){
        animal.feed();
    }
}

public class Animal {
    public void feed(){
        System.out.println("Animal eat...");
    }
}

public class Dog extends Animal{
    @Override
    public void feed(){
        System.out.println("Dog eat...");
    }

}

public class Cat extends Animal{
    @Override
    public void feed(){
        System.out.println("Cat eat...");
    }

}

public class Pig extends Animal{
    @Override
    public void feed(){
        System.out.println("Pig eat...");
    }

}

父类指向子类对象达到多态的小结

父类指向子类对象的，那么只能使用父类中定义好的方法而不能使用子类特有的方法
父类指向子类对象的，若果重写了父类的方法就调用子类重写的方法而不会调用父类的
当父类作为方法的参数时那么就能能传入所有子类对象（就象上面Child类的feed方法）
当一个方法的返回对象是父类时，那么久能返回所有子类对象

将上面的Test类和Child类修改，就达到上面的第四条：

    public class Test {
        public static void main(String[] args) {
            Child child = new Child();
            Dog dog = new Dog();
            Cat cat = new Cat();
            Pig pig = new Pig();
            child.feed(cat);
            child.feed(dog);
            child.feed(pig);
            child.feed2(cat).feed();
            child.feed2(dog).feed();
            child.feed2(pig).feed();
        }

    }

public class Child {
    /**
     * 将父类的对象作为了方法的参数，因此animal的所有子类的对象全部都可以传入
     * 又因为子类都对feed方法进行了重写，所以调用的时候优先使用子类。
     * 这样没有过多的重载，减少了代码量
     */
    public void feed(Animal animal){
        animal.feed();
    }

    public Animal feed2(Animal animal){//新加入的Animal返回类型方法

        return animal;
    }

}

3.接口指向实现类对象

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        USB U1 = new Car();
        USB U2 = new Mp3();
        USB U3 = new Game();
        U1.run();
        U2.end();
        U3.run();

    }

}

一个USB接口

public interface USB {
    public void run();
    public void end();
}

对接口进行实现的MP3，Car，Game类

ublic class Mp3 implements USB{
    public void run(){
        System.out.println("Play Music");
    }
    public void end(){
        System.out.println("Stop Music");
    }

}

public class Car implements USB{
    public void run(){
        System.out.println("car is starting!");
    }
    public void end(){
        System.out.println("Car is stop!");
    }

}

public class Game implements USB{
    public void run(){
        System.out.println("play game");
    }
    public void end(){
        System.out.println("stop game");
    }

}

在这个小例子中通过利用接口的一个特性（一个接口可以有多个实现），实现了多态

这些就是今天学长讲完多态后，我的一点小总结,有理解错误的地方烦请帮忙指正一下。