Polimorfizm jest wtedy, gdy można traktować obiekt jako ogólną wersję czegoś, ale gdy uzyskujemy do niego dostęp, kod określa dokładny typ i wywołuje powiązany kod.

Oto przykład w C#. Tworzenie czterech klas w aplikacji konsolowej:

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

Utwórz teraz w Main() modułu dla aplikacji konsolowej:

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

W tym przykładzie tworzymy Listę pojazdu klasy podstawowej, który nie wie, ile kół każdy swoich podklas ma, ale wie, że każda podklasa jest odpowiedzialna za to, ile ma kół.

Następnie dodajemy Rower, Samochód i ciężarówkę do listy.

Następnie możemy przejrzeć każdy pojazd na liście i traktować je wszystkie identycznie, jednak gdy uzyskamy dostęp do właściwości "koła" każdego pojazdu, Klasa pojazdu deleguje wykonanie tego kodu do odpowiedniej podklasy.

Ten kod mówi się, że jest polimorficzny, ponieważ dokładny kod, który jest wykonywany jest określona przez podklasę, do której odwołuje się w czasie wykonywania.

From zrozumienie i zastosowanie polimorfizmu w PHP, dzięki Steve Guidetti.

Polimorfizm to długie słowo na bardzo proste pojęcie.

Polimorfizm opisuje wzorzec w programowaniu obiektowym, w którym klasy mają różną funkcjonalność przy jednoczesnym współdzieleniu wspólnego interfejsu.

Piękno polimorfizmu polega na tym, że kod pracujący z różnymi klasami nie musi wiedzieć, której klasy używa, ponieważ wszystkie są używane w ten sam sposób. Rzeczywistą analogią dla polimorfizmu jest guzik. Każdy wie, jak używać przycisku: po prostu naciskasz na niego. To, co przycisk "robi", zależy jednak od tego, do czego jest podłączony i kontekstu, w którym jest używany - ale wynik nie ma wpływu na to, jak jest używany. Jeśli twój szef każe ci nacisnąć przycisk, masz już wszystkie informacje potrzebne do wykonania zadania.

W świecie programowania polimorfizm jest wykorzystywany do tworzenia aplikacji bardziej modułowych i rozszerzalny. Zamiast niechlujnych instrukcji warunkowych opisujących różne sposoby działania, tworzy się wymienne obiekty, które wybiera się w zależności od potrzeb. To jest podstawowy cel polimorfizmu.

Jeśli ktoś powie "CUT to these people"

1. Chirurg
2. Stylistka Włosów
3. Aktor

Co się stanie?

Chirurg zaczynał robić nacięcie. Stylista fryzur zaczynał obcinać komuś włosy. [[3]] aktor nagle przestałby działać poza bieżącą sceną, czekam na wskazówki kierunkowe.

Tak więc powyższa reprezentacja pokazuje czym jest polimorfizm (ta sama nazwa, inne zachowanie) w OOP.

Jeśli wybierasz się na rozmowę kwalifikacyjną, a osoba przeprowadzająca wywiad poprosi Cię o podanie przykładu polimorfizmu na żywo w tym samym pomieszczeniu, w którym siedzimy, powiedz-

Drzwi Antywłamaniowe / Okna

Zastanawiasz Się Jak?

Przez Drzwi / Okna - człowiek może przyjść, powietrze może przyjść, światło może przyjść, deszcz może przyjść, itp.

Aby to lepiej zrozumieć i w prosty sposób użyłem powyższego przykładu.. Jeśli potrzebujesz referencji do kodu wykonaj powyższe odpowiedzi.

Polimorfizm:

Jest to pojęcie programowania obiektowego.Zdolność różnych obiektów do reagowania, każdy na swój sposób, na identyczne wiadomości nazywa się polimorfizmem.

Polimorfizm wynika z faktu, że każda klasa żyje w swojej własnej przestrzeni nazw. Nazwy przypisane w ramach definicji klasy nie są sprzeczne z nazwami przypisanymi gdziekolwiek poza nią. Dotyczy to zarówno zmiennych instancji w strukturze danych obiektu, jak i zmiennych obiektu metody:

