ポリモーフィズムとは何ですか、何のためにあり、どのように使用されますか？

StackOverflow https://stackoverflow.com/questions/1031273

質問

ポリモーフィズムとは何ですか、何のためにあり、どのように使用されますか？

役に立ちましたか？

解決

用語のギリシャ語のルーツについて考えれば、それは明らかになるはずです。

  • ポリ=多く：ポリゴン=多面、ポリスチレン=多くのスチレン（a）、ポリグロット=多くの言語など。
  • モーフ=変化または形態：形態学=生物学的形態の研究、モルフェウス=あらゆる形態をとることができるギリシャの夢の神。

多相性とは、異なるプログラミング（データ型）に対して同じインターフェイスを表示する（プログラミングにおける）機能です。

たとえば、多くの言語では、型が異なるという事実に関係なく、加算、減算、乗算などを行うことができるため、整数と浮動小数点は暗黙的にポリモーフィックです。通常の用語ではオブジェクトと見なされることはめったにありません。

しかし、同じ方法で、 BigDecimal や Rational や Imaginary などのクラスは、これらの操作を実行できますが、さまざまなデータ型。

古典的な例は、 Shape クラスと、それから継承できるすべてのクラス（正方形、円、12面体、不規則な多角形、スプラットなど）です。

ポリモーフィズムでは、これらのクラスのそれぞれに異なる基礎データがあります。ポイントシェイプに必要な座標は2つだけです（もちろん、2次元空間にあると仮定します）。円には中心と半径が必要です。正方形または長方形には、左上隅と右下隅の2つの座標と（場合によっては）回転が必要です。不規則な多角形には一連の線が必要です。

クラスにデータだけでなくコードも担当させることで、ポリモーフィズムを実現できます。この例では、すべてのクラスに独自の Draw（）関数があり、クライアントコードでは次のことができます。

shape.Draw()

任意の形状の正しい動作を取得します。

これは、コードがデータとは別のものであり、 drawSquare（）や drawCircle（）<などの関数を使用していた古い方法とは対照的です/ code>。

オブジェクト指向、ポリモーフィズム、継承はすべて密接に関連した概念であり、知ることが不可欠です。多くの「銀の弾丸」がありました。私の長いキャリアの中で、基本的には動揺しましたが、オブジェクト指向のパラダイムは良いものであることが判明しました。それを学び、それを理解し、それを愛しなさい-あなたがしたことを喜んでいるだろう：-）

（a）私はもともとそれを冗談として書いたが、それは正しいことが判明したため、それほどおかしくない。モノマーのスチレンはたまたま炭素と水素、 C 8 H 8 から作られており、ポリスチレンはそのグループから作られています（C 8 H 8 ） n 。

おそらく、ポリープは文字 p の多くの出現であると述べたはずですが、今では冗談を説明する必要がありました。 >

場合によっては、後ろにいる間に終了する必要があります：-）

他のヒント

多態性とは、オブジェクトを何かのジェネリックバージョンとして扱うことができる場合ですが、アクセスすると、コードが正確なタイプを判断し、関連するコードを呼び出します。

これはC＃の例です。コンソールアプリケーション内に4つのクラスを作成します。

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（）で次を作成します。

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のリストを作成します。このクラスは、各サブクラスが所有するホイールの数を知りませんが、各サブクラスが所有するホイールの数を知る責任があることを知っています。

次に、自転車、車、トラックをリストに追加します。

次に、リスト内の各Vehicleをループし、それらをすべて同一に扱いますが、各Vehiclesの「Wheels」プロパティにアクセスすると、Vehicleクラスはそのコードの実行を関連するサブクラスに委任します。

実行される正確なコードは実行時に参照されるサブクラスによって決定されるため、このコードはポリモーフィックと呼ばれます。

これがお役に立てば幸いです。

PHPでのポリモーフィズムの理解と適用、Steve Guidettiに感謝します。

  

ポリモーフィズムは、非常に単純な概念の長い言葉です。

     

ポリモーフィズムは、オブジェクト指向プログラミングのパターンを説明します。クラスでは、共通のインターフェースを共有しながら、異なる機能を備えています。

     

ポリモーフィズムの利点は、異なるクラスを使用するコードは、すべて同じように使用されるため、使用しているクラスを知る必要がないことです。   ポリモーフィズムの現実世界の類似性はボタンです。ボタンの使用方法は誰でも知っています。ボタンに圧力をかけるだけです。どのようなボタンが＆＃8220;するのか＆＃8221;ただし、接続先と使用されるコンテキストに依存します＆＃8212;ただし、結果は使用方法に影響しません。上司からボタンを押すように指示された場合、タスクを実行するために必要なすべての情報を既に持っています。

     

