Java-多态

【1】多态跟属性无关，多态指的是方法的多态，而不是属性的多态。

【2】案例代入：

1.public class Animal {//父类：动物：
2.    public void shout(){
3.        System.out.println("我是小动物，我可以叫。。。");
4.    }
5.}

1.public class Cat extends Animal{
2.    //喊叫方法：
3.    public void shout(){
4.        System.out.println("我是小猫，可以喵喵叫");
5.    }
6.    public void scratch(){
7.        System.out.println("我是小猫，我可以挠人");
8.    }
9.}

1.public class Dog extends Animal{
2.    //喊叫：
3.    public void shout(){
4.        System.out.println("我是小狗，我可以汪汪叫");
5.    }
6.    public void guard(){
7.        System.out.println("我是小狗，我可以看家护院，保护我的小主人。。。");
8.    }
9.}

1.public class Pig extends Animal{
2.    public void shout(){
3.        System.out.println("我是小猪，我嗯嗯嗯的叫");
4.    }
5.    public void eat(){
6.        System.out.println("我是小猪，我爱吃东西。。");
7.    }
8.
9.}

1.public class Girl {
2.    //跟猫玩耍：
3.    /*public void play(Cat cat){
4.        cat.shout();
5.    }*/
6.    //跟狗玩耍：
7.    /*public void play(Dog dog){
8.        dog.shout();
9.    }*/
10.    //跟小动物玩耍：
11.    public void play(Animal an){
12.        an.shout();
13.    }
14.}

1.public class Test {
2.    //这是一个main方法，是程序的入口：
3.    public static void main(String[] args) {
4.        //具体的猫：--》猫的对象
5.        //Cat c = new Cat();
6.        //具体的小女孩：--》女孩的对象
7.        Girl g = new Girl();
8.        //小女孩跟猫玩：
9.        //g.play(c);
10.        //具体的狗---》狗的对象：
11.        //Dog d = new Dog();
12.        //小女孩跟狗玩：
13.        //g.play(d);
14.        //具体的动物：--》动物的对象：
15.        //Cat c = new Cat();
16.        //Dog d = new Dog();
17.        Pig p = new Pig();
18.        Animal an = p;
19.        g.play(an);
20.    }
21.}

【3】总结：

（1）先有父类，再有子类：--》继承   先有子类，再抽取父类 ----》泛化 

（2）什么是多态：

多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。

多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。

（3）多态的好处：

为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。

开闭原则：指的就是扩展是 开放的，修改是关闭的。

注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习 反射 

（4）多态的要素：

一，继承：   Cat extends Animal  ,Pig extends Animal,   Dog extends Animal

二，重写：子类对父类的方法shout()重写

三， 父类引用指向子类对象：

1.Pig p = new Pig();
2.Animal an = p;

将上面的代码合为一句话：

Animal an = new Pig();

=左侧：编译期的类型

=右侧：运行期的类型

Animal an = new Pig();

g.play(an); //

1.public void play(Animal an){//Animal an = an = new Pig();
2.        an.shout();
3.    }

上面的代码，也是多态的一种非常常见的应用场合：父类当方法的形参，然后传入的是具体的子类的对象，

然后调用同一个方法，根据传入的子类的不同展现出来的效果也不同，构成了多态。

内存分析

向下转型，向上转型

现在我就想访问到eat()方法和weight属性：

1.public class Demo {
2.    //这是一个main方法，是程序的入口：
3.    public static void main(String[] args) {
4.        Pig p = new Pig();
5.        Animal an = p;//转型：向上转型
6.        an.shout();
7.
8.        //加入转型的代码：
9.        //将Animal转为Pig类型：
10.        Pig pig = (Pig)an ;//转型：向下转型
11.        pig.eat();
12.        pig.age = 10;
13.        pig.weight = 60.8;
14.    }
15.}

对应内存：

思考之前的equals方法：

简单工厂设计模式

不仅可以使用父类做方法的形参，还可以使用父类做方法的返回值类型，真实返回的对象可以是该类的任意一个子类对象。

简单工厂模式的实现，它是解决大量对象创建问题的一个解决方案。将创建和使用分开，工厂负责创建，使用者直接调用即可。简单工厂模式的基本要求是 

² 定义一个static方法，通过类名直接调用

² 返回值类型是父类类型，返回的可以是其任意子类类型

² 传入一个字符串类型的参数，工厂根据参数创建对应的子类产品

1.public class Test {
2.    public static void main(String[] args) {
3.        Girl g = new Girl();
4.
5.        //Cat c = new Cat();
6.        //Dog d = new Dog();
7.        //Pig p = new Pig();
8.        Animal an = PetStore.getAnimal("狗");
9.
10.        g.play(an);
11.    }
12.}

1.public class PetStore {//宠物店 ---》工厂类
2.    //方法：提供动物
3.    public static Animal getAnimal(String petName){//多态的应用场合（二）
4.        Animal an = null;
5.
6.        if("猫".equals(petName)){//petName.equals("猫") --》这样写容易发生空指针异常
7.            an = new Cat();
8.        }
9.
10.        if("狗".equals(petName)){
11.            an = new Dog();
12.        }
13.
14.        if("猪".equals(petName)){
15.            an = new Pig();
16.        }
17.
18.        return an;
19.    }
20.}