关于oop：什么是多态，它是什么，以及它是如何使用的？


What is polymorphism, what is it for, and how is it used?

什么是多态性，它的用途是什么，它是如何使用的？

相关讨论

如果你想到这个词的希腊根源，它应该会变得明显。

  • poly=many:polygon=many sides，polyses=many styrenes(a)，polyglot=many languages，等等。
  • 变形=变化或形态：形态=研究生物形态，变形=希腊梦之神能够采取任何形式。

因此，多态性是(在编程中)为不同的基础形式(数据类型)呈现相同接口的能力。

例如，在许多语言中，整数和浮点数都是隐式多态的，因为无论类型是不同的，您都可以进行加、减、乘等操作。在通常的术语中，它们很少被视为对象。

但是，同样地，像BigDecimal或Rational或Imaginary这样的类也可以提供这些操作，即使它们在不同的数据类型上操作。

典型的例子是Shape类和所有可以从它继承的类(正方形、圆形、十二面体、不规则多边形、splat等等)。

使用多态性，这些类中的每一个都将具有不同的基础数据。一个点形状只需要两个坐标(当然假设它在二维空间中)。圆需要圆心和半径。正方形或矩形的左上角和右下角需要两个坐标，并且(可能)需要旋转。不规则多边形需要一系列直线。

通过使类对其代码和数据负责，可以实现多态性。在这个例子中，每个类都有自己的Draw()函数，客户机代码可以简单地做到：

1
shape.Draw()

以获得任何形状的正确行为。

这与以前的代码与数据分离的方式形成了对比，您可以使用诸如drawSquare()和drawCircle()之类的函数。

面向对象、多态性和继承都是密切相关的概念，了解它们至关重要。在我漫长的职业生涯中，有很多"银弹"基本上都失败了，但是OO模式已经被证明是一个很好的模式。学习它，理解它，热爱它——你会很高兴你做到了——)

(a)我最初是开玩笑写的，但结果证明是正确的，因此也没有那么有趣。MOMOMER苯乙烯恰好是由碳和氢，C8H8制成的，而聚苯乙烯则是由(C8H8)n组成的。

也许我应该说息肉是一个字母p的多次出现，尽管现在我不得不解释这个笑话，即使这看起来也不好笑。

有时候，当你落后时，你应该退出：—)

相关讨论

多态性是指可以将对象视为某个对象的通用版本，但当您访问它时，代码将确定它是哪种类型，并调用相关的代码。

下面是C中的一个例子。在控制台应用程序中创建四个类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

现在在控制台应用程序模块的main()中创建以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

在这个例子中，我们创建了一个基本类车辆的列表，它不知道每个子类有多少个车轮，但知道每个子类负责知道它有多少个车轮。

然后我们将自行车、汽车和卡车添加到列表中。

接下来，我们可以循环遍历列表中的每辆车，并对它们进行相同的处理，但是当我们访问每辆车的车轮属性时，Vehicle类将代码的执行委托给相关的子类。

这段代码被称为多态的，因为执行的确切代码是由运行时被引用的子类决定的。

我希望这对你有帮助。

相关讨论

从理解和应用PHP中的多态性开始，感谢Steve Guidetti。

Polymorphism is a long word for a very simple concept.

Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface.

The beauty of polymorphism is that the code working with the different classes does not need to know which class it is using since they’re all used the same way.
A real world analogy for polymorphism is a button. Everyone knows how to use a button: you simply apply pressure to it. What a button"does," however, depends on what it is connected to and the context in which it is used — but the result does not affect how it is used. If your boss tells you to press a button, you already have all the information needed to perform the task.

In the programming world, polymorphism is used to make applications more modular and extensible. Instead of messy conditional statements describing different courses of action, you create interchangeable objects that you select based on your needs. That is the basic goal of polymorphism.

相关讨论