プログラミングの世界では、ポリモーフィズムを使用して、アプリケーションをよりモジュール化および拡張可能にします。さまざまなアクションコースを記述する乱雑な条件ステートメントの代わりに、ニーズに基づいて選択する交換可能なオブジェクトを作成します。それがポリモーフィズムの基本的な目標です。

誰かがこれらの人々にCUTを言う場合

  1. 外科医
  2. ヘアスタイリスト
  3. 俳優

何が起こりますか

  • 外科医は切開を開始します。
  • ヘアスタイリストは誰かの髪を切り始めます。
  • 俳優は現在のシーンから演技を突然停止し、 監督のガイダンスを待っています。

上記の表現は、OOPのポリモーフィズムとは何か（同じ名前、異なる動作）を示しています。

インタビューに行くときに、インタビュアーが、私たちが座っているのと同じ部屋で、ポリモーフィズムの実例を教えて/見せてほしいと言ったら、たとえば

回答-ドア/窓

不思議な方法は？

ドア/窓から-人が来ても、空気が来ても、光が来ても、雨が来てもいい、など。

これをよりよく理解するために、簡単な方法で上記の例を使用しました。 コードの参照が必要な場合は、上記の回答に従ってください。

類推による簡単な説明

米国大統領はポリモーフィズムを採用しています。どうやって？まあ、彼には多くのアドバイザーがいます：

  1. 軍事顧問
  2. 法律顧問
  3. 核物理学者（顧問として）
  4. 医療アドバイザー
  5. などなど

全員が1つのことのみを担当する必要があります：例：

社長は亜鉛コーティングや量子物理学の専門家ではありません。彼は多くのことを知りません-しかし、彼はただ一つのことを知っています：国を運営する方法。

コードでも同じです。懸念と責任は関連するクラス/人に分離する必要があります。そうでなければ、ウィキペディア全体で、世界のすべてを文字通り知っている大統領がいるでしょう。あなたのコードのクラスにウィキペディア全体があると想像してください：維持するのは悪夢です。

なぜ大統領がこれらすべての特定のことを知るのが悪い考えなのですか？

大統領が何をすべきかを具体的に伝える場合、大統領は何をすべきかを正確に知る必要があることを意味します。大統領が特定のことを自分で知る必要がある場合、つまり、変更を加える必要がある場合は、1箇所だけでなく2箇所で行う必要があります。

たとえば、EPAが公害法を変更した場合、その場合は次のようになります。EPAクラス を大統領クラスに変更する必要があります。コードを2か所ではなく2か所で変更するのは危険です。メンテナンスがずっと難しいからです。

より良いアプローチはありますか

より良いアプローチがあります。大統領は何かの詳細を知る必要はありません-彼は、それらのことを特に任された人々から、最高のアドバイスを要求することができます。

  

彼は国を運営するために多態的なアプローチを使用できます。

例-多態的なアプローチの使用：

大統領は、人々に彼に助言するように頼むだけです-そしてそれは彼が実際に実際に行うことです-そしてそれは良い大統領がすべきことです。彼のアドバイザーはすべて異なった反応をしますが、彼らはすべて大統領の意味を知っています：Advise（）。彼は彼のオフィスに何百人もの人々をストリーミングしています。実際には、彼らが誰であるかは問題ではありません。 大統領が知っているのは、大統領に「アドバイス」するように頼むときだけです。彼らはそれに応じて対応する方法を知っています ：

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
    }
}

このアプローチにより、大統領は軍隊、医療、国際外交について何も知らずに文字通り国を運営することができます。詳細は専門家に任されています。大統領が知る必要があるのは、これだけです：＆quot; Advise（）＆quot;。

しないこと＆quot; T want： 

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();
    }
}

いいえ！いや！いや！上記のシナリオでは、大統領はすべての作業を行っています。彼は部隊数の増加と既存の条件について知っています。これは、中東の政策が変更された場合、大統領はペトラエウスのクラスも同様に コマンドを変更する必要があることを意味します。大統領がそのような詳細に動揺する必要はないので、ペトラウスのクラスを変更するだけでよいはずです。彼は詳細について知る必要はありません。彼が知る必要があるのは、彼が1つの注文をする場合、すべてが世話をされるということです。詳細はすべて専門家にお任せください。

