다형성이란 무엇이며, 그 목적은 무엇이며 어떻게 사용됩니까?

용어의 그리스어 뿌리에 대해 생각하면 분명해집니다.

• 폴리 = 다수 : 폴리곤 =다면, 폴리스티렌 = 많은 스티렌 ^(a) , 폴리 글롯 = 많은 언어 등.
• Morph = 변화 또는 형태 : 형태 = 생물학적 형태 연구, Morpheus = 어떤 형태를 취할 수있는 그리스의 꿈의 신.

따라서 다형성은 (프로그래밍에서) 다른 기본 형태 (데이터 유형)에 대해 동일한 인터페이스를 제시하는 능력입니다.

예를 들어, 많은 언어에서 정수와 부동 소수점은 유형이 다르기 때문에 상관없이 더하기, 빼기, 곱하기 등을 할 수 있기 때문에 암시 적으로 다형성입니다. 그것들은 일반적인 용어로는 거의 객체로 간주되지 않습니다.

그러나, 같은 방식으로, 같은 클래스 BigDecimal또는 Rational나 Imaginary또한 서로 다른 데이터 유형에서 작동하더라도, 그 작업을 제공 할 수 있습니다.

고전적인 예는 Shape클래스와 클래스에서 상속 할 수있는 모든 클래스 (정사각형, 원, 12 면체, 불규칙 다각형, 표시 등)입니다.

