Java中的多态

╰+攻爆jí腚メ 2024-03-31 14:39 26阅读 0赞

##  ##

## 多态 ##

**一、概念**

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态**（概念是网上抄的，可以不看）**。

简单解释：多态就是指**方法或对象**具有多种形态。它建立在封装和继承之上。

#### 通俗解释： ####

要想解释多态，我们先从**创建对象**说起。

Dog myDog = new Dog();

1.  Dog myDog：声明一个Dog类型的引用变量myDog。JVM分配空间给引用变量，并将此引用变量命名为myDog，而且此引用变量被永久的固定为Dog类型。
2.  new Dog()：实例化Dog对象，分配堆空间给新建的Dog对象。
3.  “=”：将new出来的Dog对象赋值给引用变量myDog。myDog就好像是一个遥控器，指向了new出来的Dog，指向了它的那片空间。

在该过程中，有一个重点就是，引用变量的类型和对象的类型必须是一样的。即myDog是Dog类型的，而后面new的对象也要是Dog类型的。

However！在多态中，引用变量的类型和new的对象的类型**可以是不一样的！**（父类引用指向子类对象）运用多态时，引用变量的类型可以是new出来的对象的父类类型，例如Animal是Dog的父类:

Animal[] animals = new Animal[5]; //创建一个Animal类型的数组
    animal[0] = new Dog();
    animal[1] = new Cat();
    animal[2] = new Wolf();
    animal[3] = new Hippo();
    animal[4] = new Lion();

多态更强大的地方在于，**参数和返回类型也可以多态**。（这不就是方法的重载？）

这就表示，可以将不同的对象作为方法的参数，从而判断出使用哪种方法：

Class vet{
        public void giveShot(Animal a){
            a.makeNoise();   //giveShot这个方法是需要传入Animal类型的对象
        }
    }
    
    class PetOwner{
        public void start(){
            Vet v = new Vet();
            Dog d = new Dog();
            Hippo h = new Hippo();
            v.giveShot(d);   //执行Dog的makeNoise()方法
            v.giveShot(h);   //执行Hippo的makeNoise()方法
        }
    }

--------------------

## 多态的具体体现 ##

#### 一、方法重写（override）和重载（overload） ####

public static void main(String[] args){
        //方法重载体现多态。因为传入不同的参数就调用不同的sum方法。
        A a = new A();
        sout(a.sum(10, 20));
        sout(a.sum(10, 20, 30));
    
        //方法重写体现多态。因为对象不一样，调用不同的say方法。
        B b = new B();
        a.say();
        b.say();
    }
    
    class B{   //父类
        public void say(){
            sout("B的say()方法被调用");    
        }
    }
    
    class A extends B{   //子类
        public int sum(int n1, int n2){
            return n1 + n2;
        }
        public int sum(int n1, int n2, int n3){
            return n1 + n2 + n3;
        }
        public void say(){
            sout("A的say()方法被调用");    
        }
    }

#### 二、对象体现多态 ####

对象体现多态是多态的核心。同一个父类的引用变量即可使用所有子类的方法，只需修改父类型的引用变量指向的子类实例即可。总结起来就是一句话：**父类型的引用变量指向子类的实例化对象。**（引用变量就是animal，实例化对象就是后面的new Dog()）

Animal animal = new Dog();   //Animal类型的引用变量animal指向了Dog类型的实例。
    animal.eat();   //因此这里的eat()方法调用的是Dog类型的eat()方法。
    
    //引用变量的类型一旦确定，就不可以更改，但是指向的实例可以变换。
    animal = new Cat();   //animal仍然是Animal类型的引用变量，但现在是指向了Cat类型的实例。
    animal.eat();   //因此这里的eat()方法调用的是Cat类型的eat()方法。

#### 三、多态的一个简单例子 ####

假设主人要给动物喂食物，如果不用多态，写出来的是这样的：

//给dog喂bone
    public void feed(Dog dog, Bone bone){
        sout(dog.getName() + "被喂了" + bone.getName())
    }
    
    //给cat喂fish
    public void feed(Cat cat, Fish fish){
        sout(cat.getName() + "被喂了" + fish.getName())
    }

采用多态的思想是这样的：

public void feed(Animal animal, Food food){
        sout("animal" + animal + "food" + food);
        sout(animal.getName() + "吃" + food.getName());
    }

#### 四、多态的好处 ####

1.  提高代码的复用性。
2.  子类的功能可以被父类型的引用变量所调用，即可以向后兼容，提高代码的可扩展性和维护性。