これにより、大統領は自分の最善を尽くすことができます。一般的なポリシーを設定し、見栄えを良くし、ゴルフをプレイします。

基本クラスまたは共通インターフェースを介して実際に実装される方法

実質的には、ポリモーフィズムです。どのように正確に行われますか？ 「共通インターフェースの実装」を通じてまたは基本クラス（継承）を使用して-上記の回答をご覧ください。 （この概念をより明確に理解するには、インターフェースとは何かを知る必要があり、

多相性とは、オブジェクトのクラスを親クラスであるかのように扱う機能です。

たとえば、Animalというクラスと、Animalを継承するDogというクラスがあるとします。多態性とは、DogオブジェクトをAnimalオブジェクトとして扱う機能です。

Dog* dog = new Dog;
Animal* animal = dog;

ポリモーフィズム：

これはオブジェクト指向プログラミングの概念です。異なるオブジェクトがそれぞれ独自の方法で同一のメッセージに応答する能力をポリモーフィズムと呼びます。

多態性は、すべてのクラスが独自の名前空間に存在するという事実に起因します。クラス定義内で割り当てられた名前は、それ以外の場所で割り当てられた名前と競合しません。これは、オブジェクトのデータ構造のインスタンス変数とオブジェクトのメソッドの両方に当てはまります。

  • C構造体のフィールドが保護された名前空間にあるように、 オブジェクトのインスタンス変数です。

  • メソッド名も保護されます。 C関数の名前とは異なり、 メソッド名はグローバルシンボルではありません。 1つのメソッドの名前 クラスは他のクラスのメソッド名と競合できません。二 非常に異なるクラスが同じ名前のメソッドを実装できます。

メソッド名はオブジェクトのインターフェースの一部です。オブジェクトが何かをするように要求するメッセージが送信されると、メッセージはオブジェクトが実行するメソッドの名前を指定します。異なるオブジェクトは同じ名前のメソッドを持つことができるため、メッセージの意味は、メッセージを受信する特定のオブジェクトに関連して理解する必要があります。 2つの異なるオブジェクトに送信された同じメッセージは、2つの異なるメソッドを呼び出すことができます。

ポリモーフィズムの主な利点は、プログラミングインターフェイスが簡素化されることです。クラスごとに再利用できる規則を確立できます。プログラムに追加する新しい関数ごとに新しい名前を作成する代わりに、同じ名前を再利用できます。プログラミングインターフェイスは、それらを実装するクラスとは別に、一連の抽象的な動作として説明できます。

例：

例1： Python 2.x で記述された簡単な例を次に示します。

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 のメソッド overloading およびメソッド overrideing の概念を使用して実装されています。

ポリモーフィズムを議論するためのCarの例を考えてみましょう。フォード、ホンダ、トヨタ、BMW、ベンツなどのブランドを選択してください。すべてがタイプカーです。

ただし、それぞれに独自の高度な機能と、移動動作に関連するより高度なテクノロジーがあります。

次に、基本型のCarを作成しましょう

Car.java 

public class Car {

    int price;
    String name;
    String color;

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

}

Ford Carの例を実装しましょう。

Fordは、Car型を拡張して、そのすべてのメンバー（プロパティとメソッド）を継承します。

Ford.java 

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

上記のFordクラスはCarクラスを拡張し、move（）メソッドも実装します。 moveメソッドは継承を通じてFordですでに利用可能ですが、Fordは独自の方法でメソッドを実装しています。これはメソッドのオーバーライドと呼ばれます。

Honda.java 

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

フォードと同様に、ホンダもCarタイプを拡張し、独自の方法でmoveメソッドを実装しました。

メソッドのオーバーライドは、ポリモーフィズムを有効にする重要な機能です。メソッドのオーバーライドを使用して、Subタイプは、継承を通じて利用可能なメソッドの動作方法を変更できます。

PolymorphismExample.java 

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();

  }
}

ポリモーフィズムの出力例：

PolymorphismExampleクラスのメインメソッドでは、Car、Ford、Hondaの3つのオブジェクトを作成しました。 3つのオブジェクトはすべて、Carタイプによって参照されます。

ここで重要な点に注意してください。スーパークラス型はオブジェクトのサブクラス型を参照できますが、その逆は不可能です。その理由は、継承を使用してスーパークラスのすべてのメンバーがサブクラスで使用可能であり、コンパイル時にコンパイラが使用している参照型にアクセスしようとしているメソッドがあるかどうかを評価しようとするためです。