• Tak jak pola struktury C znajdują się w chronionej przestrzeni nazw, tak są zmiennymi instancji obiektu.

• Nazwy metod są również chronione. W przeciwieństwie do nazw funkcji C, nazwy metod nie są symbolami globalnymi. Nazwa metody w jednym klasa nie może kolidować z nazwami metod w innych klasach; dwa bardzo różne klasy mogą implementować metody o identycznie nazwanych nazwach.

Nazwy metod są częścią obiektu interfejs. Gdy wiadomość jest wysyłana z prośbą o wykonanie jakiegoś zadania przez obiekt, wiadomość określa metodę, którą obiekt powinien wykonać. Ponieważ różne obiekty mogą mieć metody o tej samej nazwie, znaczenie wiadomości musi być rozumiane względem konkretnego obiektu, który otrzymuje wiadomość. Ta sama wiadomość wysłana do dwóch różnych obiektów może wywołać dwie różne metody.

Główną zaletą polimorfizmu jest to, że upraszcza interfejs programowania. Dopuszcza konwencje do być ustalone, że mogą być ponownie wykorzystane w klasie po klasie. Zamiast wymyślać nową nazwę dla każdej nowej funkcji dodanej do programu, te same nazwy mogą być ponownie użyte. Interfejs programowania może być opisany jako zbiór abstrakcyjnych zachowań, zupełnie niezależnie od klas, które je implementują.

Przykłady:

Przykład-1: Oto prosty przykład napisany w Pythonie 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()

Przykład-2: polimorfizm jest zaimplementowany w Java za pomocą Method overloading and method overriding concepts.

Ale każdy z nich ma swoje zaawansowane funkcje i bardziej zaawansowaną technologię zaangażowaną w ich zachowanie ruchu.

Teraz stwórzmy podstawowy typ samochodu

public class Car {

    int price;
    String name;
    String color;

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

}

Zaimplementujmy przykład samochodu Forda.

Ford rozszerza Typ Samochód do dziedziczenia wszystkich jego członków (właściwości i metody).

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

Powyższa Klasa Forda rozszerza klasę samochodów, a także implementuje metodę move (). Mimo że metoda move jest już dostępna dla Forda poprzez dziedziczenie, Ford nadal wdrożył metodę na swój sposób. Nazywa się to nadpisywaniem metody.

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

Podobnie jak Ford, Honda również rozszerza typ samochodu i wdrożyła metodę move we własnym sposób.

Nadpisywanie metod jest ważną cechą umożliwiającą polimorfizm. Za pomocą nadpisywania metod, podtypy mogą zmienić sposób działania metod, które są dostępne poprzez dziedziczenie.

Polimorfizmjava

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

  }
}

Przykładowy Wynik Polimorfizmu:

W głównej metodzie Polimorfizmuprzykładbłędy stworzyłem trzy obiekty-samochód, Ford i Honda. Wszystkie trzy obiekty są określone przez typ samochodu.

Proszę zwrócić uwagę na ważny punkt tutaj że typ super klasy może odnosić się do podklasy typu obiektu, ale wice-werset nie jest możliwy. Powodem jest to, że wszyscy członkowie super klasy są dostępni dla podklasy za pomocą dziedziczenia i podczas kompilacji kompilator próbuje ocenić, czy typ odniesienia, którego używamy, ma metodę, do której próbuje uzyskać dostęp.

Tak więc,dla odniesień car, f I h W Polimorfizmie, metoda move istnieje od typu Car. Tak więc kompilator przechodzi proces kompilacji bez żadnych problemów.

Ale jeśli chodzi o czas wykonania, maszyna wirtualna wywołuje metody na obiektach, które są podtypami. Tak więc metoda move() jest wywoływana z ich odpowiednich implementacji.

Tak więc wszystkie obiekty są typu Car, ale podczas uruchamiania, wykonanie zależy od obiektu, na którym ma miejsce wywołanie. Nazywa się to polimorfizmem.

Polimorfizm to zdolność do traktowania klasy obiektu tak, jakby była klasą nadrzędną.

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

