什么是多态?

Posted 2023-04-10 熬夜磕代码丶

文章目录

• 一、多态是什么？
• 二、多态的必要条件
• • 2.1 初始多态
  • 2.2 多态的优缺点
  • 2.3 重写
• 三、转型
• • 3.1 向上转型
  • 3.2 向下转型
  • 3.3 避免在构造方法中调用重写方法.

一、多态是什么？

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

二、多态的必要条件

2.1 初始多态

要实现多态，以下三大条件缺一不可:

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
   

class Shape 
    void draw() 

    

class Square extends Shape 
    @Override
    void draw() 
        System.out.println("画Square!");
    

class Circle extends Shape 
    @Override
    void draw() 
        System.out.println("画Circle!");
    

class Triangle extends Shape 
    @Override
    void draw() 
        System.out.println("画Triangle!");
    

public class Test 
    public static void draw(Shape shape) 
        shape.draw();
    
    public static void main(String[] args) 
        Circle circle = new Circle();
        Square square = new Square();
        draw(circle);
        draw(square);
    

在这里实现了同一个方法同一引用，因为传入对象的不同，产生了不同的效果，这种不同的体现就是多态的体现.

2.2 多态的优缺点

优点:

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

缺点:
1.属性没有多态性
当父类和子类属性同名时，只能访问父类的
2.构造方法没有多态性.

2.3 重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

在重写的时候可以加上@Override关键字，系统会默认帮我们检查重写的方法是否正确，如果父类没有此类方法，就会编译报错.

区别	重写	重载
方法名	不能修改	不能修改
参数列表	一定不能修改	必须修改
返回类型	不能修改或者构成父子关系	可以修改
访问限定符	不能增强限制	可以修改

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，
并且添加或者改动新的内容。

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

三、转型

3.1 向上转型

Shape shape = new Circle();

向上转型就是new 一个子类对象，让父类对象来使用

class Animal 
    String neme;
    int age;

    public Animal(String neme, int age) 
        this.neme = neme;
        this.age = age;
    

    public void eat()

   


class Cat extends Animal 
    public Cat(String neme, int age) 
        super(neme, age);
    

    public void eat() 
        System.out.println("吃鱼");
    
    public void work() 
        System.out.println("抓老鼠");
    


class Dog extends Animal 
    public Dog(String neme, int age) 
        super(neme, age);
    

    public void eat() 
        System.out.println("吃骨头");
    
    public void work() 
        System.out.println("看家");
    

1.直接赋值:

public static void main(String[] args) 
        Animal cat = new Cat("咪咪",18);//直接将子类对象赋值给父类对象
    

2.方法传参:

public static void eat(Animal animal) 
        //方法传参:形参为父类引用，可以接受子类对象
        animal.eat();
    

3.方法返回:

public static Animal reAnimal(String type) 
        //返回一个子类对象
        if("狗".equals(type)) 
            return new Dog("旺财",18);
        else if("猫".equals(type)) 
            return new Cat("咪咪",18);
        else 
            return null;
        
    

向上转型可以让代码变得更加简单灵活，但无法访问子类特有的属性方法.

3.2 向下转型

在进行向上转型后，无法调用子类的方法，但有时可能需要调用子类方法，此时在还原为子类对象，成为向下转型.

放下转型具有不安全性

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

public static void main(String[] args) 
        Animal animal = new Dog("旺财",18);
        if(animal instanceof Cat) 
            Cat cat = (Cat)animal;
        
        else if(animal instanceof Dog) 
            Dog dog = (Dog)animal;
        
    

通过向下转型后就可以正常的调用子类方法.

3.3 避免在构造方法中调用重写方法.

class A 
    public A() 
        fun();
    
    public void fun() 
        System.out.println("A:fun");
    

class B extends A 
    int count = 10;

    @Override
    public void fun() 
        System.out.println("B:fun"+count);
    

    public static void main(String[] args) 
        B b = new B();
    

这样的代码会出现很多问题.它先执行父类的构造方法，然后在构造方法中执行子类的重写方法，但因为子类还没有执行构造方法,子类的属性还没有被加载，所以这里输出的count不是10，而是默认值0.

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

什么是多态性

什么是多态性