したがって、PolymorphismExampleの参照car、fおよびhの場合、Carメソッドからmoveメソッドが存在します

通常、これは、タイプAのオブジェクトがタイプBのオブジェクトのように動作する能力を指します。オブジェクト指向プログラミングでは、これは通常、継承によって実現されます。続きを読むウィキペディアのリンク：

編集：リンク切れを修正。

多態性は次のとおりです：

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
}

特定のインスタンスの代わりにカップのみを渡すことができます。これは、各カップタイプごとに特定のmeasure（）インスタンスを提供する必要がないため、一般性を高めます

これは多くの良い答えがある古い質問であることは知っていますが、一文の答えを含めたいです：

  

ベース型であるかのように派生型を処理します。

これが実際に動作することを示す上記の例はたくさんありますが、これは簡潔で適切な答えだと思います。

（まったく違うものに関する別の記事を閲覧していました..ポリモーフィズムが現れました...今、ポリモーフィズムが何であるかを知っていると思いました....どうやらこの美しい方法では説明されていませんでした。どこかに..それを共有する方が良い...）

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

このパートの続きを読む：

.....ポリモーフィズム。これは、異なる名詞に同じ動詞を適用できるというオタク的な方法です。

ポリモーフィズムという用語の由来は次のとおりです。

poly = many

morphism =変更する能力

プログラミングでは、ポリモーフィズムは「技術」です。これにより、「見る」ことができます。オブジェクトに複数の種類のものとして。例：

学生オブジェクトは人物オブジェクトでもあります。 「見る」場合（つまり、キャスト）学生で、おそらく学生IDを要求できます。いつも人と一緒にできるとは限りませんよね？ （人は必ずしも学生であるとは限らないため、学生IDがない場合があります）。しかし、人はおそらく名前を持っています。学生もそうです。

下の行、「見た目」異なる「角度」の同じオブジェクトでさまざまな「視点」を提供できます。 （つまり、異なるプロパティまたはメソッド）

したがって、この手法を使用すると、「見える」ものを作成できます。異なる角度から。

ポリモーフィズムを使用する理由手始めに...抽象化。この時点で十分な情報になっているはずです：）

一般的に言えば、同じまたは表面的に類似したAPIを使用して、多くの異なるタイプのオブジェクトをインターフェースする機能です。さまざまな形式があります：

  • 関数のオーバーロード：sqrt（float）、sqrt（double）、sqrt（complex）など、同じ名前で異なるパラメータータイプを持つ複数の関数を定義します。これを許可するほとんどの言語では、コンパイラーは、渡される引数のタイプに対して正しいものを自動的に選択するため、これはコンパイル時のポリモーフィズムです。

  • OOPの仮想メソッド：クラスのメソッドは、そのサブクラスの詳細に合わせてさまざまな実装を持つことができます。これらはそれぞれ、基本クラスで指定された実装をオーバーライドすると言われています。基本クラスまたはそのサブクラスのオブジェクトである可能性がある場合、正しい実装がオンザフライで選択されるため、これは実行時多態性です。

  • テンプレート：関数、クラスなどをタイプごとにパラメーター化できる、いくつかのオブジェクト指向言語の機能。たとえば、汎用の「リスト」を定義できます。テンプレートクラスを作成し、「整数のリスト」、「文字列のリスト」、場合によっては「文字列のリストのリスト」としてインスタンス化します。など。一般に、任意の要素タイプのデータ構造に対してコードを1回記述すると、コンパイラはさまざまな要素タイプに対してそのバージョンを生成します。

アナロジーを使用しましょう。与えられた音楽スクリプトについて、それを演奏するすべてのミュージシャンは、解釈に彼女自身のタッチを与えます。

ミュージシャンはインターフェイスで抽象化でき、ミュージシャンが属するジャンルは解釈のグローバルルールを定義する抽象クラスであり、演奏するすべてのミュージシャンは具体的なクラスでモデル化できます。

あなたが音楽作品のリスナーである場合、スクリプトへの参照があります。バッハの「フーガとトカタ」とそれを演奏するすべてのミュージシャンは、彼女自身の方法でそれを多形的にしています。

これは、可能な設計の単なる例です（Java）：

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());
}

別の質問に対する多型の概要を提供しました：

c ++の多態性

お役に立てば幸いです。抜粋...

  

...簡単なテストと[多態性]の定義から始めるのに役立ちます。コードを考慮してください：

