Polimorfizm a przeciążenie a przeciążenie

Polimorfizm to zdolność instancji klasy do zachowania się tak, jakby była instancją innej klasy w drzewie dziedziczenia, najczęściej jednej z klas przodków. Na przykład w Javie wszystkie klasy dziedziczą po obiekcie. W związku z tym można utworzyć zmienną typu Object i przypisać do niej instancję dowolnej klasy.

An override jest typem funkcji, która występuje w klasie, która dziedziczy z innej klasy. Funkcja override "zastępuje" funkcję dziedziczoną z klasy bazowej, ale robi to w taki sposób, że jest wywoływana nawet wtedy, gdy instancja jej klasy udaje inny typ poprzez polimorfizm. Odwołując się do poprzedniego przykładu, możesz zdefiniować własną klasę i nadpisać funkcję toString (). Ponieważ funkcja ta jest dziedziczona po obiekcie, nadal będzie dostępna, jeśli skopiujesz instancję tej klasy do zmiennej typu Obiektowego. Zwykle, jeśli wywołujesz ToString () na swojej klasie, gdy udaje ona obiekt, wersja toString, która faktycznie będzie uruchamiana, jest tą zdefiniowaną na samym obiekcie. Jednakże, ponieważ funkcja jest nadpisaniem, definicja ToString () z twojej klasy jest używana nawet wtedy, gdy prawdziwy typ instancji klasy jest ukryty za polimorfizmem.

Overloading jest działaniem definiującym wiele metod o tej samej nazwie, ale z różnymi parametrami. Nie ma związku ani z nadrzędnością, ani z polimorfizmem.

Oto przykład polimorfizmu w pseudo-C # / Java:

class Animal
{
    abstract string MakeNoise ();
}

class Cat : Animal {
    string MakeNoise () {
        return "Meow";
    }
}

class Dog : Animal {
    string MakeNoise () {
        return "Bark";
    }
}

Main () {
   Animal animal = Zoo.GetAnimal ();
   Console.WriteLine (animal.MakeNoise ());
}

Główna funkcja nie zna typu zwierzęcia i zależy od zachowania konkretnej implementacji metody MakeNoise ().

Edit: wygląda na to, że Brian mnie wyprzedził. Zabawne, że użyliśmy tego samego przykładu. Ale powyższy kod powinien pomóc wyjaśnić pojęcia.

Polimorfizm oznacza więcej niż jedną postać, ten sam obiekt wykonujący różne operacje zgodnie z wymogiem.

Polimorfizm można osiągnąć za pomocą dwóch sposobów, są to

1. nadpisywanie metody
2. metoda przeciążenia

metoda overloading oznacza zapis dwóch lub więcej metod w tej samej klasie przy użyciu tej samej nazwy metody, ale parametry przekazywania są inne.

nadpisanie metody oznacza, że używamy nazw metod w różne klasy, czyli metoda klasy rodzica jest używana w klasie potomnej.

W Javie aby osiągnąć polimorfizm, zmienna referencyjna super klasy może posiadać obiekt sub klasy.

Aby osiągnąć polimorfizm każdy programista musi używać tych samych nazw metod w projekcie.

Zarówno przeciążenie, jak i przeciążenie są używane do osiągnięcia polimorfizmu.

Można mieć metodę w klasie to jest overridden w jednym lub więcej podklas. Metoda robi różne rzeczy w zależności od tego, który klasa została użyta do utworzenia obiektu.

    abstract class Beverage {
       boolean isAcceptableTemperature();
    }

    class Coffee extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature > 70;
       }
    }

    class Wine extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature < 10;
       }
    }

Można też mieć metodę, która jest przeciążony dwoma lub więcej zestawami argumentów. Metoda robi różne rzeczy oparte na Typ(Y) przekazanego (- ych) argumentu (- ów).

    class Server {
        public void pour (Coffee liquid) {
            new Cup().fillToTopWith(liquid);
        }

        public void pour (Wine liquid) {
            new WineGlass().fillHalfwayWith(liquid);
        }

        public void pour (Lemonade liquid, boolean ice) {
            Glass glass = new Glass();
            if (ice) {
                glass.fillToTopWith(new Ice());
            }
            glass.fillToTopWith(liquid);
        }
    }

Masz rację, że przeciążenie nie jest odpowiedzią.

Ani nie jest nadrzędne. Nadpisywanie jest środkiem, za pomocą którego można uzyskać polimorfizm. Polimorfizm to zdolność obiektu do zmiany zachowania w zależności od jego typu. Jest to najlepiej pokazane, gdy wywołujący obiekt, który wykazuje polimorfizm, nie jest świadomy, jaki konkretny typ obiektu jest.

Konkretnie mówiąc przeciążenie lub nadpisanie nie daje pełnego obrazu. Polimorfizm to po prostu zdolność obiektu do specjalizacji jego zachowania w oparciu o jego typ.

Nie zgodziłbym się z niektórymi odpowiedziami tutaj, ponieważ przeciążenie jest formą polimorfizmu (polimorfizmu parametrycznego) w przypadku, gdy metoda o tej samej nazwie może zachowywać się inaczej, podając różne typy parametrów. Dobrym przykładem jest przeciążenie operatora. Możesz zdefiniować"+", aby akceptować różne typy parametrów-powiedzmy łańcuchów lub int - i na podstawie tych typów, " + " będzie zachowywać się inaczej.