Proste wyjaśnienie przez analogię

1. Doradcy Wojskowi
2. Radcy Prawni
3. fizycy jądrowi (jako doradcy)
4. doradcy medyczni
5. itd.

Każdy powinien być odpowiedzialny tylko za jedną rzecz: przykład:

Jest tak samo z kodem: obawy i obowiązki powinny być rozdzielone na odpowiednie klasy/osoby. W przeciwnym razie prezydent wiedziałby dosłownie wszystko na świecie - całą Wikipedię. Wyobraź sobie, że cała wikipedia jest klasą Twojego kodu: utrzymanie tego byłoby koszmarem.

Dlaczego to zły pomysł, żeby prezydent wiedział te wszystkie konkretne rzeczy?

Jeśli prezydent miał mówić ludziom, co mają robić, to oznaczałoby, że prezydent musi dokładnie wiedzieć, co robić. Jeśli prezydent sam musi znać konkretne rzeczy, to znaczy, że kiedy trzeba coś zmienić, trzeba to zrobić w dwóch miejscach, a nie tylko w jednym.

Na przykład, jeśli EPA zmieni przepisy dotyczące zanieczyszczeń, to kiedy tak się stanie: będziesz musiał dokonać zmiany w klasie EPAa także Klasa prezydenta. Zmiana kodu w dwóch miejsca, a nie jeden może być niebezpieczny - bo jest o wiele trudniejszy do utrzymania.

Czy jest lepsze podejście?

Potrafi posługiwać się polimorficznym podejściem do rządzenia krajem.

Przykład użycia podejścia polimorficznego:

Wszystkie prezydent prosi ludzi, aby mu doradzali - i to właśnie robi w prawdziwym życiu - i to powinien zrobić dobry prezydent. wszyscy jego doradcy reagują inaczej, ale wszyscy wiedzą, co prezydent ma na myśli: doradzać (). Ma setki ludzi w jego biurze. Nie ma znaczenia, kim oni są. wszystko, co prezydent wie, to to, że kiedy prosi ich o "poradę", wiedzą, jak odpowiednio zareagować:

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

Takie podejście pozwala na prezydent rządzić krajem dosłownie nie wiedząc nic o wojskowych rzeczy, opieki zdrowotnej lub dyplomacji międzynarodowej: szczegóły są pozostawione do ekspertów. Jedyne co prezydent musi wiedzieć to: "doradzić ()".

Czego nie chcesz:

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

To w efekcie jest polimorfizm, w skrócie. Jak dokładnie to się robi? Poprzez "implementację wspólnego interfejsu" lub za pomocą klasy bazowej ( dziedziczenie) - zobacz powyższe odpowiedzi, które szczegółowo to wyjaśniają. (Aby lepiej zrozumieć tę koncepcję, musisz wiedzieć, czym jest interfejs i musisz zrozumieć, czym jest dziedziczenie. Bez tego, ty może walczyć.)

Innymi słowy, Petraeus, Condi i HealthOfficials byłyby klasami, które "implementują interfejs" - nazwijmy go interfejsem IAdvisor, który zawiera tylko jedną metodę: Advise(). Ale teraz wchodzimy w szczegóły.

To byłoby idealne

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

Podsumowanie

Wszystko, co naprawdę musisz wiedzieć, to:

• prezydent nie musi znać szczegółów-te są pozostawione innym.
• Wszystkie prezydent musi wiedzieć, to zapytać, kto kiedykolwiek wchodzi do drzwi, aby mu doradzić - i wiemy, że będą absolutnie wiedzieć, co robić, gdy poproszony o radę (ponieważ wszyscy są w rzeczywistości doradcami (lub doradcami):)) {]}

Zazwyczaj odnosi się to do zdolności obiektu typu A do zachowania się jak obiekt typu B. w programowaniu obiektowym jest to zwykle osiągane przez dziedziczenie. Niektóre linki do wikipedii, aby przeczytać więcej:

• polimorfizm w programowaniu obiektowym
• polimorfizm typu

EDIT: Naprawiono niedziałające linki.