다형성을 사용하면 이러한 각 클래스는 서로 다른 기본 데이터를 갖습니다. 점 모양에는 두 개의 좌표 만 필요합니다 (물론 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에서 다형성을 적용 , 감사 스티브 GUIDETTI.

다형성은 매우 간단한 개념의 긴 단어입니다.

다형성은 공통 인터페이스를 공유하면서 클래스가 다른 기능을 갖는 객체 지향 프로그래밍의 패턴을 설명합니다.

다형성의 장점은 다른 클래스로 작업하는 코드가 모두 같은 방식으로 사용되므로 사용중인 클래스를 알 필요가 없다는 것입니다. 다형성에 대한 실제 비유는 버튼입니다. 누구나 버튼 사용법을 알고 있습니다. 버튼에 압력을 가하기 만하면됩니다. 그러나 버튼의 기능은 연결된 기능과 사용되는 컨텍스트에 따라 달라 지지만 결과는 사용 방법에 영향을 미치지 않습니다. 상사가 버튼을 누르라고 지시하면 이미 작업을 수행하는 데 필요한 모든 정보가 있습니다.

프로그래밍 세계에서 다형성은 애플리케이션을보다 모듈적이고 확장 가능하게 만드는 데 사용됩니다. 다양한 행동 과정을 설명하는 복잡한 조건문 대신 필요에 따라 선택할 수있는 상호 교환 가능한 객체를 만듭니다. 이것이 다형성의 기본 목표입니다.

이 사람들에게 CUT이라고하면

1. 외과 의사
2. 헤어 스타일리스트
3. 배우

무슨 일이 일어날 것?

• 외과 의사는 절개를 시작합니다.
• 헤어 스타일리스트는 누군가의 머리카락을 자르기 시작합니다.
• 액터는 감독의 안내를 기다리면서 현재 장면에서 갑자기 연기를 중단합니다.

위의 표현은 OOP에서 다형성 (동일한 이름, 다른 동작)이란 무엇입니까?

면접을 보러 가고 면접관이 우리가 앉아있는 같은 방에서 다형성에 대한 생생한 예를 말하고 보여 주면

답변-문 / 창문

어떻게 궁금하십니까?

문 / 창을 통해-사람이 올 수 있고, 공기가 올 수 있고, 빛이 올 수 있으며, 비가 올 수 있습니다.

더 잘 이해하고 간단한 방법으로 위의 예제를 사용했습니다. 코드에 대한 참조가 필요한 경우 위의 답변을 따르십시오.

유추에 의한 간단한 설명

미국 대통령은 다형성을 사용합니다. 어떻게? 글쎄, 그는 많은 고문이 있습니다.

1. 군 고문
2. 법률 고문
3. 핵 물리학 자 (고문으로)
4. 의료 고문
5. 등

모두 한 가지만 책임 져야합니다. 예 :

이 대통령은 아연 코팅 또는 양자 물리학 전문가가 아닙니다. 그는 많은 것을 알지 못하지만 한 가지만 알고 있습니다. 국가를 운영하는 방법.

코드와 동일합니다. 우려와 책임은 관련 클래스 / 사람으로 분리되어야합니다. 그렇지 않으면 전 세계 위키피디아 전체의 모든 것을 아는 대통령이있을 것입니다. 전체 위키 백과를 코드 클래스에 포함한다고 상상해보십시오. 유지하기가 악몽 일 것입니다.

대통령이 이러한 모든 구체적인 것을 아는 것이 왜 나쁜 생각입니까?

대통령이 사람들에게 무엇을해야하는지 구체적으로 말해 주어야한다면 대통령이 알아야 할 것입니다 정확히 합니다. 대통령이 특정 사항을 스스로 알아야하는 경우, 변경해야 할 때 한 곳이 아닌 두 곳에서 변경해야한다는 것을 의미합니다.

예를 들어, EPA가 오염 법률을 변경하면 그럴 때 EPA 클래스 와 대통령 클래스를 변경해야합니다 . 한 곳이 아닌 두 곳에서 코드를 변경하면 유지 관리가 훨씬 어렵 기 때문에 위험 할 수 있습니다.

더 나은 접근 방법이 있습니까?

더 나은 접근 방법이 있습니다. 대통령은 어떤 세부 사항도 알 필요가 없습니다. 특히 그러한 일을하는 사람들에게 최고의 조언을 요구할 수 있습니다.

그는 다국적 접근법을 사용하여 국가를 운영 할 수 있습니다.

다형성 접근법을 사용하는 예-

모든 대통령은 사람들에게 그에게 조언 해달라고 요청합니다. 이것이 그가 실제로 실제로하는 일이며, 좋은 대통령이해야 할 일입니다. 그의 고문들은 모두 다르게 반응하지만, 대통령의 의미를 알고 있습니다 : 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 클래스 만 변경하면됩니다. 그는 세부 사항에 대해 알 필요가 없습니다. 그가 알아야 할 것은 그가 한 번 주문하면 모든 것이 처리된다는 것입니다. 모든 세부 사항은 전문가에게 맡겨야합니다.

이를 통해 대통령은 자신이 가장 잘하는 일을 할 수있다 : 일반 정책을 세우고, 외모를 보며 골프를 치는 행위 : P.

기본 클래스 또는 공통 인터페이스를 통해 실제로 어떻게 구현됩니까?

그 사실은 간단히 말해서 다형성입니다. 정확히 어떻게 이루어 집니까? "공통 인터페이스 구현" 또는 기본 클래스 (상속)를 사용하여-보다 명확하게 설명하는 위의 답변을 참조하십시오. (이 개념을보다 명확하게 이해하려면 인터페이스가 무엇인지 알아야하고 상속이 무엇인지 이해해야합니다. 그렇지 않으면 어려움을 겪을 수 있습니다.)

즉, Petraeus, Condi 및 HealthOfficials는 모두 "인터페이스를 구현하는"클래스입니다 . IAdvisor하나의 메서드 만 포함 된 인터페이스라고하겠습니다 Advise(). 그러나 지금 우리는 세부 사항에 들어가고 있습니다.

이것은 이상적 일 것입니다

    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 함수의 이름과 달리 메서드 이름은 전역 기호가 아닙니다. 한 클래스의 메소드 이름은 다른 클래스의 메소드 이름과 충돌 할 수 없습니다. 매우 다른 두 클래스는 동일한 이름의 메소드를 구현할 수 있습니다.

메소드 이름은 객체 인터페이스의 일부입니다. 객체가 무언가를하도록 요청하는 메시지가 전송되면 메시지는 객체가 수행해야하는 방법의 이름을 지정합니다. 다른 객체는 동일한 이름의 메서드를 가질 수 있으므로 메시지의 의미는 메시지를받는 특정 객체와 관련하여 이해해야합니다. 두 개의 다른 객체로 전송 된 동일한 메시지는 두 개의 고유 한 메소드를 호출 할 수 있습니다.

다형성의 주요 이점은 프로그래밍 인터페이스를 단순화한다는 것입니다. 수업이 끝난 후 수업에서 재사용 할 수있는 협약을 수립 할 수 있습니다. 프로그램에 추가하는 새로운 기능마다 새로운 이름을 발명하는 대신 동일한 이름을 재사용 할 수 있습니다. 프로그래밍 인터페이스는 구현하는 클래스와 별개로 일련의 추상 동작으로 설명 할 수 있습니다.

예 :

예 -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 로 구현됩니다. 개념을 .

다형성을 논의하기위한 Car 예제를 고려해 보자. 포드, 혼다, 토요타, BMW, 벤츠 등과 같은 모든 브랜드를 선택하십시오.

그러나 각각에는 고유 한 고급 기능과 이동 동작과 관련된 고급 기술이 있습니다.

이제 기본형 자동차를 만들어 봅시다

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 () 메서드도 구현합니다. Ford에서 상속을 통해 이동 방법을 이미 사용할 수 있지만 Ford는 여전히 고유 한 방식으로 방법을 구현했습니다. 이를 메소드 재정의라고합니다.

Honda.java

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

포드와 마찬가지로 혼다는 자동차 유형을 확장하고 자체 방식으로 이동 방법을 구현했습니다.

메소드 재정의는 다형성을 가능하게하는 중요한 기능입니다. 메소드 재정의를 사용하여 하위 유형은 상속을 통해 사용 가능한 메소드 작동 방식을 변경할 수 있습니다.

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 클래스 main 메소드에서 Car, Ford 및 Honda의 세 가지 오브젝트를 작성했습니다. 세 가지 개체는 모두 Car 유형으로 나타납니다.

여기서 슈퍼 클래스 유형은 하위 클래스 유형의 객체를 참조 할 수 있지만 그 반대는 불가능하다는 점에 유의하십시오. 그 이유는 상속을 사용하여 수퍼 클래스의 모든 멤버를 서브 클래스에서 사용할 수 있고 컴파일 시간 동안 컴파일러가 사용중인 참조 유형에 액세스하려는 메소드가 있는지 평가하려고 시도하기 때문입니다.

따라서 PolymorphismExample의 참조 car, f 및 h의 경우 이동 방법은 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
}

