Polymorphism

最新推荐文章于 2022-06-14 13:15:31 发布

转载最新推荐文章于 2022-06-14 13:15:31 发布 · 576 阅读

C++ 同时被 2 个专栏收录

21 篇文章

订阅专栏

2 篇文章

订阅专栏

本文详细介绍了计算机科学中多态性的概念及其在面向对象编程中的应用。探讨了三种多态形式：参数多态、子类型多态及特设多态，并通过实例说明了它们的工作原理。

http://en.wikipedia.org/wiki/Polymorphism_(computer_science)

http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming

http://www.cplusplus.com/doc/tutorial/polymorphism/

http://www.codeproject.com/Articles/10900/Polymorphism-in-C

多态

多型（英语：Polymorphism），是指物件導向程式執行時，相同的訊息可能會送給多個不同的類別之物件，而系統可依據物件所屬類別，引發對應類別的方法，而有不同的行為。簡單來說，所謂多型意指相同的訊息給予不同的物件會引發不同的動作稱之。

比如有動物（Animal）之類別（Class），而且由動物繼承出類別雞（Chicken）和類別狗（Dog），並對同一源自類別動物（父類別）之一訊息有不同的響應，如類別動物有「叫()」之動作，而類別雞會「啼叫()」，類別狗則會「吠叫()」，則稱之為多型。

In computer science, polymorphism is a programming language feature that allows values of different data types to be handled using a uniform interface.

1. ad-hoc polymorphism. Ad-hoc polymorphism is supported in many languages using function and method overloading.

2. parametric polymorphism: If all code is written without mention of any specific type and thus can be used transparently with any number of new types.In the object-oriented programming community, programming using parametric polymorphism is often called generic programming.

3. subtype polymorphism or inclusion polymorphism, a name may denote instances of many different classes as long as they are related by some common super class. objects of different types are entirely substitutable for objects of another type (their base type(s)) and thus can be handled via a common interface.

Ad-hoc polymorphism = function/operator overloading

ad-hoc polymorphism to refer to polymorphic functions which can be applied to arguments of different types, but which behave differently depending on the type of the argument to which they are applied (also known as function overloading or operator overloading).

Parametric polymorphism = genetics

Parametric polymorphism allows a function or a data type to be written generically, so that it can handle values identically without depending on their type.

class List<T> {
    class Node<T> {
        T elem;
        Node<T> next;
    }
    Node<T> head;
    int length() { ... }
}
 
List map(Func<A,B> f, List<A> xs) {
    ...
}

Subtyping polymorphism ~ abstract class
subtyping polymorphism(sometimes referred to as dynamic polymorphism) allows a function to be written to take an object of a certain type T, but also work correctly if passed an object that belongs to a type S that is a subtype of T.

abstract class Animal {
    String talk();
}
 
class Cat extends Animal {
    String talk() { return "Meow!"; }
}
 
class Dog extends Animal {
    String talk() { return "Woof!"; }
}
 
public class MyClass {
 
    public static void write(Animal a) {
        System.out.println(a.talk());
    }
 
    public static void main() {
        write(new Cat());
        write(new Dog());
    }
 
}

one C++ example:

// dynamic allocation and polymorphism
#include <iostream>
using namespace std;

class CPolygon { // abstract base class
  protected:
    int width, height;
  public:
    void set_values (int a, int b)
      { width=a; height=b; }
    virtual int area (void) =0; // virtual members
    void printarea (void)
      { cout << this->area() << endl; } // pure virtual members can be called from the abstract base class
  };

class CRectangle: public CPolygon {
  public:
    int area (void)
      { return (width * height); }
  };

class CTriangle: public CPolygon {
  public:
    int area (void)
      { return (width * height / 2); }
  };

int main () {
  CPolygon * ppoly1 = new CRectangle; // pointers to base class
  CPolygon * ppoly2 = new CTriangle;
  ppoly1->set_values (4,5);
  ppoly2->set_values (4,5);
  ppoly1->printarea();
  ppoly2->printarea();
  delete ppoly1;
  delete ppoly2;
  return 0;
}