あなたがこの用語のギリシャ語のルーツについて考えるならば、それは明白になるはずです。
- ポリ=多：多角形=多面、ポリスチレン=多スチレン （a）、polyglot =多くの言語など.
- 形態＝変化または形態：形態＝生物学的形態の研究、形態素＝あらゆる形態をとることができる夢のギリシャの神。
そのため、ポリモーフィズムとは、（プログラミングにおいて）基礎となるさまざまな形式（データ型）に対して同じインターフェースを提示する能力です。
たとえば、多くの言語では、型が異なるという事実に関係なく、加算、減算、乗算などを実行できるため、整数と浮動小数点数は暗黙的に多相です。通常の用語では、それらがオブジェクトと見なされることはめったにありません。
しかし、同じように、BigDecimalやRationalやImaginaryのようなクラスも、それらが異なるデータ型を操作していてもそれらの操作を提供することができます。
古典的な例はShapeクラスとそれから継承できるすべてのクラス（正方形、円、十二面体、不規則な多角形、スプラットなど）です。
多態性では、これらの各クラスは異なる基礎データを持ちます。ポイントシェイプに必要な座標は2つだけです（もちろん2次元空間にあると仮定）。円は中心と半径を必要とします。正方形または長方形には、左上隅と右下隅に2つの座標と（おそらく）回転が必要です。不規則な多角形は一連の線を必要とします。
そのコードとそのデータに責任を持たせることで、多態性を実現できます。この例では、すべてのクラスが独自のDraw()関数を持ち、クライアントコードは単に以下のようにすることができます。
shape.Draw()
どんな形でも正しい振る舞いをするために。
これは、コードがデータから分離されていて、drawSquare()やdrawCircle()のような関数を持っていたという古いやり方とは対照的です。
オブジェクト指向、ポリモーフィズム、および継承はすべて密接に関連した概念であり、それらは知ることが不可欠です。私の長いキャリアの中では、基本的にはちょっと気まぐれになった多くの「銀の弾丸」がありましたが、OOパラダイムは良いものであることがわかりました。それを学び、理解し、それを愛しなさい - あなたはあなたがしたことがうれしいでしょう:-)
（a） 私はもともと冗談としてそれを書いたが、それは正しいことが判明し、したがって、それほど面白くない。モノマーのスチレンはたまたま炭素と水素から作られていますC8H8、そしてポリスチレンはそのグループから作られています(C8H8)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。
多態性は非常に単純な概念のための長い言葉です。
ポリモーフィズムは、共通のインタフェースを共有しながらクラスが異なる機能を持つオブジェクト指向プログラミングのパターンを表します。
ポリモフィズムの利点は、さまざまなクラスを扱うコードが、どのクラスを使用しているのかを知る必要がないことです。これらはすべて同じ方法で使用されるからです。ポリモーフィズムの現実世界の例えはボタンです。誰もがボタンの使い方を知っています：あなたは単にそれに圧力をかけるだけです。ただし、ボタンの「動作」は、そのボタンが接続されている内容と使用されるコンテキストによって異なりますが、結果はボタンの使用方法には影響しません。上司からボタンを押すように指示された場合は、タスクを実行するために必要なすべての情報がすでにあります。
プログラミングの世界では、アプリケーションをよりモジュール化し、拡張可能にするためにポリモーフィズムが使用されています。さまざまな行動方針を記述する面倒な条件文の代わりに、ニーズに基づいて選択した交換可能なオブジェクトを作成します。それが多型の基本的な目標です。
誰かがこれらの人々にCUTを言ったら
- 外科医
- ヘアスタイリスト
- 俳優
何が起こるか？
- 外科医は切開を始めます。
- ヘアスタイリストは誰かの髪をカットし始めます。
- 俳優は、監督の指導を待って、現在の場面の外で行動することを突然停止するでしょう。
そのため、上の表現はOOPの多態性（同名、異なる動作）を示しています。
もしあなたがインタビューを受けようとしていてインタビュアーが私達が座っているのと同じ部屋で多型の実例を教えたり見せたりするように頼むなら
答え - ドア/窓
疑問に思う？
ドア/窓から - 人が来ることができる、空気が来ることができる、光が来ることができる、雨が来ることができるなど.
理解を深めるために、私は上記の例を使用しました。あなたがコードの参照を必要とするならば、上記の答えに従ってください。
類推による簡単な説明
米国大統領はポリモーフィズムを採用しています。どうやって？まあ、彼には多くのアドバイザーがいます：
- 軍事顧問
- 法律顧問
- 核物理学者（アドバイザーとして）
- 医療顧問
- などなど.
全員が1つのことのみを担当する必要があります：例：
社長は亜鉛コーティングや量子物理学の専門家ではありません。彼は多くのことを知りません-しかし、彼はただ一つのことを知っています：国を運営する方法。
コードについても同じです。懸念と責任は関連するクラス/人に分離する必要があります。そうでなければ、ウィキペディア全体で、世界のすべてを文字通り知っている大統領がいるでしょう。あなたのコードのクラスにウィキペディア全体があると想像してください：維持するのは悪夢です。
なぜ大統領がこれらすべての特定のことを知るのが悪い考えなのですか？
大統領が具体的に何をすべきかを人々に伝える場合、それは大統領が何をすべきかを正確に知る必要があることを意味します。大統領が特定のことを自分で知る必要がある場合、つまり、変更を行う必要がある場合、1つだけでなく2つの場所で変更する必要があります。
たとえば、EPAが公害に関する法律を変更した場合、それが起こった場合：EPAクラスを変更する必要がありますand Presidentクラス。コードを1箇所ではなく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
}
}
このアプローチにより、大統領は軍事、医療、国際外交について何も知らずに文字通り国を運営することができます。詳細は専門家に任されています。大統領が知る必要があるのは、「Advise（）」だけです。
あなたがしたくないもの：
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();
}
}
いや！いや！いや！上記のシナリオでは、大統領はすべての作業を行っています。彼は部隊数の増加と既存の条件について知っています。これは、中東の政策が変更された場合、大統領は自分の命令およびPetraeusクラスも変更する必要があることを意味します。大統領がそのような詳細に動揺する必要はないので、ペトラウスのクラスを変更するだけでよいはずです。彼は詳細について知る必要はありません。彼が知る必要があるのは、彼が1つの注文をする場合、すべてが世話をされるということです。詳細はすべて専門家にお任せください。
これにより、大統領は自分の最善を尽くすことができます。一般的なポリシーを設定し、見栄えを良くし、ゴルフをします。
実際に実装される方法-基本クラスまたは共通インターフェースを介して
それは事実上、多態性です。どのように正確に行われますか？ 「共通インターフェースの実装」を通じてまたは基本クラス（継承）を使用して-上記の回答を参照して、これをより詳細に説明します。 （この概念をより明確に理解するには、インターフェースとは何かを知る必要があり、継承とは何かを理解する必要があります。それなしでは苦労するかもしれません。）
言い換えれば、Petraeus、Condi、HealthOfficialsはすべて「インターフェースを実装する」クラスです。1つのメソッドAdvise()のみを含むIAdvisorインターフェースと呼びましょう。しかし、今、私たちは詳細に入ります。
これが理想的です
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);
}
}
概要
あなたが本当に知る必要があるのはこれだけです：
- 大統領はその詳細を知る必要はありません-それらは他人に任されています。
- 大統領が知っておく必要があるのは、誰が彼にアドバイスするためにドアに歩いて来るか尋ねることです-そして、彼らはアドバイスを求められたときに何をすべきかを絶対に知っていることを知っています
それがあなたのお役に立てば幸いです。何もわからない場合はコメントを投稿して、もう一度やり直してください。
多態性とは、オブジェクトのクラスを親クラスであるかのように扱う機能です。
たとえば、Animalというクラスと、Animalを継承したDogというクラスがあるとします。ポリモーフィズムとは、DogオブジェクトをAnimalオブジェクトとして扱う機能です。
Dog* dog = new Dog;
Animal* animal = dog;
多型：
それはオブジェクト指向プログラミングの概念です。それぞれが独自の方法で同一のメッセージに応答するさまざまなオブジェクトの能力は、ポリモーフィズムと呼ばれます。
多態性は、すべてのクラスが独自のネームスペースに存在するという事実から生じます。クラス定義内で割り当てられた名前は、その外側以外で割り当てられた名前と競合しません。これは、オブジェクトのデータ構造内のインスタンス変数とオブジェクトのメソッドの両方に当てはまります。
C構造体のフィールドが保護された名前空間にあるように、オブジェクトのインスタンス変数も同様です。
メソッド名も保護されています。 C関数の名前とは異なり、メソッド名はグローバルシンボルではありません。あるクラスのメソッド名が他のクラスのメソッド名と競合しないようにしてください。 2つのまったく異なるクラスが同じ名前のメソッドを実装できます。
メソッド名はオブジェクトのインターフェースの一部です。オブジェクトが何かをすることを要求するメッセージが送信されると、そのメッセージはそのオブジェクトが実行すべきメソッドを指定します。異なるオブジェクトは同じ名前のメソッドを持つことができるので、メッセージの意味はそのメッセージを受け取る特定のオブジェクトに関連して理解されなければなりません。 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 usingメソッド オーバーロード およびmethod オーバーライド の概念で実装されています。
多態性を議論するために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型を拡張してそのすべてのメンバ（プロパティとメソッド）を継承します。
フォードジャバ
public class Ford extends Car{
public void move(){
System.out.println("Moving with V engine");
}
}
上記のFordクラスはCarクラスを拡張したもので、move（）メソッドも実装しています。 moveメソッドは継承を通じてすでにFordに利用可能ですが、Fordはまだ独自の方法でメソッドを実装しています。これはメソッドオーバーライドと呼ばれます。
ホンダジャバ
public class Honda extends Car{
public void move(){
System.out.println("Move with i-VTEC engine");
}
}
フォードと同じように、ホンダも車のタイプを拡張し、独自の方法で移動方法を実装しました。
メソッドのオーバーライドは、多態性を有効にするための重要な機能です。メソッドオーバーライドを使用して、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では、moveメソッドはCar型から存在します。そのため、コンパイラは問題なくコンパイルプロセスを通過します。
しかし、実行時には、仮想マシンはサブタイプであるオブジェクトのメソッドを呼び出します。そのため、メソッドmove（）はそれぞれの実装から呼び出されます。
したがって、すべてのオブジェクトはCar型ですが、実行時には、実行は呼び出しが発生したオブジェクトに依存します。これは多態性と呼ばれます。
通常これは、タイプ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
}
特定のインスタンスの代わりにCupだけを渡すことができます。あなたはそれぞれのカップタイプごとに特定のmeasure（）インスタンスを提供する必要がないのでこれは一般性を助ける
（私は全く別のものについての別の記事を閲覧していました。そして多相性が現れました...今、私は多型性が何であるか知っていると思いました…もっと共有しましょう...）
http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife
この部分から読んでください。
.....多態性それは、異なる名詞が同じ動詞をそれらに適用することができると言うのにこっけいな方法です。
私はこれがたくさんの良い答えを持つより古い質問であることを知っています、しかし私は一文の答えを含めたいです。
派生型を基本型であるかのように扱う.
これを実際に示す例はたくさんありますが、これは簡潔な答えであると私は思います。
多型という用語は、
ポリ=多数
形態論=変化する能力
プログラミングにおいて、ポリモーフィズムは、オブジェクトを複数の種類のものとして「見る」ことを可能にする「技法」です。例えば：
学生オブジェクトは人物オブジェクトでもあります。学生を「見る」（キャスト）する場合は、おそらく学生IDを尋ねることができます。あなたはいつも人と一緒にそうすることはできませんね。 （人は必ずしも学生ではないので、学生IDを持っていないかもしれません）。しかし、人はおそらく名前を持っています。学生もします。
結論として、異なる「角度」から同じオブジェクトを「見る」と、異なる「視点」（つまり、異なるプロパティやメソッド）が得られます。
そのため、この手法では、さまざまな角度から「見る」ことができるものを構築できます。
多型を使用するのはなぜですか。初心者のために…抽象化。この時点でそれは十分な情報であるはずです:)
一般的に言えば、それは同じまたは表面的に類似したAPIを使用して多数の異なるタイプのオブジェクトをインターフェースする能力です。さまざまな形式があります。
関数のオーバーロード：sqrt（float）、sqrt（double）、sqrt（complex）など、同じ名前で異なるパラメータ型を持つ複数の関数を定義します。これを可能にするほとんどの言語では、コンパイラーは渡される引数のタイプに対して正しいものを自動的に選択するため、これはコンパイル時ポリモーフィズムです。
OOPの仮想メソッド：クラスのメソッドは、そのサブクラスの詳細に合わせて調整されたさまざまな実装を持つことができます。これらはそれぞれ、基本クラスで指定された実装をオーバーライドすると言われています。基本クラスまたはそのサブクラスのいずれかである可能性があるオブジェクトを考えると、正しい実装がオンザフライで選択されるため、これは実行時ポリモーフィズムです。
テンプレート：いくつかのOO言語の機能で、関数、クラスなどを型によってパラメータ化することができます。たとえば、一般的な「リスト」テンプレートクラスを定義し、それを「整数のリスト」、「文字列のリスト」、さらには「文字列のリストのリスト」などとしてインスタンス化できます。一般に、任意の要素型のデータ構造に対して1回コードを書くと、コンパイラはさまざまな要素型に対してそのバージョンを生成します。
多態性は、オブジェクトがさまざまな形をとる能力です。 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は両方とも実装する必要があります。しかし、多相性を利用するためにneed継承をしないでください。
少なくともPHP（C++やJavaについては知りません）のような動的に型付けされた言語では、ポリモーフィズムにより、開発者は事前にオブジェクトの型を必ずしも知ることなくメソッドを呼び出すことができ、メソッドの正しい実装が呼び出されます。たとえば、作成されたNumberのタイプを選択するとします。
$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 "\n";
この場合、ユーザーが分数を選択するか複素数を選択するかを開発者が事前に知ることはできませんが、適切なdisplay()メソッドが呼び出されます。
多態性は、さまざまな形で解釈できるオブジェクトの機能です。たとえば人間関係では、人間は人間関係について話すときにさまざまな形で行動することができます。例：男は息子の父親であり、妻の夫であり、生徒の先生です。
OOPの多態性はクラスが異なる型を持つことができることを意味します。継承は多態性を実装する1つの方法です。
例えば、 Shape はインターフェースで、 Square 、 Circle 、 Diamond のサブタイプがあります。 SquareはShapeなので、Squareオブジェクトを持っているので、SquareをShapeに自動的にアップキャストすることができます。しかし、ShapeをSquareに変換するときは、明示的に型キャストを行う必要があります。ShapeがSquareとは言えないので、Circleでもかまいません。そのため、手動でSquare s = (Square)shapeのようなコードでそれをキャストする必要があります。形状がCircleの場合、CircleはSquareではないので、Java.lang.ClassCastExceptionを取得します。
アナロジーを使ってみましょう。与えられた音楽の脚本のためにそれを演奏するすべてのミュージシャンは解釈において彼女自身の接触を与えます。
ミュージシャンはインターフェースで抽象化でき、ミュージシャンが属するジャンルはグローバルな通訳規則を定義する抽象クラスで、演奏するすべてのミュージシャンは具体的なクラスでモデル化できます。
あなたが音楽作品のリスナーであるならば、あなたは脚本への参照を持っています。バッハの「フーガとトカタ」とそれを実行するすべてのミュージシャンは、それを自分のやり方で多形的にします。
これは（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());
}
多型は文字通り、複数の形を意味します。 （または多くの形式）：異なるクラスと同じ名前メソッドからのオブジェクトですが、ワークフローは異なります。簡単な例は次のようになります。
人Xを考えます。
彼は一人だけですが、彼は多くの人として行動します。あなたはどうやって尋ねることができます：
彼は母親の息子です。彼の友達への友達。彼の妹への兄弟。
多態性は、同じルーチン（関数、メソッド）が異なるタイプに作用することを可能にします。
多くの既存の回答がサブタイプと多相を混同しているので、多相を実装するための3つの方法（サブタイプを含む）があります。
- パラメトリック（総称）多態性 は、通常のパラメーターに加えて、ルーチンが1つ以上のタイプ・パラメーターを受け入れることを可能にし、それらのタイプで実行されます。
- サブタイプ多型 は、ルーチンがそのパラメータの任意のサブタイプに作用することを可能にします。
- アドホックポリモーフィズム は、一般的に、ルーチンのオーバーロードを使用してポリモーフィック動作を許可しますが、他のポリモーフィズム実装も参照できます。
また見なさい：
http://wiki.c2.com/?CategoryPolymorphism
https://en.wikipedia.org/wiki/Polymorphism_(computer_science）
ポリモーフィズムとは、オブジェクトを構成するすべてのコンポーネントが特定のクラスのサブクラスによって継承される、特定のクラスでオブジェクトを使用する機能です。つまり、このオブジェクトがクラスによって宣言されると、その下にあるすべてのサブクラス（および最上位/最下位のサブクラスに達するまでなど）は、オブジェクトとそのコンポーネント（メイクアップ）を継承します。
各クラスは別々のファイルに保存する必要があることを忘れないでください。
次のコードは多態性の例です。
スーパークラス：
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つのクラスが使われることができるか、またはさらにサブクラスによって定義されます。
これが助けになり、それが明確になることを願っています。コードの検証に使用できるコンピューターが見つかったら、結果を掲載します。忍耐をありがとう！
Polymorphism =>参照変数の型ではなく、クラスのインスタンスによって実行が異なります。
インターフェース型参照変数は、そのインターフェースを実装するクラスインスタンスを参照できます。
オブジェクト指向プログラミングでは、多態性はプログラミング言語のオブジェクトのデータ型またはクラスに応じて異なる方法でオブジェクトを処理する能力を指します。より具体的には、派生クラスのメソッドを再定義する機能です。
多態性を使用すると、あるモジュールから別のモジュールを呼び出すことができますが、コンパイル時の依存関係は、制御の流れではなく制御の流れに対して発生します。
多態性を使用することで、高水準モジュールは低水準モジュールに依存しません。どちらも抽象化に依存しています。これは依存性の逆転の原則を適用するのに役立ちます（ https://en.wikipedia.org/wiki/Dependency_inversion_principle ）.
これが私が上記の定義を見つけたところです。ビデオの約50分後、講師は上記の説明をします。 https://www.youtube.com/watch?v=TMuno5RZNeE
コーディングの観点から見たポリモーフィズムとは、継承などによってオブジェクトが複数の型として存在できる場合です。オブジェクトの辺の数を定義する「Shape」という名前のクラスを作成すると、「Square」などの継承クラスを作成できます"その後「Square」のインスタンスを作成するときに、必要に応じて「Shape」から「Square」に前後にキャストできます。
オブジェクト指向言語では、ポリモーフィズムにより、同じインターフェースを介してさまざまなデータ型の処理と処理が可能になります。たとえば、C++での継承を考えます。クラスBはクラスAから派生しています。クラスAのオブジェクトとクラスBのオブジェクトの両方を処理するには、タイプA *のポインター（クラスAへのポインター）を使用できます。