Polimorfizm jest taki:

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
}

Możesz przekazać tylko kubek zamiast konkretnej instancji. Pomaga to w ogólności, ponieważ nie musisz podawać konkretnej instancji measure () dla każdego typu kubka

Wiem, że jest to starsze pytanie z wieloma dobrymi odpowiedziami, ale chciałbym dołączyć odpowiedź jedno zdanie:

Traktowanie typu pochodnego tak, jakby był typem bazowym.

Istnieje wiele przykładów powyżej, które pokazują to w akcji, ale uważam, że jest to dobra zwięzła odpowiedź.

(przeglądałem inny artykuł o czymś zupełnie innym.. pojawił się polimorfizm... Teraz myślałem, że wiem, czym jest polimorfizm.... ale najwyraźniej nie w ten piękny sposób wyjaśnione.. Chciałem to gdzieś zapisać.. jeszcze lepiej się nim podzielę... )

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

Czytaj dalej z tej części:

..... polimorfizm. To jest geeky sposób na powiedzenie, że różne rzeczowniki mogą mieć ten sam czasownik stosowane do nich.

Termin polimorfizm pochodzi od:

Poly = many

Morfizm = zdolność do zmiany

W programowaniu polimorfizm jest "techniką", która pozwala "patrzeć" na obiekt jako na więcej niż jeden rodzaj rzeczy. Na przykład:

Obiekt ucznia jest również obiektem osoby. Jeśli "spojrzysz" (czyli rzucisz) na ucznia, prawdopodobnie możesz poprosić o legitymację studencką. Nie zawsze można to zrobić z osobą, prawda? (osoba niekoniecznie jest studentem, dlatego może nie mieć legitymacja studencka). Jednak osoba prawdopodobnie ma imię. Student też.

Podsumowując, "patrzenie" na ten sam obiekt z różnych "kątów" może dać różne "perspektywy" (tj. różne właściwości lub metody)

Więc ta technika pozwala budować rzeczy, które można "patrzeć"na z różnych kątów.

Dlaczego używamy polimorfizmu? Na początek ... abstrakcja. W tym momencie powinno wystarczyć info:)

Ogólnie rzecz biorąc, jest to możliwość interfejsu wielu różnych typów obiektów przy użyciu tego samego lub powierzchownie podobnego API. Istnieją różne formy:

• Przeciążanie funkcji: definiowanie wielu funkcji o tej samej nazwie i różnych typach parametrów, takich jak sqrt(float), sqrt(double) i sqrt (complex). W większości języków, które na to pozwalają, kompilator automatycznie wybierze poprawny dla typu przekazywanego do niego argumentu. polimorfizm w czasie kompilacji.

• Metody wirtualne w OOP: metoda klasy może mieć różne implementacje dostosowane do specyfiki jej podklas; każda z nich mówi się, że nadpisuje implementację podaną w klasie bazowej. Biorąc pod uwagę obiekt, który może należeć do klasy bazowej lub dowolnej z jej podklas, właściwa implementacja jest wybierana w locie, a więc jest to polimorfizm w czasie wykonywania.

• Szablony: cecha niektórych języków OO, w której funkcja, Klasa, itd. może być parametryzowany przez typ. Na przykład, możesz zdefiniować ogólną klasę szablonu "list", a następnie utworzyć jej instancję jako "list of integers", "list of strings", a może nawet "list of lists of strings" lub tym podobne. Zazwyczaj kod zapisuje się raz dla struktury danych dowolnego typu elementu, a kompilator generuje jego wersje dla różnych typów elementów.

Użyjmy analogii. Dla danego scenariusza muzycznego każdy muzyk, który go gra, daje swój własny akcent w interpretacji.

Muzyk może być abstrakcyjny za pomocą interfejsów, gatunek do którego należy muzyk może być klasą abstrakcji, która określa pewne globalne zasady interpretacji, a każdy muzyk grający może być modelowany za pomocą konkretnej klasy.

To tylko przykład możliwego projektu (w Javie):

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