특정 인스턴스 대신 컵만 전달할 수 있습니다. 각 컵 유형마다 특정 measure () 인스턴스를 제공 할 필요가 없기 때문에 일반적으로 도움이됩니다.

나는 이것이 좋은 답변이 많은 오래된 질문이라는 것을 알고 있지만 한 문장으로 답변하고 싶습니다.

파생 된 유형을 기본 유형 인 것처럼 취급합니다.

위의 예제가 실제로 작동하는 것을 보여 주지만 이것이 좋은 간결한 답변이라고 생각합니다.

(나는 완전히 다른 무언가에 대한 다른 기사를 탐색하고 있었다. 그리고 다형성이 튀어 나왔다 ... 이제 나는 다형성이 무엇인지 알고 있다고 생각했다. 더 나은 여전히 ​​그것을 공유 할 것입니다 ...)

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

이 부분에서 읽으십시오 :

..... 다형성. 그것은 다른 명사에 동일한 동사가 적용될 수 있다고 말하는 괴짜 방법입니다.

일반적으로, 동일하거나 표면적으로 유사한 API를 사용하여 여러 유형의 객체를 인터페이스 할 수 있습니다. 다양한 형태가 있습니다 :

• 함수 오버로딩 : sqrt (float), sqrt (double) 및 sqrt (complex)와 같이 동일한 이름과 다른 매개 변수 유형으로 여러 함수를 정의합니다. 이를 허용하는 대부분의 언어에서 컴파일러는 전달되는 인수 유형에 대해 올바른 것을 자동으로 선택하므로 컴파일 타임 다형성입니다.