Type1 x;
Type2 y;

f(x);
f(y);
  

ここで、 f（）は何らかの操作を実行するためのもので、入力として値 x および y が与えられています。ポリモーフィックであるためには、 f（）が少なくとも2つの異なるタイプ（ int および double など）の値を操作できる必要があります。タイプに適したコードの実行。

（ c ++の多態性に続く）

ポリモーフィズムは、多くの形式で使用できるオブジェクトの機能です。 たとえば、人間のクラスでは、人間関係について話すとき、男性はさまざまな形で行動できます。 例：男は息子の父親であり、妻の夫であり、生徒の教師です。

ポリモーフィズムは、オブジェクトがさまざまな形をとる能力です。 OOPでのポリモーフィズムの最も一般的な使用方法は、親クラス参照を使用して子クラスオブジェクトを参照する場合に発生します。 Javaで記述されたこの例では、3つのタイプのビークルがあります。 3つの異なるオブジェクトを作成し、wheelsメソッドを実行してみます：

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");
    }

}

結果は次のとおりです。

結果

詳細については、 https：//をご覧ください。 github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java 。役に立てば幸いです。

ポリモーフィズムとは、オブジェクトのニーズに応じて、オブジェクトの種類ごとに異なることを行う同じ名前のメソッドを記述するプログラマの能力です。たとえば、 Fraction というクラスと ComplexNumber というクラスを開発している場合、これらの両方に display（）というメソッドが含まれている可能性があります。しかし、それぞれがそのメソッドを異なる方法で実装します。たとえば、PHPでは、次のように実装できます。

//  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 "\n";

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

出力：

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

他の回答のいくつかは、ポリモーフィズムが継承と組み合わせてのみ使用されることを暗示しているようです。たとえば、 Fraction と ComplexNumber はどちらも display（）というメソッドを持つ Number という抽象クラスを実装している可能性があります。 FractionとComplexNumberはどちらも実装する必要があります。しかし、ポリモーフィズムを利用するために継承を必要する必要はありません。

少なくともPHPなどの動的に型付けされた言語（C ++やJavaについては知りません）では、開発者はポリモーフィズムを使用して、オブジェクトの型を必ずしも事前に知ることなく、メソッドの正しい実装を信頼せずにメソッドを呼び出すことができますメソッドが呼び出されます。たとえば、ユーザーが作成した Number のタイプを選択するとします。

$userNumberChoice = 
ポリモーフィズムとは、オブジェクトのニーズに応じて、オブジェクトの種類ごとに異なることを行う同じ名前のメソッドを記述するプログラマの能力です。たとえば、 Fraction というクラスと ComplexNumber というクラスを開発している場合、これらの両方に display（）というメソッドが含まれている可能性があります。しかし、それぞれがそのメソッドを異なる方法で実装します。たとえば、PHPでは、次のように実装できます。



//  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 "\n";

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




出力：



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




他の回答のいくつかは、ポリモーフィズムが継承と組み合わせてのみ使用されることを暗示しているようです。たとえば、 Fraction と ComplexNumber はどちらも display（）というメソッドを持つ Number という抽象クラスを実装している可能性があります。 FractionとComplexNumberはどちらも実装する必要があります。しかし、ポリモーフィズムを利用するために継承を必要する必要はありません。



少なくともPHPなどの動的に型付けされた言語（C ++やJavaについては知りません）では、開発者はポリモーフィズムを使用して、オブジェクトの型を必ずしも事前に知ることなく、メソッドの正しい実装を信頼せずにメソッドを呼び出すことができますメソッドが呼び出されます。たとえば、ユーザーが作成した Number のタイプを選択するとします。


<*>


この場合、ユーザーが小数を選択するか複素数を選択するかを開発者が事前に知ることができない場合でも、適切な display（）メソッドが呼び出されます。
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 "\n";

この場合、ユーザーが小数を選択するか複素数を選択するかを開発者が事前に知ることができない場合でも、適切な display（）メソッドが呼び出されます。

オブジェクト指向プログラミングでは、ポリモーフィズムとは、データ型またはクラスに応じてオブジェクトを異なる方法で処理するプログラミング言語の能力を指します。具体的には、派生クラスのメソッドを再定義する機能です。

ポリモーフィズムとは、文字通り複数の形状を意味します。 （または多くの形式）： 異なるクラスおよび同じ名前のメソッドからのオブジェクトですが、ワークフローは異なります。 簡単な例は次のとおりです。