Polimorfizm to zdolność programisty do pisania metod o tej samej nazwie, które robią różne rzeczy dla różnych typów obiektów, w zależności od potrzeb tych obiektów. Na przykład, jeśli tworzysz klasę o nazwie Fraction i klasę o nazwie ComplexNumber, obie z nich mogą zawierać metodę o nazwie display(), ale każda z nich zaimplementowałaby tę metodę inaczej. Na przykład w PHP możesz zaimplementować go w następujący sposób:

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

Wyjścia:

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

Niektóre z inne odpowiedzi wydają się sugerować, że polimorfizm jest używany tylko w połączeniu z dziedziczeniem; na przykład, być może Fraction i ComplexNumber oba implementują abstrakcyjną klasę o nazwie Number, która ma metodę display(), którą ułamek i numer kompleksowy są wtedy zobowiązane zaimplementować. Ale nie potrzebujesz dziedziczenia, aby wykorzystać polimorfizm.

Przynajmniej w językach dynamicznie typowanych, takich jak PHP (Nie wiem jak C++ czy Java), polimorfizm pozwala wywoływać metodę bez konieczności uprzedniej znajomości typu obiektu i ufania, że zostanie wywołana prawidłowa implementacja metody. Na przykład, powiedzmy, że użytkownik wybiera typ Number utworzonego:

$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";

W tym przypadku zostanie wywołana odpowiednia metoda display(), nawet jeśli programista nie może wcześniej wiedzieć, czy użytkownik wybierze ułamek, czy liczbę złożoną.

Podałem ogólny przegląd polimorfizmu na inne pytanie:

Polimorfizm w c++

...pomaga zacząć od prostego testu dla niego i definicji [polimorfizmu]. Rozważmy kod:

Type1 x;
Type2 y;

f(x);
f(y);

Tutaj, {[1] } ma wykonać jakąś operację i otrzymuje się wartości x i y jako dane wejściowe. Aby być polimorficznym, f() musi być w stanie działać z wartościami co najmniej dwóch różne typy (np. int i double), znajdowanie i wykonywanie kodu odpowiedniego dla typu.

( ciąg dalszy polimorfizm w c++ )

Polimorfizm oznacza dosłownie wiele kształtów. (lub wiele form) : Obiekt z różnych klas i Metoda o tej samej nazwie, ale obiegi pracy są różne. Prostym przykładem może być:

Rozważ osobę X.

On jest tylko jedną osobą, ale działa tak wiele. Możesz zapytać jak:

On jest synem dla swojej matki. Przyjaciel jego przyjaciół. Brat jego siostry.

Polimorfizm w OOP oznacza, że klasa może mieć różne typy, dziedziczenie jest jednym ze sposobów implementacji polimorfizmu.

Na przykład, Kształt jest interfejsem, ma kwadrat, Circle, Diamond podtypy. teraz masz kwadratowy obiekt, Możesz automatycznie ustawić kwadrat do kształtu, ponieważ kwadrat jest kształtem. Ale kiedy próbujesz obniżyć kształt do kwadratu, musisz wykonać wyraźne odlewanie typu, ponieważ nie możesz powiedzieć, że kształt jest kwadratowy, może to być okrąg też. więc trzeba ręcznie wrzucić go z kodem w stylu Square s = (Square)shape, co jeśli kształt jest okrąg, otrzymasz java.lang.ClassCastException, ponieważ okrąg nie jest kwadratowy.

W programowaniu obiektowym, polimorfizm odnosi się do zdolności języka programowania do przetwarzania obiektów w różny sposób w zależności od ich typu danych lub klasy . Dokładniej, jest to zdolność do redefiniowania metod dla klas pochodnych.

Polimorfizm jest zdolnością obiektu, która może być przyjmowana w wielu formach. Na przykład w klasie ludzkiej człowiek może działać w wielu formach, gdy mówimy o związkach. EX: mężczyzna jest ojcem dla syna i jest mężem dla żony i jest nauczycielem dla swoich uczniów.

Polimorfizm = > różne wykonanie w zależności od instancji klasy, a nie typu zmiennej referencyjnej.

Zmienna odniesienia typu interfejsu może odwoływać się do dowolnej instancji klasy, która implementuje ten interfejs.