Polimorfizm obejmuje również metody dziedziczenia i nadrzędne, choć mogą być abstrakcyjne lub wirtualne w typie bazowym. Jeśli chodzi o polimorfizm oparty na dziedziczeniu, Java obsługuje tylko dziedziczenie pojedynczej klasy, ograniczając jego zachowanie polimorficzne do zachowania pojedynczego łańcucha typów bazowych. Java obsługuje implementację wielu interfejsów, co jest kolejną formą polimorfizmu zachowanie.

Klasyczny przykład, psy i koty są zwierzętami, zwierzęta mają metodę makeNoise. Mam nadzieję, że zrobią to tam.

Kod wywoławczy nie musi wiedzieć, jakie są konkretne zwierzęta.

To jest to, co myślę o polimorfizmie.

Polimorfizm to zdolność obiektu do pojawiania się w wielu formach. Polega to na wykorzystaniu dziedziczenia i funkcji wirtualnych do budowy rodziny obiektów, które mogą być wymienne. Klasa bazowa zawiera prototypy funkcji wirtualnych, prawdopodobnie niewprowadzone lub z domyślnymi implementacjami, jak dyktuje aplikacja, a różne klasy pochodne implementują je w różny sposób, aby wpływać na różne zachowania.

Ani:

Przeciążenie jest wtedy, gdy masz tę samą nazwę funkcji, która przyjmuje różne parametry.

Nadpisywanie jest wtedy, gdy Klasa potomna zastępuje metodę rodzica własną (to samo w sobie nie stanowi polimorfizmu).

Polimorfizm jest późnym wiązaniem, np. metody klasy bazowej (rodzica) są wywoływane, ale dopiero wtedy, gdy aplikacja dowie się, czym jest rzeczywisty obiekt - może to być Klasa potomna, której metody są różne. Dzieje się tak dlatego, że każda klasa potomna może być użyta tam, gdzie zdefiniowana jest klasa bazowa.

W Javie często widać polimorfizm z biblioteką zbiorów:

int countStuff(List stuff) {
  return stuff.size();
}

List jest klasą bazową, kompilator nie ma pojęcia, czy liczysz listę połączoną, wektor, tablicę lub implementację listy niestandardowej, o ile działa ona jak Lista:

List myStuff = new MyTotallyAwesomeList();
int result = countStuff(myStuff);

Gdybyś się przeciążał to byś miał:

int countStuff(LinkedList stuff) {...}
int countStuff(ArrayList stuff) {...}
int countStuff(MyTotallyAwesomeList stuff) {...}
etc...

I poprawna wersja countStuff() zostanie wybrana przez kompilator, aby pasowała do parametrów.

Polimorfizm oznacza po prostu "wiele form".

Nie wymaga dziedziczenia do achieve...as implementacja interfejsu, która w ogóle nie jest dziedziczeniem, służy polimorficznym potrzebom. Prawdopodobnie implementacja interfejsu służy polimorficznym potrzebom "lepiej" niż dziedziczenie.

Na przykład, czy stworzyłbyś superklasę opisującą wszystkie rzeczy, które mogą latać? Nie sądzę. Najlepiej byłoby stworzyć interfejs opisujący lot i zostawić go na to.

Tak więc, ponieważ interfejsy opisują zachowanie, a nazwy metod opisują zachowanie (dla programisty), nie jest zbyt daleko, aby uznać przeciążenie metody za mniejszą formę polimorfizmu.

Termin overloading odnosi się do posiadania wielu wersji czegoś o tej samej nazwie, Zwykle metod z różnymi listami parametrów

public int DoSomething(int objectId) { ... }
public int DoSomething(string objectName) { ... }

Więc te funkcje mogą zrobić to samo, ale masz opcję, aby wywołać go z ID, lub nazwa. Nie ma nic wspólnego z dziedziczeniem, klasami abstrakcyjnymi itp.

Nadpisywanie zwykle odnosi się do polimorfizmu, jak opisałeś w swoim pytaniu

Nadpisywanie jest bardziej jak ukrywanie odziedziczonej metody poprzez zadeklarowanie metody o tej samej nazwie i sygnaturze co metoda górnego poziomu (super metoda), co dodaje zachowanie polimorficzne do klasy . innymi sĹ 'owy decyzja o wybraniu metody, ktĂłra ma byÄ ‡ wywoĹ' anaä ‡ zostanie podjęta w czasie wykonywania, a nie w czasie kompilacji . prowadzi to do koncepcji interfejsu i implementacji .