• OOP의 가상 메소드 : 클래스의 메소드는 서브 클래스의 특성에 맞게 다양한 구현을 가질 수 있습니다. 이들 각각은 기본 클래스에 제공된 구현을 재정의한다고합니다. 기본 클래스 또는 하위 클래스 중 하나 일 수있는 개체가 주어지면 올바른 구현이 즉시 선택되므로 런타임 다형성입니다.

• 템플릿 : 함수, 클래스 등을 유형별로 매개 변수화 할 수있는 일부 OO 언어의 기능입니다. 예를 들어, 일반 "목록"템플릿 클래스를 정의한 다음 "정수 목록", "문자열 목록", "문자열 목록"등으로 인스턴스화 할 수 있습니다. 일반적으로 임의 요소 유형의 데이터 구조에 대해 코드를 한 번 작성하면 컴파일러는 다양한 요소 유형에 대한 코드 버전을 생성합니다.

다형성이라는 용어는 다음과 같습니다.

폴리 = 많은

형태 = 변화하는 능력

프로그래밍에서 다형성은 객체를 하나 이상의 유형으로 보는 것을 가능하게하는 "기술"입니다. 예를 들어 :

학생 대상도 개인 대상입니다. 학생을 "보면"(예 : 출연) 학생 ID를 요청할 수 있습니다. 항상 사람과 함께 할 수는 없습니다. (사람은 반드시 학생 일 필요는 없으므로 학생 ID가 없을 수도 있습니다). 그러나 사람은 아마도 이름을 가지고있을 것입니다. 학생도 마찬가지입니다.

결론적으로, 다른 "각도"에서 동일한 객체를 "보는"것은 다른 "관점"(즉, 다른 속성 또는 방법)을 제공 할 수 있습니다

따라서이 기술을 사용하면 다른 각도에서 "볼 수있는"물건을 만들 수 있습니다.

왜 다형성을 사용 하는가? 우선 ... 추상화. 이 시점에서 충분한 정보가 있어야합니다 :)

유추를 사용합시다. 주어진 뮤지컬 스크립트의 경우 연주하는 모든 음악가는 해석에 자신의 손길을줍니다.

음악가는 인터페이스로 추상화 할 수 있으며, 음악가가 속한 장르는 일부 글로벌 해석 규칙을 정의하는 절대 클래스가 될 수 있으며 연주하는 모든 음악가는 구체적인 클래스로 모델링 할 수 있습니다.

뮤지컬 작품을 듣는 사람이라면 Bach의 'Fuga and Tocata'와 같은 스크립트를 참조하며이를 연주하는 모든 음악가는 자신의 방식으로 다형성을합니다.