如果有人对这些人说削减

  • 外科医生
  • 发型师
  • 演员

    • 会发生什么？

    • 外科医生会开始做切口。
    • 发型师会开始剪别人的头发。
    • 演员会突然停止演戏，等待董事会的指导。

    所以上面的表示显示了OOP中的多态性(相同的名称，不同的行为)。

    如果你要去面试，面试官要求你在我们坐的同一个房间里展示一个多态性的实例，比如-

    答案-门窗

    想知道如何？

    通过门/窗-人可以来，空气可以来，光可以来，雨可以来，等等。

    为了更好地理解它，我用上面的例子以一种简单的方式。如果您需要代码参考，请遵循以上答案。

    相关讨论

    类比的简单解释

    美国总统使用多态性。怎样？嗯，他有很多顾问：好的。

  • 军事顾问
  • 法律顾问
  • 核物理学家(顾问)
  • 医疗顾问
  • 等

    • 每个人只应负责一件事：例如：好的。

    总统不是锌涂层或量子物理学方面的专家。他不知道很多事情，但他只知道一件事：如何管理国家。好的。

    代码也是一样的：关注点和责任应该划分到相关的类/人。否则你就会让总统真正了解世界上的一切——整个维基百科。想象一下，将整个维基百科放在一个代码类中：维护它将是一场噩梦。好的。

    为什么总统要知道所有这些具体的事情是个坏主意？好的。

    如果总统要特别告诉人们该做什么，那就意味着总统需要确切地知道该做什么。如果总统需要自己知道具体的事情，这意味着当你需要改变的时候，你需要在两个地方，而不仅仅是一个。好的。

    例如，如果环境保护局改变了污染法，那么当这发生时：你必须改变环境保护局的等级，同时也改变总统的等级。在两个地方而不是一个地方更改代码是危险的-因为维护起来要困难得多。好的。

    有更好的方法吗？好的。

    有一个更好的方法：总统不需要知道任何事情的细节——他可以从专门负责这些事情的人那里要求最好的建议。好的。

    He can use a polymorphic approach to running the country.

    Ok.

    使用多态方法的示例：好的。

    总统所做的一切就是让人们给他建议——这就是他在现实生活中实际所做的——这就是一个好总统应该做的。他的顾问们都有不同的反应，但他们都知道总统的意思：advice()。他有数百人涌入他的办公室。其实他们是谁并不重要。总统所知道的是，当他要求他们"建议"时，他们知道如何做出相应的反应：好的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class MisterPresident
    {
        public void RunTheCountry()
        {
            // assume the Petraeus and Condi classes etc are instantiated.
            petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
            condolezza.Advise(); // # she says negotiate trade deal with Iran
            healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
        }
    }

    这种方法使总统能够在不了解任何军事、医疗保健或国际外交的情况下真正管理国家：细节留给专家。总统唯一需要知道的是："advice()"。好的。

    你不想要的：好的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    public class MisterPresident
    {
        public void RunTheCountry()
        {
            // people walk into the Presidents office and he tells them what to do
            // depending on who they are.

            // Fallujah Advice - Mr Prez tells his military exactly what to do.
            petraeus.IncreaseTroopNumbers();
            petraeus.ImproveSecurity();
            petraeus.PayContractors();

            // Condi diplomacy advice - Prez tells Condi how to negotiate

            condi.StallNegotiations();
            condi.LowBallFigure();
            condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

            // Health care

            healthOfficial.IncreasePremiums();
            healthOfficial.AddPreexistingConditions();
        }
    }

    NO！NO！NO！在以上情况下，总统的全是冰做的工作：他知道关于提高队伍数和预先存在的条件。这意味，如果中东政策的变化，当时的总统将改变他的commands，AA级AA阱的阱彼得雷乌斯AA。我们应该只有两类相变的彼得雷乌斯将军，因为总统不应该有两个bogged下在那黑色的零售银行。他不需要知道什么的细节。所有他需要知道的是，如果他使一阶，这是由我照顾。所有的细节应该离开的专家。

    好。

    这允许总统做的。他两个最好的政策：一般来说，看起来不错：P和打高尔夫。

    好。 实际上它是如何implemented通一级的基础和共同的接口

    这是在冰polymorphism效应，在一nutshell。它到底是怎么做的？通"实施一个共同的接口或使用"城市A座舱(传承)看到以上的答案，这更明确的零售。(为了更明确的理解这个概念，你需要知道两个接口的冰淇淋，你将需要理解什么是传承的冰淇淋。这是不可能的，你的斗争)。

    好。

    在其他的话，她和彼得雷乌斯healthofficials会全是"实施这类的接口"的呼叫信息的接口，这就IAdvisorcontains方法：一Advise()。现在，我们是要为《specifics。

    好。

    这将是理想的

    好。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
        public class MisterPresident
        {
                // You can pass in any advisor: Condi, HealthOfficials,
                //  Petraeus etc. The president has no idea who it will
                // be. But he does know that he can ask them to"advise"
                // and that's all Mr Prez cares for.

            public void RunTheCountry(IAdvisor governmentOfficer)
            {            
                governmentOfficer.Advise();              
            }
        }


        public class USA
        {
            MisterPresident president;

            public USA(MisterPresident president)
            {
                this.president = president;
            }

            public void ImplementPolicy()
            {
                IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
                president.RunTheCountry(governmentOfficer);
            }
        }

    摘要

    好的，你真的需要知道的是这个：

    好。

    • 总统不需要知道的specifics -这是两个离开的人。
    • 所有的总统需要知道冰问谁永远走在门的两个建议他和我们知道他们会绝对知道该怎么做，当你的建议(因为他们两个都在actuality，顾问(或：iadvisors))

    我真的希望你helps信息。如果你不了解事情的评论后，我会再试一次。

    好。 好的。

    相关讨论

    多态性是将对象类视为父类的能力。

    例如，假设有一个名为"动物"的类，还有一个名为"狗"的类继承自"动物"。多态性是把任何狗的物体都当作动物的物体来对待的能力，就像这样：

    1
    2
    Dog* dog = new Dog;
    Animal* animal = dog;
    相关讨论

    型

    多态性：好的。型

    它是面向对象编程的概念，不同对象对相同消息以各自的方式作出响应的能力称为多态性。好的。型

    多态性是因为每个类都生活在自己的名称空间中。在类定义中分配的名称与在类定义之外分配的名称不冲突。这对于对象数据结构中的实例变量和对象方法都是正确的：好的。型

      百万千克1

      就像C结构的字段在受保护的名称空间中一样，所以是对象的实例变量。好的。型百万千克1百万千克1

      方法名也受到保护。与C函数的名称不同，方法名不是全局符号。一个方法的名称类不能与其他类中的方法名冲突；2非常不同的类可以实现同名的方法。好的。型百万千克1

    型

    方法名是对象接口的一部分。当发送请求对象执行某项操作的消息时，该消息将命名该对象应执行的方法。因为不同的对象可以有同名的方法，所以必须相对于接收消息的特定对象理解消息的含义。发送到两个不同对象的相同消息可以调用两个不同的方法。好的。型

    多态性的主要优点是简化了编程接口。它允许建立可以在一个又一个类中重用的约定。不同于为添加到程序中的每个新函数发明一个新名称，相同的名称可以重用。编程接口可以描述为一组抽象行为，与实现它们的类完全不同。好的。型

    示例：好的。型

    示例1：这里有一个用python 2.x编写的简单示例。好的。型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    class Animal:
        def __init__(self, name):    # Constructor of the class
            self.name = name
        def talk(self):              # Abstract method, defined by convention only
            raise NotImplementedError("Subclass must implement abstract method")

    class Cat(Animal):
        def talk(self):
            return 'Meow!'

    class Dog(Animal):
        def talk(self):
            return 'Woof! Woof!'

    animals = [Cat('Missy'),
               Dog('Lassie')]

    for animal in animals:
        print animal.name + ': ' + animal.talk()

    示例2:多态性是在Java中使用方法重载和方法重写概念实现的。好的。型

    让我们以汽车为例来讨论多态性。以福特、本田、丰田、宝马、奔驰等品牌为例，一切都是车型。好的。型

    但每个人都有自己的高级功能和更先进的技术参与他们的移动行为。好的。型

    现在让我们创建一个基本类型的汽车好的。型

    汽车.java好的。型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Car {

        int price;
        String name;
        String color;

        public void move(){
        System.out.println("Basic Car move");
        }

    }

    号

    让我们来实现福特汽车的例子。好的。型

    福特扩展类型car以继承其所有成员(属性和方法)。好的。型

    爪哇福特好的。型

    1
    2
    3
    4
    5
    public class Ford extends Car{
      public void move(){
        System.out.println("Moving with V engine");
      }
    }

    上面的Ford类扩展了Car类并实现了move()方法。尽管move方法已经通过继承对Ford可用，但Ford仍然以自己的方式实现了该方法。这称为方法重写。好的。型

    本田.java好的。型

    1
    2
    3
    4
    5
    public class Honda extends Car{
      public void move(){
        System.out.println("Move with i-VTEC engine");
      }
    }

    。

    和福特一样，本田也扩展了车型，并以自己的方式实现了移动方法。好的。

    方法重写是实现多态性的一个重要特性。使用方法重写，子类型可以更改通过继承可用的方法的工作方式。好的。

    多态性示例.java好的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class PolymorphismExample {
      public static void main(String[] args) {
        Car car = new Car();
        Car f = new Ford();
        Car h = new Honda();

        car.move();
        f.move();
        h.move();

      }
    }

    多态性示例输出：好的。

    在多态性示例类主方法中，我创建了三个对象——Car、Ford和Honda。这三个对象都是由汽车类型引用的。好的。

    请注意，这里的一个重要点是，一个超类类型可以引用对象的子类类型，但不能使用副诗。原因是，使用继承，父类的所有成员对子类都可用，并且在编译期间，编译器尝试评估我们使用的引用类型是否具有他尝试访问的方法。好的。

    因此，对于多态性中的参考car、f和h，move方法存在于car类型中。因此，编译器通过编译过程时没有任何问题。好的。

    但是，当涉及到运行时执行时，虚拟机会调用属于子类型的对象上的方法。因此，方法move()是从它们各自的实现中调用的。好的。

    所以，所有对象都是car类型，但是在运行时，执行取决于调用发生的对象。这叫做多态性。好的。好啊。

    相关讨论

    通常这是指类型A的对象能够像类型B的对象一样工作。在面向对象的编程中，这通常是通过继承来实现的。一些维基百科链接可以阅读更多：

    • 面向对象编程中的多态性
    • 类型多态性

    编辑：修复断开的链接。

    相关讨论

    多态性是指：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    class Cup {
       int capacity
    }

    class TeaCup : Cup {
       string flavour
    }

    class CoffeeCup : Cup {
       string brand
    }

    Cup c = new CoffeeCup();

    public int measure(Cup c) {
        return c.capacity
    }

    您可以只传递一个杯子而不是一个特定的实例。这有助于通用性，因为您不必为每个CUP类型提供特定的measure()实例。

    相关讨论

    (我正在浏览另一篇文章，内容完全不同..多态性突然出现…现在我想我知道多态性是什么……但显然不是用这种漂亮的方式解释的……想把它写在某个地方……最好还是分享一下……)

    http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

    阅读本部分：

    …多态性。这是一种奇怪的说法，不同的名词可以有相同的动词适用于它们。

    我知道这是一个老问题，有很多好的答案，但我想包括一句话的答案：

    Treating a derived type as if it were it's base type.

    上面有很多例子说明了这一点，但我觉得这是一个很好的简明答案。

    相关讨论

    术语多态性来自：

    多=多

    变形=改变的能力

    在编程中，多态性是一种"技术"，它允许您将一个对象视为多个类型的事物。例如：

    学生对象也是人对象。如果你"看"(演员)学生，你可能会要求学生证。你不能总是和一个人这样做，对吗？(一个人不一定是学生，因此可能没有学生证)。然而，一个人可能有一个名字。学生也是。

    底线是，"从不同的角度看"同一个对象可以给你不同的"视角"(即不同的属性或方法)

    所以这项技术可以让你构建从不同角度"看"的东西。

    为什么我们要使用多态性？首先……抽象化。现在应该有足够的信息：)

    一般来说，它是使用相同的或表面上相似的API来接口许多不同类型的对象的能力。有多种形式：

    • 函数重载：定义具有相同名称和不同参数类型的多个函数，如sqrt(float)、sqrt(double)和sqrt(complex)。在大多数允许这样做的语言中，编译器将自动为传递给它的参数类型选择正确的参数，因此这是编译时多态性。

    • OOP中的虚拟方法：一个类的方法可以有不同的实现，这些实现根据其子类的具体情况而定制；每一个都被称为重写基类中给定的实现。给定一个可能属于基类或其任何子类的对象，就可以动态地选择正确的实现，因此这就是运行时多态性。

    • 模板：一些OO语言的一种特性，函数、类等可以由一种类型参数化。例如，您可以定义一个通用的"列表"模板类，然后将其实例化为"整数列表"、"字符串列表"，甚至可能是"字符串列表"等。通常，您为任意元素类型的数据结构编写一次代码，编译器为各种元素类型生成该代码的版本。

    多态性是一个对象具有多种形式的能力。OOP中多态性最常见的用法是在父类引用用于引用子类对象时使用。在这个用Java编写的例子中，我们有三种类型的车辆。我们创建了三个不同的对象，并尝试运行它们的轮子方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    public class PolymorphismExample {

        public static abstract class Vehicle
        {
            public int wheels(){
                return 0;
            }
        }

        public static class Bike extends Vehicle
        {
            @Override
            public int wheels()
            {
                return 2;
            }
        }

        public static class Car extends Vehicle
        {
            @Override
            public int wheels()
            {
                return 4;
            }
        }

        public static class Truck extends Vehicle
        {
            @Override
            public int wheels()
            {
                return 18;
            }
        }

        public static void main(String[] args)
        {
            Vehicle bike = new Bike();
            Vehicle car = new Car();
            Vehicle truck = new Truck();

            System.out.println("Bike has"+bike.wheels()+" wheels");
            System.out.println("Car has"+car.wheels()+" wheels");
            System.out.println("Truck has"+truck.wheels()+" wheels");
        }

    }

    结果是：

    The Result

    有关详细信息，请访问https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/polymorphismexample.java。希望有帮助。

    相关讨论

    我为另一个问题提供了多态性的高级概述：

    C++中的多态性

    希望有帮助。摘录…

    ...it helps to start from a simple test for it and definition of [polymorphism]. Consider the code:

    1
    2
    3
    4
    5
    Type1 x;
    Type2 y;

    f(x);
    f(y);

    Here, f() is to perform some operation and is being given the values x and y as inputs. To be polymorphic, f() must be able to operate with values of at least two distinct types (e.g. int and double), finding and executing type-appropriate code.

    (C++中的多态性继续)

    让我们用一个类比。对于一个特定的音乐剧本，每一个演奏它的音乐家都会给她自己的解释。

    音乐家可以通过接口抽象出来，音乐家所属的流派可以是一个abstrac类，它定义了一些全局的解释规则，每个演奏的音乐家都可以用一个具体的类来建模。

    如果你是一个音乐作品的听众，你可以参考剧本，例如巴赫的《赋格曲与托卡塔》，以及每一个演奏它的音乐家，都会以她自己的方式表现出多态性。

    这只是一个可能的设计的例子(在爪哇)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    public interface Musician {
      public void play(Work work);
    }

    public interface Work {
      public String getScript();
    }

    public class FugaAndToccata implements Work {
      public String getScript() {
        return Bach.getFugaAndToccataScript();
      }
    }

    public class AnnHalloway implements Musician {
      public void play(Work work) {
        // plays in her own style, strict, disciplined
        String script = work.getScript()
      }
    }

    public class VictorBorga implements Musician {
      public void play(Work work) {
        // goofing while playing with superb style
        String script = work.getScript()
      }
    }

    public class Listener {
      public void main(String[] args) {
        Musician musician;
        if (args!=null && args.length > 0 && args[0].equals("C")) {
          musician = new AnnHalloway();
        } else {
          musician = new TerryGilliam();
        }
        musician.play(new FugaAndToccata());
    }
    相关讨论

    多态性是程序员根据这些对象的需要，为不同类型的对象编写同名方法的能力。例如，如果您正在开发一个名为Fraction的类和一个名为ComplexNumber的类，这两个类都可能包含一个名为display()的方法，但每个类都将以不同的方式实现该方法。例如，在PHP中，您可以这样实现它：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    //  Class definitions

    class Fraction
    {
        public $numerator;
        public $denominator;

        public function __construct($n, $d)
        {
            //  In real life, you'd do some type checking, making sure $d != 0, etc.
            $this->numerator = $n;
            $this->denominator = $d;
        }

        public function display()
        {
            echo $this->numerator . '/' . $this->denominator;
        }
    }

    class ComplexNumber
    {
        public $real;
        public $imaginary;

        public function __construct($a, $b)
        {
            $this->real = $a;
            $this->imaginary = $b;
        }

        public function display()
        {
            echo $this->real . '+' . $this->imaginary . 'i';
        }
    }


    //  Main program

    $fraction = new Fraction(1, 2);
    $complex = new ComplexNumber(1, 2);

    echo 'This is a fraction: '
    $fraction->display();
    echo"
    ";

    echo 'This is a complex number: '
    $complex->display();
    echo"
    ";

    输出：

    1
    2
    This is a fraction: 1/2
    This is a complex number: 1 + 2i

    其他一些答案似乎意味着多态性只与继承结合使用；例如，可能Fraction和ComplexNumber都实现了一个名为Number的抽象类，该类有一个方法display()，那么分数和复数都有义务实现。但是您不需要继承来利用多态性。

    至少在像PHP这样的动态类型语言(我不知道C++或Java)中，多态性允许开发人员调用一种方法，而不必提前知道对象的类型，并且相信调用该方法的正确实现。例如，假设用户选择创建的Number类型：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    $userNumberChoice = $_GET['userNumberChoice'];

    switch ($userNumberChoice) {
        case 'fraction':
            $userNumber = new Fraction(1, 2);
            break;
        case 'complex':
            $userNumber = new ComplexNumber(1, 2);
            break;
    }

    echo"The user's number is:";
    $userNumber->display();
    echo"
    ";

    在这种情况下，将调用适当的display()方法，即使开发人员不能提前知道用户将选择小数还是复数。

    相关讨论

    OOP中的多态性意味着一个类可以有不同的类型，继承是实现多态性的一种方法。

    例如，形状是一个接口，它有方形、圆形、菱形子类型。现在你有了一个正方形的对象，你可以自动将正方形向上投射成形，因为正方形是一个形状。但是当你试图将形状向下投射到正方形时，你必须做显式类型投射，因为你不能说形状是正方形，它也可以是圆形。所以你需要用像Square s = (Square)shape这样的代码手工铸造它，如果形状是圆，你会得到java.lang.ClassCastException，因为圆不是正方形。

    多态性字面意思是多个形状。(或多种形式)：对象来自不同的类和相同的名称方法，但工作流不同。一个简单的例子是：

    考虑一个人X。

    他只有一个人，但他的行为也一样多。您可以问如何：

    他是他母亲的儿子。他朋友的朋友。他姐姐的哥哥。

    多态性是一种对象的能力，可以采取多种形式。例如，在人类社会，当我们谈论人际关系时，一个人可以采取多种形式。例：男人是儿子的父亲，是妻子的丈夫，是学生的老师。

    多态性=>根据类的实例执行不同的操作，而不是引用变量的类型。

    接口类型引用变量可以引用实现该接口的任何类实例。

    在面向对象编程中，多态性是指编程语言根据对象的数据类型或类对对象进行不同处理的能力。更具体地说，它是为派生类重新定义方法的能力。

    多态性是在给定类中使用对象的能力，其中构成对象的所有组件都由给定类的子类继承。这意味着一旦一个类声明了这个对象，它下面的所有子类(以及它的子类，等等，直到到达最远/最低的子类)都会继承这个对象和它的组件(组合)。

    请记住，每个类都必须保存在单独的文件中。

    以下代码举例说明了多态性：

    SuperClass：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Parent {
        //Define things that all classes share
        String maidenName;
        String familyTree;

        //Give the top class a default method
        public void speak(){
             System.out.println("We are all Parents");
        }
    }

    父亲，一个子类：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Father extends Parent{
        //Can use maidenName and familyTree here
        String name="Joe";
        String called="dad";

        //Give the top class a default method
        public void speak(){
            System.out.println("I am"+name+", the father.");
        }
    }

    子类，另一个子类：

    1
    2
    3
    4
    5
    6
    7
    8
    public class Child extends Father {
        //Can use maidenName, familyTree, called and name here

        //Give the top class a default method
        public void speak(){
            System.out.println("Hi"+called+". What are we going to do today?");
        }
    }

    执行方法引用父类以开始：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class Parenting{
        public static void main(String[] args) {
            Parent parents = new Parent();
            Parent parent = new Father();
            Parent child = new Child();

            parents.speak();
            parent.speak();
            child.speak();
        }
    }

    注意，每个类需要在单独的*.java文件中声明。代码应该编译。还请注意，您可以继续使用MaidenName和FamilyTree。这就是多态性的概念。这里还探讨了继承的概念，其中一个类可以被使用，或者由一个子类进一步定义。

    希望这有帮助，并说明了这一点。当我找到一台可以用来验证代码的计算机时，我会发布结果。感谢您的耐心等待！

    相关讨论

    多态性允许相同的例程(函数、方法)对不同的类型进行操作。

    由于许多现有的答案将子类型与多态性混为一谈，下面是实现多态性的三种方法(包括子类型)。

    • 参数(通用)多态性允许一个例程接受一个或多个类型参数(除了正常参数)，并在这些类型上运行自己。
    • 子类型多态性允许例程对其参数的任何子类型执行操作。
    • AdHoc多态性通常使用例程重载来授予多态行为，但也可以引用其他多态性实现。

    参见：

    http://wiki.c2.com/？类别同构

    https://en.wikipedia.org/wiki/多态性(计算机科学)

    多态性使您能够创建一个调用另一个模块的模块，并且还具有针对控制流而不是控制流的编译时依赖点。

    通过使用多态性，高层模块不依赖于底层模块。两者都依赖于抽象。这有助于我们应用依赖倒置原则(https://en.wikipedia.org/wiki/dependency_inversion_principle)。

    这就是我找到上述定义的地方。在视频中大约50分钟后，指导老师解释了上述内容。https://www.youtube.com/watch？V= TMUO5RZNE

    在面向对象语言中，多态性允许通过同一个接口处理和处理不同的数据类型。例如，考虑C++中的继承：类B是从类A派生的。类型A*的指针(指向类A的指针)可用于处理类A的对象和类B的对象。

    编码术语中的多态性是指对象可以通过继承等方式以多种类型存在。如果您创建了一个名为"shape"的类，它定义了对象的边数，那么您可以创建一个继承它的新类，如"square"。当你随后制作一个"正方形"的实例时，你可以根据需要将它从"形状"前后投射到"正方形"上。