Overriding gdy dziedziczymy klasę bazową i tworzymy klasę pochodną, to jeśli w klasie pochodnej istnieje metoda, która ma taką samą nazwę jak metoda (ta sama nazwa,ten sam argument,ten sam typ powrotu) zdefiniuje w klasie bazowej, to jej wywołanie nadrzędne..

  class Vehicle{  
      void run()
          {
           System.out.println("Vehicle is running");
          }  
               }
   class Bike2 extends Vehicle{  
       void run()
           {
            System.out.println("Bike is running safely");
           }  

    public static void main(String args[]){  
    Bike2 obj = new Bike2();  
    obj.run();  
     }  

Wyjście: rower działa bezpiecznie........ Aby lepiej zrozumieć, odwiedź Stronę: http://javabyroopam.blogspot.in/

Przeciążenie Po prostu dwie metody, które mają tę samą nazwę, ale mają inną listę argumentów to zwane przeciążeniem..

   class Calculation{  
      void sum(int a,int b){System.out.println(a+b);}  
      void sum(int a,int b,int c){System.out.println(a+b+c);}  

      public static void main(String args[]){  
      Calculation obj=new Calculation();  
      obj.sum(10,10,10);  
       obj.sum(20,20);  

       }  
    }  

Wyjście 30,20

Czym jest polimorfizm?

From java tutorial

Biorąc pod uwagę przykłady i definicję, / align = "left" / należy przyjąć odpowiedź.

Odnośnie drugiego zapytania:

Jeśli miałeś abstrakcyjną klasę bazową, która zdefiniowała metodę bez implementacji i zdefiniowałeś tę metodę w podklasie, czy to nadal jest overridding?

Powinno się to nazywać nadrzędnym.

Spójrz na ten przykład, aby zrozumieć różne rodzaje nadpisywania.

1. klasa bazowa nie zapewnia implementacji, a podklasa musi nadpisać metodę pełną - (abstract)
2. klasa bazowa zapewnia domyślną implementację, a podklasa może zmienić zachowanie
3. podklasa dodaje rozszerzenie do implementacji klasy bazowej przez wywołanie super.methodName() jako pierwszej instrukcji
4. klasa bazowa definiuje strukturę algorytmu (metoda szablonowa), a podklasa nadpisuje część algorytmu

Kod fragment:

import java.util.HashMap;

abstract class Game implements Runnable{

    protected boolean runGame = true;
    protected Player player1 = null;
    protected Player player2 = null;
    protected Player currentPlayer = null;

    public Game(){
        player1 = new Player("Player 1");
        player2 = new Player("Player 2");
        currentPlayer = player1;
        initializeGame();
    }

    /* Type 1: Let subclass define own implementation. Base class defines abstract method to force
        sub-classes to define implementation    
    */

    protected abstract void initializeGame();

    /* Type 2: Sub-class can change the behaviour. If not, base class behaviour is applicable */
    protected void logTimeBetweenMoves(Player player){
        System.out.println("Base class: Move Duration: player.PlayerActTime - player.MoveShownTime");
    }

    /* Type 3: Base class provides implementation. Sub-class can enhance base class implementation by calling
        super.methodName() in first line of the child class method and specific implementation later */
    protected void logGameStatistics(){
        System.out.println("Base class: logGameStatistics:");
    }
    /* Type 4: Template method: Structure of base class can't be changed but sub-class can some part of behaviour */
    protected void runGame() throws Exception{
        System.out.println("Base class: Defining the flow for Game:");  
        while ( runGame) {
            /*
            1. Set current player
            2. Get Player Move
            */
            validatePlayerMove(currentPlayer);  
            logTimeBetweenMoves(currentPlayer);
            Thread.sleep(500);
            setNextPlayer();
        }
        logGameStatistics();
    }
    /* sub-part of the template method, which define child class behaviour */
    protected abstract void validatePlayerMove(Player p);

    protected void setRunGame(boolean status){
        this.runGame = status;
    }
    public void setCurrentPlayer(Player p){
        this.currentPlayer = p;
    }
    public void setNextPlayer(){
        if ( currentPlayer == player1) {
            currentPlayer = player2;
        }else{
            currentPlayer = player1;
        }
    }
    public void run(){
        try{
            runGame();
        }catch(Exception err){
            err.printStackTrace();
        }
    }
}

class Player{
    String name;
    Player(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

/* Concrete Game implementation  */
class Chess extends Game{
    public Chess(){
        super();
    }
    public void initializeGame(){
        System.out.println("Child class: Initialized Chess game");
    }
    protected void validatePlayerMove(Player p){
        System.out.println("Child class: Validate Chess move:"+p.getName());
    }
    protected void logGameStatistics(){
        super.logGameStatistics();
        System.out.println("Child class: Add Chess specific logGameStatistics:");
    }
}
class TicTacToe extends Game{
    public TicTacToe(){
        super();
    }
    public void initializeGame(){
        System.out.println("Child class: Initialized TicTacToe game");
    }
    protected void validatePlayerMove(Player p){
        System.out.println("Child class: Validate TicTacToe move:"+p.getName());
    }
}

public class Polymorphism{
    public static void main(String args[]){
        try{

            Game game = new Chess();
            Thread t1 = new Thread(game);
            t1.start();
            Thread.sleep(1000);
            game.setRunGame(false);
            Thread.sleep(1000);

            game = new TicTacToe();
            Thread t2 = new Thread(game);
            t2.start();
            Thread.sleep(1000);
            game.setRunGame(false);

        }catch(Exception err){
            err.printStackTrace();
        }       
    }
}

Wyjście:

Child class: Initialized Chess game
Base class: Defining the flow for Game:
Child class: Validate Chess move:Player 1
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Child class: Validate Chess move:Player 2
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Base class: logGameStatistics:
Child class: Add Chess specific logGameStatistics:
Child class: Initialized TicTacToe game
Base class: Defining the flow for Game:
Child class: Validate TicTacToe move:Player 1
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Child class: Validate TicTacToe move:Player 2
Base class: Move Duration: player.PlayerActTime - player.MoveShownTime
Base class: logGameStatistics:

Chociaż polimorfizm jest już szczegółowo wyjaśniony w tym poście, ale chciałbym położyć większy nacisk na to, dlaczego część tego.

Dlaczego polimorfizm jest tak ważny w każdym języku OOP.

Spróbujmy zbudować prostą aplikację dla telewizora z dziedziczeniem/polimorfizmem i bez niego. Po każdej wersji aplikacji robimy małą retrospektywę.

Przypuśćmy, że jesteś inżynierem oprogramowania w firmie telewizyjnej i zostaniesz poproszony o napisanie oprogramowania dla wolumenu, Kontrolery jasności i kolorów zwiększające i zmniejszające ich wartości na polecenie użytkownika.

Zaczynasz od pisania klas dla każdej z tych funkcji, dodając

1. set: - aby ustawić wartość kontrolera.(Przypuśćmy, że ma kod specyficzny dla kontrolera)
2. get: - aby uzyskać wartość kontrolera.(Przypuśćmy, że ma kod specyficzny dla kontrolera)
3. adjust: - aby zweryfikować wejście i ustawić kontroler.(Ogólne walidacje.. niezależne od Kontrolery)
4. mapowanie wejścia użytkownika za pomocą kontrolerów: - aby uzyskać wejście użytkownika i odpowiednio wywołać Kontrolery.

Wersja Aplikacji 1

import java.util.Scanner;    
class VolumeControllerV1 {
    private int value;
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of VolumeController \t"+this.value);
        this.value = value;
        System.out.println("New value of VolumeController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}
class  BrightnessControllerV1 {
    private int value;
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of BrightnessController \t"+this.value);
        this.value = value;
        System.out.println("New value of BrightnessController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}
class ColourControllerV1    {
    private int value;
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of ColourController \t"+this.value);
        this.value = value;
        System.out.println("New value of ColourController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}

/*
 *       There can be n number of controllers
 * */
public class TvApplicationV1 {
    public static void main(String[] args)  {
        VolumeControllerV1 volumeControllerV1 = new VolumeControllerV1();
        BrightnessControllerV1 brightnessControllerV1 = new BrightnessControllerV1();
        ColourControllerV1 colourControllerV1 = new ColourControllerV1();


        OUTER: while(true) {
            Scanner sc=new Scanner(System.in);
            System.out.println(" Enter your option \n Press 1 to increase volume \n Press 2 to decrease volume");
            System.out.println(" Press 3 to increase brightness \n Press 4 to decrease brightness");
            System.out.println(" Press 5 to increase color \n Press 6 to decrease color");
            System.out.println("Press any other Button to shutdown");
            int button = sc.nextInt();
            switch (button) {
                case  1:    {
                    volumeControllerV1.adjust(5);
                    break;
                }
                case 2: {
                    volumeControllerV1.adjust(-5);
                    break;
                }
                case  3:    {
                    brightnessControllerV1.adjust(5);
                    break;
                }
                case 4: {
                    brightnessControllerV1.adjust(-5);
                    break;
                }
                case  5:    {
                    colourControllerV1.adjust(5);
                    break;
                }
                case 6: {
                colourControllerV1.adjust(-5);
                break;
            }
            default:
                System.out.println("Shutting down...........");
                break OUTER;
        }

    }
    }
}

Teraz masz naszą pierwszą wersję działającej aplikacji gotową do wdrożenia. Czas na analizę dotychczas wykonanych prac.

Problemy w aplikacji TV Wersja 1

1. Kod Adjust(int value) jest duplikowany we wszystkich trzech klasach. Chciałbyś zminimalizować dwulicowość kodu. (Ale ty nie pomyślałem o wspólnym kodzie i przeniesieniu go do jakiejś super klasy, aby uniknąć duplikatów kodu) {]}

Decydujesz się z tym żyć tak długo, jak Twoja aplikacja działa zgodnie z oczekiwaniami.

Po pewnym czasie twój szef wraca do Ciebie i prosi o dodanie funkcji resetowania do istniejącej aplikacji. Reset ustawia wszystkie trzy Kontrolery na odpowiednie wartości domyślne.

Zaczynasz pisać nową klasę (ResetFunctionV2) dla nowej funkcjonalności i mapujesz użytkownika wprowadź kod mapowania dla tej nowej funkcji.

Wersja Aplikacji 2

import java.util.Scanner;
class VolumeControllerV2    {

    private int defaultValue = 25;
    private int value;

    int getDefaultValue() {
        return defaultValue;
    }
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of VolumeController \t"+this.value);
        this.value = value;
        System.out.println("New value of VolumeController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}
class  BrightnessControllerV2   {

    private int defaultValue = 50;
    private int value;
    int get()    {
        return value;
    }
    int getDefaultValue() {
        return defaultValue;
    }
    void set(int value) {
        System.out.println("Old value of BrightnessController \t"+this.value);
        this.value = value;
        System.out.println("New value of BrightnessController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}
class ColourControllerV2    {

    private int defaultValue = 40;
    private int value;
    int get()    {
        return value;
    }
    int getDefaultValue() {
        return defaultValue;
    }
    void set(int value) {
        System.out.println("Old value of ColourController \t"+this.value);
        this.value = value;
        System.out.println("New value of ColourController \t"+this.value);
    }
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}

class ResetFunctionV2 {

    private VolumeControllerV2 volumeControllerV2 ;
    private BrightnessControllerV2 brightnessControllerV2;
    private ColourControllerV2 colourControllerV2;

    ResetFunctionV2(VolumeControllerV2 volumeControllerV2, BrightnessControllerV2 brightnessControllerV2, ColourControllerV2 colourControllerV2)  {
        this.volumeControllerV2 = volumeControllerV2;
        this.brightnessControllerV2 = brightnessControllerV2;
        this.colourControllerV2 = colourControllerV2;
    }
    void onReset()    {
        volumeControllerV2.set(volumeControllerV2.getDefaultValue());
        brightnessControllerV2.set(brightnessControllerV2.getDefaultValue());
        colourControllerV2.set(colourControllerV2.getDefaultValue());
    }
}
/*
 *       so on
 *       There can be n number of controllers
 *
 * */
public class TvApplicationV2 {
    public static void main(String[] args)  {
        VolumeControllerV2 volumeControllerV2 = new VolumeControllerV2();
        BrightnessControllerV2 brightnessControllerV2 = new BrightnessControllerV2();
        ColourControllerV2 colourControllerV2 = new ColourControllerV2();

        ResetFunctionV2 resetFunctionV2 = new ResetFunctionV2(volumeControllerV2, brightnessControllerV2, colourControllerV2);

        OUTER: while(true) {
            Scanner sc=new Scanner(System.in);
            System.out.println(" Enter your option \n Press 1 to increase volume \n Press 2 to decrease volume");
            System.out.println(" Press 3 to increase brightness \n Press 4 to decrease brightness");
            System.out.println(" Press 5 to increase color \n Press 6 to decrease color");
            System.out.println(" Press 7 to reset TV \n Press any other Button to shutdown");
            int button = sc.nextInt();
            switch (button) {
                case  1:    {
                    volumeControllerV2.adjust(5);
                    break;
                }
                case 2: {
                    volumeControllerV2.adjust(-5);
                    break;
                }
                case  3:    {
                    brightnessControllerV2.adjust(5);
                    break;
                }
                case 4: {
                    brightnessControllerV2.adjust(-5);
                    break;
                }
                case  5:    {
                    colourControllerV2.adjust(5);
                    break;
                }
                case 6: {
                    colourControllerV2.adjust(-5);
                    break;
                }
                case 7: {
                    resetFunctionV2.onReset();
                    break;
                }
                default:
                    System.out.println("Shutting down...........");
                    break OUTER;
            }

        }
    }
}

Więc masz swoją aplikację gotową z funkcją resetowania. Ale teraz zaczynasz zdawać sobie sprawę, że

Problemy w aplikacji TV Wersja 2

1. jeśli do produktu zostanie wprowadzony nowy kontroler, należy zmienić kod funkcji resetowania.
2. jeśli liczba kontrolera rośnie bardzo wysoko, będziesz miał problem z utrzymaniem referencji Kontrolery.
3. kod funkcji Reset jest ściśle powiązany z kodem klasy kontrolerów (aby uzyskać i ustawić domyślne wartości).
4. Klasa funkcji Reset (ResetFunctionV2) może uzyskać dostęp do innej metody klasy kontrolera (adjust), co jest niepożądane.

W tym samym czasie, słychać od Ciebie szef, że być może trzeba dodać funkcję, w której każdy z kontrolerów, na starcie, musi sprawdzić najnowszą wersję sterownika z firmy hosted repozytorium sterowników przez internet.

Teraz zaczynasz myśleć, że ta nowa funkcja, która ma zostać dodana, przypomina funkcję resetowania i problemy z aplikacją (V2) zostaną pomnożone, jeśli nie włączysz ponownie swojej aplikacji.

Zaczynasz myśleć o użyciu dziedziczenia, aby móc wykorzystać polimorficzną zdolność Javy i dodajesz nową klasę abstrakcyjną (ControllerV3) do

1. deklaruje podpis metody get I set.
2. zawierają implementację metody adjust, która została wcześniej replikowane wśród wszystkich kontrolerów.
3. Zadeklaruj metodę setDefault, aby funkcja reset mogła być łatwo zaimplementowana z wykorzystaniem polimorfizmu.

Dzięki tym ulepszeniom masz przygotowaną wersję 3 aplikacji telewizyjnej.

Wersja Aplikacji 3

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

abstract class ControllerV3 {
    abstract void set(int value);
    abstract int get();
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
    abstract void setDefault();
}
class VolumeControllerV3 extends ControllerV3   {

    private int defaultValue = 25;
    private int value;

    public void setDefault() {
        set(defaultValue);
    }
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of VolumeController \t"+this.value);
        this.value = value;
        System.out.println("New value of VolumeController \t"+this.value);
    }
}
class  BrightnessControllerV3  extends ControllerV3   {

    private int defaultValue = 50;
    private int value;

    public void setDefault() {
        set(defaultValue);
    }
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of BrightnessController \t"+this.value);
        this.value = value;
        System.out.println("New value of BrightnessController \t"+this.value);
    }
}
class ColourControllerV3 extends ControllerV3   {

    private int defaultValue = 40;
    private int value;

    public void setDefault() {
        set(defaultValue);
    }
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of ColourController \t"+this.value);
        this.value = value;
        System.out.println("New value of ColourController \t"+this.value);
    }
}

class ResetFunctionV3 {

    private List<ControllerV3> controllers = null;

    ResetFunctionV3(List<ControllerV3> controllers)  {
        this.controllers = controllers;
    }
    void onReset()    {
        for (ControllerV3 controllerV3 :this.controllers)  {
            controllerV3.setDefault();
        }
    }
}
/*
 *       so on
 *       There can be n number of controllers
 *
 * */
public class TvApplicationV3 {
    public static void main(String[] args)  {
        VolumeControllerV3 volumeControllerV3 = new VolumeControllerV3();
        BrightnessControllerV3 brightnessControllerV3 = new BrightnessControllerV3();
        ColourControllerV3 colourControllerV3 = new ColourControllerV3();

        List<ControllerV3> controllerV3s = new ArrayList<>();
        controllerV3s.add(volumeControllerV3);
        controllerV3s.add(brightnessControllerV3);
        controllerV3s.add(colourControllerV3);

        ResetFunctionV3 resetFunctionV3 = new ResetFunctionV3(controllerV3s);

        OUTER: while(true) {
            Scanner sc=new Scanner(System.in);
            System.out.println(" Enter your option \n Press 1 to increase volume \n Press 2 to decrease volume");
            System.out.println(" Press 3 to increase brightness \n Press 4 to decrease brightness");
            System.out.println(" Press 5 to increase color \n Press 6 to decrease color");
            System.out.println(" Press 7 to reset TV \n Press any other Button to shutdown");
            int button = sc.nextInt();
            switch (button) {
                case  1:    {
                    volumeControllerV3.adjust(5);
                    break;
                }
                case 2: {
                    volumeControllerV3.adjust(-5);
                    break;
                }
                case  3:    {
                    brightnessControllerV3.adjust(5);
                    break;
                }
                case 4: {
                    brightnessControllerV3.adjust(-5);
                    break;
                }
                case  5:    {
                    colourControllerV3.adjust(5);
                    break;
                }
                case 6: {
                    colourControllerV3.adjust(-5);
                    break;
                }
                case 7: {
                    resetFunctionV3.onReset();
                    break;
                }
                default:
                    System.out.println("Shutting down...........");
                    break OUTER;
            }

        }
    }
}

Chociaż większość problemów wymienionych na liście problemów V2 została rozwiązana z wyjątkiem

Problemy w aplikacji TV Wersja 3

1. Klasa funkcji resetowania (ResetFunctionV3) może uzyskać dostęp do innej metody klasy kontrolera (adjust), co jest niepożądane.

Ponownie myślisz o rozwiązaniu tego problemu, ponieważ teraz masz jeszcze inną funkcję (aktualizację sterownika przy starcie) do wdrożenia. Jeśli go nie naprawisz, zostanie on również zreplikowany do nowych funkcji.

Więc dzielisz kontrakt zdefiniowany w klasie abstrakcyjnej i piszesz 2 interfejsy dla

1. funkcja resetowania.
2. Aktualizacja Sterownika.

I miej swój pierwszy Klasa concrete zaimplementuj je jak poniżej

Wersja Aplikacji 4

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

interface OnReset {
    void setDefault();
}
interface OnStart {
    void checkForDriverUpdate();
}
abstract class ControllerV4 implements OnReset,OnStart {
    abstract void set(int value);
    abstract int get();
    void adjust(int value)  {
        int temp = this.get();
        if(((value > 0) && (temp >= 100)) || ((value < 0) && (temp <= 0)))    {
            System.out.println("Can not adjust any further");
            return;
        }
        this.set(temp + value);
    }
}

class VolumeControllerV4 extends ControllerV4 {

    private int defaultValue = 25;
    private int value;
    @Override
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of VolumeController \t"+this.value);
        this.value = value;
        System.out.println("New value of VolumeController \t"+this.value);
    }
    @Override
    public void setDefault() {
        set(defaultValue);
    }

    @Override
    public void checkForDriverUpdate()    {
        System.out.println("Checking driver update for VolumeController .... Done");
    }
}
class  BrightnessControllerV4 extends ControllerV4 {

    private int defaultValue = 50;
    private int value;
    @Override
    int get()    {
        return value;
    }
    @Override
    void set(int value) {
        System.out.println("Old value of BrightnessController \t"+this.value);
        this.value = value;
        System.out.println("New value of BrightnessController \t"+this.value);
    }

    @Override
    public void setDefault() {
        set(defaultValue);
    }

    @Override
    public void checkForDriverUpdate()    {
        System.out.println("Checking driver update for BrightnessController .... Done");
    }
}
class ColourControllerV4 extends ControllerV4 {

    private int defaultValue = 40;
    private int value;
    @Override
    int get()    {
        return value;
    }
    void set(int value) {
        System.out.println("Old value of ColourController \t"+this.value);
        this.value = value;
        System.out.println("New value of ColourController \t"+this.value);
    }
    @Override
    public void setDefault() {
        set(defaultValue);
    }

    @Override
    public void checkForDriverUpdate()    {
        System.out.println("Checking driver update for ColourController .... Done");
    }
}
class ResetFunctionV4 {

    private List<OnReset> controllers = null;

    ResetFunctionV4(List<OnReset> controllers)  {
        this.controllers = controllers;
    }
    void onReset()    {
        for (OnReset onreset :this.controllers)  {
            onreset.setDefault();
        }
    }
}
class InitializeDeviceV4 {

    private List<OnStart> controllers = null;

    InitializeDeviceV4(List<OnStart> controllers)  {
        this.controllers = controllers;
    }
    void initialize()    {
        for (OnStart onStart :this.controllers)  {
            onStart.checkForDriverUpdate();
        }
    }
}
/*
*       so on
*       There can be n number of controllers
*
* */
public class TvApplicationV4 {
    public static void main(String[] args)  {
        VolumeControllerV4 volumeControllerV4 = new VolumeControllerV4();
        BrightnessControllerV4 brightnessControllerV4 = new BrightnessControllerV4();
        ColourControllerV4 colourControllerV4 = new ColourControllerV4();
        List<ControllerV4> controllerV4s = new ArrayList<>();
        controllerV4s.add(brightnessControllerV4);
        controllerV4s.add(volumeControllerV4);
        controllerV4s.add(colourControllerV4);

        List<OnStart> controllersToInitialize = new ArrayList<>();
        controllersToInitialize.addAll(controllerV4s);
        InitializeDeviceV4 initializeDeviceV4 = new InitializeDeviceV4(controllersToInitialize);
        initializeDeviceV4.initialize();

        List<OnReset> controllersToReset = new ArrayList<>();
        controllersToReset.addAll(controllerV4s);
        ResetFunctionV4 resetFunctionV4 = new ResetFunctionV4(controllersToReset);

        OUTER: while(true) {
            Scanner sc=new Scanner(System.in);
            System.out.println(" Enter your option \n Press 1 to increase volume \n Press 2 to decrease volume");
            System.out.println(" Press 3 to increase brightness \n Press 4 to decrease brightness");
            System.out.println(" Press 5 to increase color \n Press 6 to decrease color");
            System.out.println(" Press 7 to reset TV \n Press any other Button to shutdown");
            int button = sc.nextInt();
            switch (button) {
                case  1:    {
                    volumeControllerV4.adjust(5);
                    break;
                }
                case 2: {
                    volumeControllerV4.adjust(-5);
                    break;
                }
                case  3:    {
                    brightnessControllerV4.adjust(5);
                    break;
                }
                case 4: {
                    brightnessControllerV4.adjust(-5);
                    break;
                }
                case  5:    {
                    colourControllerV4.adjust(5);
                    break;
                }
                case 6: {
                    colourControllerV4.adjust(-5);
                    break;
                }
                case 7: {
                    resetFunctionV4.onReset();
                    break;
                }
                default:
                    System.out.println("Shutting down...........");
                    break OUTER;
            }

        }
    }
}

Teraz rozwiązano cały problem i zdałeś sobie sprawę, że dzięki dziedziczeniu i Polimorfizmowi możesz]}

1. zachowaj luźno powiązane części aplikacji.(Elementy funkcji resetowania lub aktualizacji sterowników nie muszą być informowane o rzeczywistych klasach kontrolera( głośność, jasność i kolor), każda klasa implementująca OnReset lub OnStart będzie dopuszczalne odpowiednio Resetowanie lub aktualizowanie składników funkcji sterownika).
2. Ulepszanie aplikacji staje się łatwiejsze.(Nowe dodanie kontrolera nie będzie miało wpływu na reset lub składnik aktualizacji sterownika, a teraz naprawdę łatwo jest dodać nowe)
3. Zachowaj warstwę abstrakcji.(Teraz Funkcja Reset może widzieć tylko metodę setDefault kontrolerów i funkcja Reset może widzieć tylko metodę checkForDriverUpdate kontrolerów) {]}

Nadzieja, to pomaga: -)

Przeciążenie jest wtedy, gdy zdefiniujesz 2 metody o tej samej nazwie, ale różnych parametrach

Nadpisywanie polega na zmianie zachowania klasy bazowej za pomocą funkcji o tej samej nazwie w podklasie.

Więc polimorfizm jest związany z przeciążeniem, ale tak naprawdę nie przeciążeniem.

Jednak gdyby ktoś dał mi prostą odpowiedź " nadrzędną "na pytanie" Czym jest polimorfizm?"Prosiłbym o dalsze wyjaśnienia.

Polimorfizm jest bardziej prawdopodobny, jeśli chodzi o Znaczenie ... aby przesłonić w Javie

Chodzi o różne zachowanie tego samego obiektu w różnych sytuacjach (w sposób programowania ... możesz wywoływać różne argumenty)

Myślę, że poniższy przykład pomoże Ci zrozumieć ... Chociaż nie jest to czysty kod java ...

     public void See(Friend)
     {
        System.out.println("Talk");
     }

Ale jeśli zmienimy ARGUMENT ... zachowanie zostanie zmienione ...

     public void See(Enemy)
     {
        System.out.println("Run");
     }

Osoba (tutaj "obiekt") jest taka sama ...

Polimorfizm jest wielokrotną implementacją obiektu lub można powiedzieć wielokrotną formą obiektu. powiedzmy, że masz klasę Animals jako abstrakcyjną klasę bazową i ma ona metodę o nazwie movement(), która określa sposób poruszania się zwierzęcia. Teraz w rzeczywistości mamy różne rodzaje zwierząt i one również poruszają się inaczej, niektóre z nich z 2 nogami, inne z 4, a niektóre bez nóg,itp.. Aby zdefiniować różne movement() każdego zwierzęcia na ziemi, musimy zastosować polimorfizm. Jednak potrzebujesz aby zdefiniować więcej klas tj. klasy Dogs Cats Fish itd. Następnie musisz rozszerzyć te klasy z klasy bazowej Animals i nadpisać jej metodę movement() z nową funkcjonalnością ruchu opartą na każdym posiadanym zwierzęciu. Możesz również użyć Interfaces, aby to osiągnąć. Słowo kluczowe tutaj jest nadrzędne, przeciążenie jest INNE i nie jest uważane za polimorfizm. przy przeciążeniu można zdefiniować wiele metod "o tej samej nazwie", ale z różnymi parametrami w tym samym obiekcie lub klasie.

Myślę, że chłopaki mieszają koncepcje. polimorfizm to zdolność obiektu do zachowania się inaczej w czasie działania. Aby to osiągnąć, potrzebne są dwa wymagania:

1. Późne Wiązanie
2. Spadek.

Mówiąc, że overloading oznacza coś innego niż overloading w zależności od języka, którego używasz. Na przykład w Javie nie istnieje nadpisywanie, ale przeciążanie. Overloaded metody z innym podpisem do swojej klasy bazowej są dostępne w podklasie. W przeciwnym razie byłyby one nadpisane (proszę, Zobacz, że mam na myśli teraz fakt, że nie ma sposobu na wywołanie metody klasy bazowej spoza obiektu).

Jednak w C++ tak nie jest. Każda metoda overloaded , niezależnie od tego, czy podpis jest taki sam, czy nie (różna ilość, inny typ), jest również overridden. To jest do dziś, klasa podstawowa" metoda nie jest już dostępna w podklasie, gdy jest wywoływana spoza obiektu podklasy, oczywiście.

Tak więc odpowiedź brzmi, gdy mówimy o użyciu Javy overloading . W każdym innym języku może być inaczej, jak to się dzieje w c++

Polimorfizm odnosi się do zdolności języka do jednorodnego traktowania różnych obiektów za pomocą jednego interfejsu; jako taki jest związany z nadpisywaniem, więc interfejs (lub klasa bazowa) jest polimorficzny, implementor jest obiektem, który nadpisuje (dwie twarze tego samego medalu)

W każdym razie różnica między tymi dwoma terminami jest lepiej wyjaśniona w innych językach, takich jak c++: Obiekt polimorficzny w c++ zachowuje się jak odpowiednik Javy, jeśli funkcja bazowa jest wirtualny, ale jeśli metoda nie jest wirtualna, skok kodu jest rozwiązany statycznie, A true type nie jest sprawdzany w czasie wykonywania, polimorfizm obejmuje zdolność obiektu do zachowania się inaczej w zależności od interfejsu używanego do uzyskania do niego dostępu; pozwól mi zrobić przykład w pseudocode:

class animal {
    public void makeRumor(){
        print("thump");
    }
}
class dog extends animal {
    public void makeRumor(){
        print("woff");
    }
}

animal a = new dog();
dog b = new dog();

a.makeRumor() -> prints thump
b.makeRumor() -> prints woff

(przypuśćmy, że makeRumor nie jest wirtualny)

Java tak naprawdę nie oferuje takiego poziomu polimorfizmu (zwanego także wycinaniem obiektów).

Animal a = nowy pies(); pies b = nowy dog ();

a.makeRumor() -> prints thump
b.makeRumor() -> prints woff

W obu przypadkach wydrukuje tylko woff.. ponieważ a i b odnosi się do psa klasy

import java.io.IOException;

class Super {

    protected Super getClassName(Super s) throws IOException {
        System.out.println(this.getClass().getSimpleName() + " - I'm parent");
        return null;
    }

}

class SubOne extends Super {

    @Override
    protected Super getClassName(Super s)  {
        System.out.println(this.getClass().getSimpleName() + " - I'm Perfect Overriding");
        return null;
    }

}

class SubTwo extends Super {

    @Override
    protected Super getClassName(Super s) throws NullPointerException {
        System.out.println(this.getClass().getSimpleName() + " - I'm Overriding and Throwing Runtime Exception");
        return null;
    }

}

class SubThree extends Super {

    @Override
    protected SubThree getClassName(Super s) {
        System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and Returning SubClass Type");
        return null;
    }

}

class SubFour extends Super {

    @Override
    protected Super getClassName(Super s) throws IOException {
        System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and Throwing Narrower Exception ");
        return null;
    }

}

class SubFive extends Super {

    @Override
    public Super getClassName(Super s) {
        System.out.println(this.getClass().getSimpleName()+ " - I'm Overriding and have broader Access ");
        return null;
    }

}

class SubSix extends Super {

    public Super getClassName(Super s, String ol) {
        System.out.println(this.getClass().getSimpleName()+ " - I'm Perfect Overloading ");
        return null;
    }

}

class SubSeven extends Super {

    public Super getClassName(SubSeven s) {
        System.out.println(this.getClass().getSimpleName()+ " - I'm Perfect Overloading because Method signature (Argument) changed.");
        return null;
    }

}

public class Test{

    public static void main(String[] args) throws Exception {

        System.out.println("Overriding\n");

        Super s1 = new SubOne(); s1.getClassName(null);

        Super s2 = new SubTwo(); s2.getClassName(null);

        Super s3 = new SubThree(); s3.getClassName(null);

        Super s4 = new SubFour(); s4.getClassName(null);

        Super s5 = new SubFive(); s5.getClassName(null);

        System.out.println("Overloading\n");

        SubSix s6 = new SubSix(); s6.getClassName(null, null);

        s6 = new SubSix(); s6.getClassName(null);

        SubSeven s7 = new SubSeven(); s7.getClassName(s7);

        s7 = new SubSeven(); s7.getClassName(new Super());

    }
}