Xを検討します。

彼は一人ですが、彼は多くの役割を果たします。 方法を尋ねることができます：

彼は母親の息子です。 彼の友人への友人。 妹の兄弟。

OOPのポリモーフィズムは、クラスが異なる型を持つことができることを意味し、継承はポリモーフィズムを実装する1つの方法です。

たとえば、 Shape はインターフェースであり、 Square 、 Circle 、 Diamond のサブタイプがあります。これで、Squareオブジェクトが作成されました。SquareはShapeであるため、SquareをShapeに自動的にアップキャストできます。しかし、ShapeをSquareにダウンキャストしようとする場合、ShapeがSquareであるとは言えないため、明示的な型キャストを行う必要があります。Circleである可能性もあります。 したがって、 Square s =（Square）shape などのコードを使用して手動でキャストする必要があります。形状がCircleの場合、Circleは正方形ではありません。

ポリモーフィズム：

  

参照変数のタイプではなく、クラスのインスタンスに応じた異なる実行。

インターフェイスタイプ参照変数は、そのインターフェイスを実装するクラスインスタンスのいずれかを参照できます。

ポリモーフィズムは、指定されたクラスでオブジェクトを使用する機能です。オブジェクトを構成するすべてのコンポーネントは、指定されたクラスのサブクラスに継承されます。これは、このオブジェクトがクラスによって宣言されると、その下のすべてのサブクラス（および最も遠い/最も低いサブクラスに到達するまでなど）がオブジェクトとそのコンポーネント（メイクアップ）を継承することを意味します。

各クラスは個別のファイルに保存する必要があることに注意してください。

次のコードはポリモーフィズムの例です：

スーパークラス： 

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");
    }
}

サブクラスである父親： 

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.");
    }
}

子、別のサブクラス： 

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?");
    }
}

実行メソッドは、親クラスを参照して開始します： 

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をさらに下に継続して使用できることに注意してください。 それがポリモーフィズムの概念です。 ここでは、継承の概念も検討します。1つのクラスを使用できるか、サブクラスによってさらに定義されます。

これが助けになり、明確になることを願っています。 コードの検証に使用できるコンピューターを見つけたら、結果を投稿します。しばらくお待ちください！

多態性により、同じルーチン（関数、メソッド）が異なる型で動作できます。

多くの既存の回答がサブタイピングとポリモーフィズムを混同しているため、ポリモーフィズムを実装する3つの方法（サブタイピングを含む）があります。

  • パラメーター（汎用）ポリモーフィズムを使用すると、ルーチンは通常のパラメーターに加えて1つ以上のタイプパラメーターを受け入れ、それらのタイプで実行されます。
  • サブタイプポリモーフィズムを使用すると、ルーチンはパラメーターの任意のサブタイプを操作できます。
  • アドホックポリモーフィズムは通常、ルーチンのオーバーロードを使用してポリモーフィックな動作を許可しますが、他のポリモーフィズムの実装も参照できます。

参照：

http://wiki.c2.com/?CategoryPolymorphism

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

オブジェクト指向言語では、ポリモーフィズムにより、同じインターフェイスを介して異なるデータ型を処理および処理できます。たとえば、C ++の継承を検討します。 クラスBはクラスAから派生します。クラスA *のポインター（クラスAへのポインター）を使用して、クラスAのオブジェクトとクラスBのオブジェクトの両方を処理できます。

コーディング用語のポリモーフィズムは、オブジェクトが継承などを通じて複数の型として存在できる場合です。「Shape」という名前のクラスを作成する場合、オブジェクトが持つ辺の数を定義すると、「スクエア」など、オブジェクトを継承する新しいクラスを作成できます。その後、「Square」のインスタンスを作成すると、その後、「Shape」から前後にキャストできます。 「スクエア」へ必要に応じて。

多態性により、別のモジュールを呼び出す1つのモジュールを作成することができますが、制御のフローではなく、制御のフローに対するコンパイル時の依存ポイントがあります。

ポリモーフィズムを使用することにより、高レベルモジュールは低レベルモジュールに依存しません。どちらも抽象化に依存しています。これは、依存関係の逆転の原則を適用するのに役立ちます（ https://en.wikipedia.org/wiki/Dependency_inversion_principle ）。

ここで、上記の定義を見つけました。ビデオの開始から約50分後、インストラクターは上記について説明します。 https://www.youtube.com/watch?v=TMuno5RZNeE

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top