文章目录
- 前言
- 一. 初始多态
- 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);
}
@Override
public void makeNoise() {
System.out.println(picture+"喵喵叫");
}
@Override
public 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);
}
@Override
public void makeNoise() {
System.out.println(picture+"汪汪叫");
}
@Override
public 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 {
@Override
public void draw() {
System.out.println("画矩形！");
}
}
class Cycle extends Shape {
@Override
public 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 flower
String[] 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();
}
看了上面的俩个例子香型你们已经大概理解多态的机制。
三.总结
通过多态，你就可以编写出引进新型子类时也不必修改的程序。
这可能，有些简短了，但事实就是这样。
又到了，跟大家说再见的时候了，下一次我们将带大家深入多态，了解抽象类和接口
