文章目录

• 前言
• 一. 初始多态
• • 1.1 多态是什么
  • 1.2 多态是怎么工作
  • 1.3多态的向上转型和向下转型
• 二.多态的好处
• 三.总结

前言

前面我们讲过了，面向对象继承的特性，下面我们会根据多态来展开讨论，还是用熟悉的方式，让大家去了解这个疯狂的东西。

一. 初始多态

1.1 多态是什么

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。
听起来你会觉得很奇怪，当我们去调用不同对象的时候，我们会产生不同的行为，举例子来说这里有一个打印机，然后我们打印东西，可以打黑白的，也可以打彩色的，明明同样是打印机，但我们根据不同的状态，调用同一个方法，可能呈现的行为是不一样的。

1.2 多态是怎么工作

说实话哈，如果要看多态是怎么工作的，我们就要从对象的引用和声明，创建对象的方法开始，为什么这么说呢？大家看我下面的操作就知道了。

//这里我声明一个狗对象
Dog mydog =new Dog();

它实际上在做了一个什么样操作呢？看下面的图，你就明白了。

然后我这里这么写代码,记住我这样写，是因为在多态中，引用和对象可以是不同的类型

Animal animal=new Dog();
//这编译是能够通过的。

在这句代码中，究竟发生了什么呢？现在让我们来看看。

其实这里就说明了一个问题，就是我们在使用多态时，引用类型是实际对象类的父类

大家如果还是对多态机制懵懵懂懂的，我们直接上来写一个简单的例子，这个例子就是简单的三个类，Animal、Dog、Cat类，就用这个例子，来讲明白多态。

public class Animal {String picture;//动物图像的名称String food;//动物所吃的食物int hunger;//代表饥饿程度的值，根据动物吃了多少来定义int boundaries;//动物活动的区域double location;//动物活动区域的X与Y的坐标public Animal(){}public Animal(String picture, String food, int hunger, int boundaries, double location) {this.picture = picture;this.food = food;this.hunger = hunger;this.boundaries = boundaries;this.location = location;}public void  makeNoise(){//动物发出的声音System.out.println(picture+"发声音");}public  void eat(){//吃东西}public void  sleep(){//睡眠}public void roam(){//其他的行为}
}

public class Cat extends Animal{public Cat() {super();}public Cat(String picture, String food, int hunger, int boundaries, double location){super(picture,food,hunger,boundaries,location);}@Overridepublic void makeNoise() {System.out.println(picture+"喵喵叫");}@Overridepublic void eat() {System.out.println(picture+"吃鱼");}
}

public class Dog extends Animal{public Dog() {super();}public Dog(String picture, String food, int hunger, int boundaries, double location){super(picture,food,hunger,boundaries,location);}@Overridepublic void makeNoise() {System.out.println(picture+"汪汪叫");}@Overridepublic void eat() {System.out.println(picture+"啃骨头");}
}

上面就是我们定义好的三个类，我们现在在main方法中进行不同的操作，看看会发生什么。

 Animal animal2=new Dog();animal2.picture="旺财";animal2.eat();

运行结果:

实际上，我们去调试的时候，我们去发现这个annimal的引用实际上是指向了dog对象的。

这里实际上说明了一个观点。
当你声明一个引用变量时,任何对该引用变量类型可通过IS-A测试的对象都可以被赋值给该引用。换句话说,任何extends过声明引用变量类型的对象都可以被赋值给这个引用变量。这样子你就可以做出多态数组这一类的东西。
相信大家对多态的印象又多了了一分，接下来，我们会接触到多态的向上转型和向下转型。

1.3多态的向上转型和向下转型

可能大家对于多态还是非常陌生，我也知道大家很难理解，我这里之所以引入这个东西，大家也不要在意，语法是语法，后面有实际的例子，当大家进行一个综合例子之后，就能慢慢理解多态了。

向上转型
我简单来理解，向上转型就等同于数据类型中的自动类型转换，感觉上是差不多的。

/*
Animal 和 Dog 类
是父与子的关系
*/
Animal aniaml=new Dog();//这里就发生了向上转型。
//语法就是这么简单，没什么复杂度，难得是运用