多态性就是多种表现形式，具体来说，可以用"一个对外接口，多个内在实现方法"表示。举一个例子，计算机中的堆栈可以存储各种格式的数据，包括整型，浮点或字符。不管存储的是何种数据，堆栈的算法实现是一样的。针对不同的数据类型，编程人员不必手工选择，只需使用统一接口名，系统可自动选择。
多态性也分静态多态性和动态多态性两种。静态多态性是指定义在一个类或一个函数中的同名函数，它们根据参数表（类型以及个数）区别语义，并通过静态联编实现，例如，在一个类中定义的不同参数的构造函数。动态多态性是指定义在一个类层次的不同类中的重载函数，它们一般具有相同的函数，因此要根据指针指向的对象所在类来区别语义，它通过动态联编实现。
“多态性”一词最早用于生物学，指同一种族的生物体具有相同的特性。在面向对象理论中，多态性的定义是：同一操作作用于不同的类的实例，将产生不同的执行结果，即不同类的对象收到相同的消息时，得到不同的结果。多态性包含编译时的多态性、运行时的多态性两大类。
动态多态是指发出同样的消息被不同类型的对象接收时，有可能导致完全不同的行为。即，在用户不作任何干预的环境下，类的成员函数的行为能根据调用它的对象类型自动作出适应性调整，而且调整是发生在程序运行时。 多态是面向对象程序设计的重要特征之一。是扩展性在“继承”之后的又一重大表现 。
比方一下:
你和你朋友都是烟鬼,
某日,你没有带烟, 而你朋友有n种烟,
你说: 来根烟,
朋友给你一根;
你通过烟的过滤嘴, 品出为白沙烟
你再要一根,
品出这次是芙蓉王,
再要一根,
品出这次是熊猫
...
上面描述的就是多态!
烟 a = 白沙
烟 b = 芙蓉王
烟 c = 熊猫
但发现没有, 仅仅通过"烟"基类, 引用到不同的具体类对象,
就能让你调用到不同的对象, 这就是多态.
而烟到你嘴里[此时你还没有发现是那种烟], 你仅仅凭借"吸"的动作,就识别出来,到底是哪种烟对象
这就是多态的悬机.
多态须具备:
1. 基类 和各个子类
2. 基类 引用, 指向实例化的子类对象.
再举一个鸡的例子,
鸡是所有其它鸡的基类, 定义了一个方法shape(), 此方法能指明鸡的形态. 所有的子类[火鸡,山鸡,田鸡等],都有这个shape方法, 表明自己的形态,
如果用下面的方法定义我需要具体的鸡,
[基类 引用 = 实现类的对象]
for example:
鸡 a = new 火鸡();
鸡 a = new 田鸡();
鸡 a = new 山鸡();
鸡 a = new 母鸡();
当我使用的时候, 我采用 a 这个引用,
a.shape(), 就会得到鸡的形态.
如果我定义的是
鸡 a = new 火鸡();
那么a.shape得到的是火鸡的形态, 而不需要用具体的
火鸡 a = new 火鸡(); 再通过a.shape得到火鸡的形态 参考技术A 多态性是指以适当频率在一个群体的某个特定遗传位点（基因序列或非基因序列）发生两种或两种以上变异的现象，可通过直接分析DNA或基因产物来确定。
生物多态性是指地球上所有生物，从食物链系统、物种水平、群体水平、个体水平、组织和细胞水平、分子水平、基因水平等层次上体现出的形态（morphism）和状态（state）的多样性。

生物多态性（organism polymorphism）又称生物多样性 （life diversity），包括生态系统多样性、物种多样性和遗传多样性。其中遗传多样性是生态系统多样性和物种多样性的基础和核心，是生物多样性的内在形式。又由于基因是生物遗传信息的载体，所以遗传多样性的本质是基因多样性。

从分类学角度考虑，许多物种包含着丰富的亚种多型分化，即该物种具有多种地理或生态群体。例如西方蜜蜂Apismellifera 的原产地———非洲、欧洲、亚洲中部和西部的生态系统多样性丰富，经过长期繁衍进化，各地蜜蜂已形成了适应当地生态环境的特殊亚种或生态型。一定意义上讲，一个物种包含成千上万的个体，就具有一个独特的基因多样性。 参考技术B 2楼没学过java吧，或者根本没学懂，误人子弟。
多态的概念理解很烦，举个例子。你定义了一个动物class，动物class里面有个方法：叫（），但你没实现。你又定义了两个class，一个猫class，一个狗class。都继承于动物class。在狗class里面实现叫（）方法：为“汪汪”，而在猫class里面实现方法叫（）：为“喵喵”，这就是多态。顾名思义，同一个动作不同的事物具有不同的完成状态，所以不同的子类可以重写相同的方法。希望你明白了。 参考技术C 其实多态性,没有那么复杂的,用日常生活中的例子就可以说明的很清楚啊.
如人: 动作:吃饭
打球
看电视,
唱歌

这些都是一个人的动作,而这些动作就是一个人的多态性的表现.

生活的例子好好运用就可以了,不要想太多,对于初学者来说不是很好 参考技术D 指一个对象不仅仅可以已本身的类型存在，也可以作为其父类类型存在。
多态性是允许将父对象设置成为和一个或多个它的子对象相等的技术，比如Parent:=Child； 多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作.本回答被提问者采纳