다음은 가능한 디자인의 예일뿐입니다 (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()되려면 유형에 맞는 코드를 찾고 실행하는 두 가지 이상의 고유 한 유형 (예 : int및 double)의 값으로 작동 할 수 있어야합니다 .

( C ++의 다형성에서 계속 )

다형성은 여러 형태로 취할 수있는 물체의 능력입니다. 예를 들어 인간 계급에서 사람은 우리가 관계에 관해 이야기 할 때 여러 형태로 행동 할 수 있습니다. 예 : 남자는 아들의 아버지이고, 아내의 남편이며, 학생들에게 교사입니다.

다형성은 객체가 여러 형태를 취할 수있는 능력입니다. OOP에서 다형성의 가장 일반적인 사용은 부모 클래스 참조가 자식 클래스 개체를 참조하는 데 사용될 때 발생합니다. Java로 작성된이 예제에는 세 가지 유형의 차량이 있습니다. 우리는 세 가지 다른 객체를 만들고 바퀴 방법을 실행하려고합니다.

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라는 추상 클래스 구현 두 Number방법이 display()다음을 모두 구현하는 의무가 분수와 ComplexNumber 객체를,. 그러나 당신은 필요 하지 않습니다 다형성을 이용하기 위해 상속이 .

적어도 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()개발자가 사용자가 분수 또는 복소수를 선택할지 여부를 미리 알 수 없지만 적절한 방법이 호출됩니다.

객체 지향 프로그래밍에서 다형성은 데이터 유형 또는 클래스에 따라 객체를 다르게 처리 하는 프로그래밍 언어의 기능을 나타냅니다 . 보다 구체적으로, 파생 클래스의 메서드를 재정의하는 기능입니다.

다형성이란 말 그대로 여러 모양을 의미합니다. (또는 여러 형식) : 다른 클래스 및 동일한 이름 메소드의 객체이지만 워크 플로는 다릅니다. 간단한 예는 다음과 같습니다.

사람 X를 생각해보십시오.

그는 단 한 사람이지만 많은 사람으로 행동합니다. 당신은 방법을 물을 수 있습니다 :

그는 어머니의 아들입니다. 친구에게 친구. 동생의 형제.

OOP의 다형성은 클래스가 다른 유형을 가질 수 있음을 의미하며 상속은 다형성을 구현하는 한 가지 방법입니다.

예를 들어 Shape 는 인터페이스이며 Square , Circle , Diamond 하위 유형이 있습니다. 이제 정사각형 오브젝트가 있으므로 정사각형이 모양이므로 정사각형을 자동으로 업 캐스트 할 수 있습니다. 그러나 셰이프를 정사각형으로 다운 캐스트하려고하면 명시 적 유형 캐스팅을 수행해야합니다. Shape가 정사각형이라고 말할 수 없기 때문에 Circle 일 수도 있습니다. 따라서 Circle이 정사각형이 아니기 때문에 Square s = (Square)shape모양이 Circle 인 경우 얻을 수있는 것과 같은 코드로 수동으로 캐스팅해야합니다 java.lang.ClassCastException.

다형성 :

참조 변수의 유형이 아니라 클래스의 인스턴스에 따라 다른 실행.

인터페이스 유형 참조 변수는 해당 인터페이스를 구현하는 모든 클래스 인스턴스를 참조 할 수 있습니다.

다형성은 주어진 클래스에서 객체를 사용하는 능력으로, 객체를 구성하는 모든 구성 요소가 주어진 클래스의 서브 클래스에 의해 상속됩니다. 즉,이 객체가 클래스에 의해 선언되면 그 아래의 모든 서브 클래스 (및 가장 하위 / 가장 낮은 서브 클래스에 도달 할 때까지 서브 클래스 등)가 오브젝트와 컴포넌트 (메이크업)를 상속합니다.

각 클래스는 별도의 파일로 저장해야합니다.

다음 코드는 다형성을 보여줍니다.

슈퍼 클래스 :

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

실행 방법은 Parent 클래스를 참조하여 시작합니다.

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를 계속 더 멀리 사용할 수 있습니다. 이것이 다형성의 개념입니다. 상속 개념도 여기에서 살펴볼 수 있는데, 여기서 하나의 클래스를 사용하거나 서브 클래스로 추가 정의 할 수 있습니다.

이것이 도움이되고 분명해지기를 바랍니다. 코드를 확인하는 데 사용할 수있는 컴퓨터를 찾으면 결과를 게시합니다. 양해 해 주셔서 감사합니다.

다형성은 동일한 루틴 (함수, 방법)이 다른 유형에 작용할 수 있도록합니다.

기존의 많은 답변이 다형성으로 하위 유형을 확대하고 있기 때문에 다형성을 구현하는 세 가지 방법 (하위 유형 포함)이 있습니다.

• 매개 변수 (일반) 다형성 은 루틴이 일반 매개 변수 외에 하나 이상의 유형 매개 변수를 승인하고 해당 유형에서 자체 실행됩니다.
• 하위 유형 다형성 은 루틴이 매개 변수의 하위 유형에 작용할 수 있도록합니다.
• 임시 다형성은 일반적으로 일상적인 오버로드를 사용하여 다형성 동작을 부여하지만 다른 다형성 구현도 참조 할 수 있습니다.

또한보십시오:

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

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

객체 지향 언어에서 다형성은 동일한 인터페이스를 통해 다른 데이터 유형을 처리하고 처리 할 수있게합니다. 예를 들어, C ++에서 상속을 고려하십시오. 클래스 B는 클래스 A에서 파생됩니다. A * 유형의 포인터 (A 클래스에 대한 포인터)는 클래스 A의 오브젝트와 클래스 B의 오브젝트를 모두 처리하는 데 사용될 수 있습니다.

코딩 용어의 다형성은 상속 등을 통해 객체가 여러 유형으로 존재할 수있는 경우입니다. 객체의면 수를 정의하는 "Shape"라는 클래스를 만들면 "Square와 같은 객체를 상속하는 새 클래스를 만들 수 있습니다. ". 나중에 "Square"인스턴스를 만들면 필요에 따라 "Shape"에서 "Square"로 앞뒤로 캐스트 할 수 있습니다.

다형성은 다른 모듈을 호출하는 하나의 모듈을 작성하는 기능을 제공하지만 제어 흐름 대신 제어 흐름에 대해 컴파일 시간 종속성 지점을 갖습니다.

다형성을 사용함으로써 고수준 모듈은 저수준 모듈에 의존하지 않습니다. 둘 다 추상화에 의존합니다. 이것은 의존성 역전 원리를 적용하는 데 도움이됩니다 ( https://en.wikipedia.org/wiki/Dependency_inversion_principle ) .

이것이 위의 정의를 찾은 곳입니다. 강사는 비디오에서 약 50 분 동안 위의 내용을 설명합니다. https://www.youtube.com/watch?v=TMuno5RZNeE

다형성이란 무엇입니까?

다형성은 다음과 같은 능력입니다.

• 일반화 된 유형이 아닌 특수화 된 유형의 메소드를 호출하는 동안 일반화 된 유형 만 알면 특수한 유형의 인스턴스에 대한 조작을 호출하십시오 . 동적 다형성 입니다.

• 저장 이름은 있지만 매개 변수가 다른 여러 메소드를 정의하십시오 . 정적 다형성 입니다.

역사 정의와 가장 중요한 경우 첫 번째.

다형성이란 무엇입니까?

클래스 계층 구조의 강력한 형식 일관성을 만들고 유형을 알지 않고도 부모 유형 중 하나와 데이터 바인딩을 모르는 다른 유형의 객체 목록을 관리하는 것과 같은 마술 같은 일 을 할 수 있습니다.

강하고 약한 타이핑

견본

Point, Line, Rectangle 및 Circle과 같은 일부 Shapes는 Draw () 작업에서 아무것도 지우거나 매개 변수를 사용하여 지우는 시간 초과를 설정합니다.

public class Shape
{
 public virtual void Draw()
 {
   DoNothing();
 }
 public virtual void Draw(int timeout)
 {
   DoNothing();
 }
}

public class Point : Shape
{
 int X, Y;
 public override void Draw()
 {
   DrawThePoint();
 }
}

public class Line : Point
{
 int Xend, Yend;
 public override Draw()
 {
   DrawTheLine();
 }
}

public class Rectangle : Line
{
 public override Draw()
 {
   DrawTheRectangle();
 }
}

var shapes = new List<Shape> { new Point(0,0), new Line(0,0,10,10), new rectangle(50,50,100,100) };

foreach ( var shape in shapes )
  shape.Draw();

여기서 Shape 클래스와 Shape.Draw () 메서드는 추상으로 표시해야합니다.

그들은 이해하기위한 것이 아닙니다.

설명

다형성이 없으면 추상 가상 재정의를 사용하여 모양을 구문 분석하는 동안 CLR로 호출되는 Spahe.Draw () 메서드 만 호출 할 메서드를 모릅니다. 그래서 우리가 행동하는 타입의 메소드를 호출합니다. 그리고리스트 선언 때문에 타입은 Shape입니다. 따라서 코드는 전혀 아무것도하지 않습니다.

다형성을 사용하면 CLR은 가상 테이블이라고하는 것을 사용하여 실제 객체 유형 을 유추 할 수 있습니다. 그래서 그것은 좋은 전화 방법을 여기서 Shape가 Point 인 경우 Shape.Draw ()를 호출하면 Point.Draw ()가 호출됩니다. 따라서 코드는 모양을 그립니다.

더 많은 독서

C #-다형성 (수준 1)

Java의 다형성 (수준 2)

다형성 (C # 프로그래밍 가이드)

가상 메소드 테이블