Polimorfizm to zdolność obiektu do przyjmowania wielu form. Najczęstsze użycie polimorfizmu w OOP występuje, gdy odwołanie do klasy nadrzędnej jest używane do odniesienia się do obiektu klasy potomnej. W tym przykładzie, który jest napisany w Javie, mamy trzy typy pojazdów. Tworzymy trzy różne obiekty i próbujemy uruchomić ich metodę kół:

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

}

Wynik jest następujący:

Aby uzyskać więcej informacji, odwiedź https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.javamam nadzieję, że to pomoże.

Polimorfizm pozwala tej samej rutynie (funkcji, metody) działać na różnych typach.

Ponieważ wiele istniejących odpowiedzi łączy Podtyp z polimorfizmem, oto trzy sposoby (w tym Podtyp) implementacji polimorfizmu.

• polimorfizm parametryczny (ogólny) pozwala na akceptację jednego lub więcej parametrów typu, oprócz parametrów normalnych, i działa na tych typach.
• polimorfizm podtypu umożliwia rutynowe działanie na dowolny Podtyp jego parametrów.
• polimorfizm Ad hoc zazwyczaj wykorzystuje rutynowe przeciążenie, aby nadać polimorfizmowi zachowanie, ale może odnosić się również do innych implementacji polimorfizmu.

Zobacz też:

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

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

W językach zorientowanych obiektowo, polimorfizm umożliwia przetwarzanie i obsługę różnych typów danych za pomocą tego samego interfejsu. Na przykład rozważmy dziedziczenie w C++: Klasa B jest pochodną klasy A. wskaźnik typu A* (wskaźnik do klasy A) może być używany do obsługi zarówno obiektu klasy A, jak i obiektu klasy B.

Polimorfizm w sensie kodowania jest wtedy, gdy obiekt może istnieć jako wiele typów poprzez dziedziczenie itp. Jeśli utworzysz klasę o nazwie "Shape", która określa liczbę boków Twojego obiektu, możesz następnie utworzyć nową klasę, która go dziedziczy, np."Square". Kiedy następnie zrobić wystąpienie "kwadrat" można następnie rzucić go do tyłu i do przodu Z "kształt" do "kwadrat", zgodnie z wymaganiami.

Polimorfizm jest możliwością użycia obiektu w danej klasie, gdzie wszystkie komponenty składające się na obiekt są dziedziczone przez podklasy danej klasy. Oznacza to, że gdy obiekt zostanie zadeklarowany przez klasę, wszystkie podklasy poniżej niego (i inne podklasy itd., aż do osiągnięcia najdalszej/najniższej podklasy) dziedziczą obiekt i jego komponenty (makeup).

Pamiętaj, że każda klasa musi być zapisana w osobnych plikach.

Poniższy kod ilustruje Polimorfizm: {]}

Superklasa:

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

ojciec, podklasa:

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

dziecko, kolejna podklasa:

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

metoda wykonania, odwołuje się do klasy nadrzędnej, aby rozpocząć:

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

Zauważ, że każda klasa musi być zadeklarowana w osobnym *.pliki java. Kod powinien się skompilować. Zauważ również, że możesz stale używać maidenName i familyTree dalej. Że jest pojęciem polimorfizmu. Pojęcie dziedziczenia jest również rozważane tutaj, gdzie można użyć jednej klasy lub jest dalej definiowane przez podklasę.

Polimorfizm daje możliwość tworzenia jednego modułu wywołującego drugi, a jednocześnie posiada punkt zależności czasu kompilacji względem przepływu sterowania zamiast z przepływem sterowania.

Używając polimorfizmu, moduł wysokiego poziomu nie zależy od modułu niskiego poziomu. Oba zależą od abstrakcji. To pomaga nam zastosować zasadę inwersji zależności ( https://en.wikipedia.org/wiki/Dependency_inversion_principle).

Tutaj znalazłem powyższą definicję. Około 50 minut na wideo instruktor wyjaśnia powyższe. https://www.youtube.com/watch?v=TMuno5RZNeE