这里我也举一个实际的例子，让大家体验一下，向上转型的语法

我们有三个类Animal、dog、cat类，类如下：
这里我是把三个类写到一起的，方便给你们观看的。

public class Animal {String name;String age;public void Play(){System.out.println(name+"玩耍");}public void Eat(){System.out.println(name+"吃东西");}public void  sleep(){System.out.println(name+"睡觉");}
}
public class Dog extends Animal{public void Eat(){System.out.println(name+"啃骨头");}
}public class Cat extends Animal{public void Eat(){System.out.println(name+"吃鱼鱼！！");}
}

我们接下来要做一个什么事情呢?就是我们使用不同的对象调用，会产生不同的动作。我会用俩种方式，一种是使用多态，一种是不使用多态，去进行。

不使用多态的话，我们就要使用if条件去判断是否是一个东西，然后根据这个不同的对象，去输出行为。

public class Test {public static void xingwei1(){Cat cat =new Cat();cat.name="猜猜";Dog dog=new Dog();dog.name="旺财";String[] animals={"dog","cat"};for (String a:animals){if (a.equals("dog")){dog.eat();}else if (a.equals("cat")){cat.eat();}}}public static void main(String[] args) {xingwei1();}
}

使用多态的向上转型后，代码稍稍做了一些修改，但也不难理解。

    public static void xingwei2(){Cat cat =new Cat();cat.name="猜猜";Dog dog =new Dog();dog.name="旺财";Animal[] animal1={cat,dog};//这里就是用了，多态for (Animal s:animal1) {s.eat();}}public static void main(String[] args) {
//           xingwei();xingwei2();}
}

这里你就可以看出，多态的向上转型，可以让代码变得异常灵活了。

** 向下转型**
我的理解是向下转型跟数据类型的强制类型转换差不多，大家大致来看一看语法机制，你就明白了。

  		Cat cat =new Cat();Animal animal=new Dog();//此时aniaml是狗，不可能是猫，此时我们就需要向下转型cat=(Cat) animal;cat.eat();

但向下转型存在一个问题哈，你用常规性的思维思考一下，狗怎么会变成猫呢？这完全就是不符合常理，你不信的话，你运行一下，你就会看到如下警报

因此，我们有时候，在向下转型的时候，会运用一个关键字，instanof，去判断是否合法

  Cat cat =new Cat();Dog dog =new Dog();Animal animal = cat;//此时aniaml是狗，不可能是猫，此时我们就需要向下转型if(animal instanceof Cat){cat = (Cat)animal;cat.eat();}if(animal instanceof Dog){dog = (Dog)animal;dog.eat();}

好了好了，同志们，看了这么久的多态以后。我们来进行一个综合例子，去观察观察，多态的好处。

二.多态的好处

大家都知道打印图形的例子吧，我们操作一个对象进行不同的行为。还是来两种方式，一种用多态的方式和一种用多态的方式，

2.1不用多态的方式

class Shape {public void draw() {System.out.println("画图形！");}
}
class Rect extends Shape {@Overridepublic void draw() {System.out.println("画矩形！");}
}
class Cycle extends Shape {@Overridepublic void draw() {System.out.println("画圆！");}
}public class TestMain(){
public static void drawMap() {Rect rect = new Rect();Cycle cycle = new Cycle();Flower flower = new Flower();//cycle  rect  cycle  rect  flowerString[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};for (String s : shapes) {if(s.equals("cycle")) {cycle.draw();}else if(s.equals("rect")) {rect.draw();}}public static void main(String[] args) {	drawMap();
}
}

使用多态的版本

 public static void drawMap() {Shape rect = new Rect();Shape cycle = new Cycle();Shape flower = new Flower();Shape[] shapes = {cycle,rect,cycle,rect};//int[] array = {1,2,3,4};for(Shape shape : shapes) {shape.draw();}}public static void main(String[] args) {	drawMap();
}

看了上面的俩个例子香型你们已经大概理解多态的机制。

三.总结

通过多态，你就可以编写出引进新型子类时也不必修改的程序。
这可能，有些简短了，但事实就是这样。
又到了，跟大家说再见的时候了，下一次我们将带大家深入多态，了解抽象类和接口