Зачем использовать полиморфизм?

У меня есть следующий код, в котором у меня есть родительский класс и его дочерний. Я пытаюсь определить, как код выигрывает от использования полиморфизма.

class FlyingMachines {
    public void fly() {
        System.out.println("No implementation");
    }
}

class Jet extends FlyingMachines {
    public void fly() {
        System.out.println("Start, Taxi, Fly");
    }

    public void bombardment() {
        System.out.println("Throw Missile");
    }
}

public class PolymorphicTest {
    public static void main(String[] args) {
        FlyingMachines flm = new Jet();
        flm.fly();

        Jet j = new Jet();
        j.bombardment();
        j.fly();
    }
}

В чем преимущество полиморфизма, когда обаflm.fly() а такжеj.fly() дайте мне тот же ответ?

 baig77216 июн. 2012 г., 17:08
Именно так. Спасибо @Shaharyar
 khan16 июн. 2012 г., 17:06
Я думаю, он хочет знать, есть ли разница между flm.fly () и j.fly ()? Если да? тогда что?

Ответы на вопрос(13)

это не очень много, преимущество будет, когда у вас есть разные FlyingMachines, например самолет

Теперь, когда вы изменили включение большего числа классов, преимущество полиморфизма состоит в том, что абстракция от того, какой конкретный тип (и бизнес-концепция) полученного вами экземпляра, вас просто волнует, что он может летать.

 baig77216 июн. 2012 г., 16:59
Спасибо @Sebastian Piu - Позвольте мне добавить еще два дочерних класса 1) Heli 2) Самолет - Так что я знаю, что мой вопрос все тот же.

по которой вы используете полиморфизм, заключается в том, что вы создаете общие фреймворки, которые принимают целую кучу разных объектовwith the same interface, Когда вы создаете новый тип объекта, вам не нужно изменять каркас, чтобы приспособить новый тип объекта, если он следует «правилам». объекта.

Так что в вашем случае более полезным примером является создание объекта типа «Аэропорт» который принимает различные типы FlyingMachines. Аэропорт определит «AllowPlaneToLand» функция, аналогичная:

//pseudocode
void AllowPlaneToLand(FlyingMachine fm)
{
    fm.LandPlane();
}

Пока каждый тип FlyingMachine определяет правильный метод LandPlane, он может правильно приземлиться. Аэропорту не нужно ничего знать о FlyingMachine, за исключением того, что для посадки самолета ему необходимо вызвать LandPlane на FlyingMachine. Таким образом, аэропорту больше не нужно менять, и он может продолжать принимать новые типы FlyingMachines, будь то ручной планер, НЛО, парашют и т. Д.

Таким образом, полиморфизм полезен для каркасов, построенных вокруг этих объектов, которые могут получить общий доступ к этим методам без необходимости их изменения.

Полиморфизм (и время выполнения, и время компиляции) необходимо в Java по нескольким причинам.

Переопределение метода являетсяrun time polymorphism и перегрузкаcompile time polymorphism.

Немногие из них (некоторые из них уже обсуждались):

Collections: Suppose you have multiple type of flying machines and you want to have them all in a single collection. You can just define a list of type FlyingMachines and add them all.

List<FlyingMachine> fmList = new ArrayList<>();
fmList.add(new new JetPlaneExtendingFlyingMachine());
fmList.add(new PassengerPlanePlaneExtendingFlyingMachine());

The above can be done only by polymorphism. Otherwise you would have to maintain two separate lists.

Caste one type to another : Declare the objects like :

FlyingMachine fm1 = new JetPlaneExtendingFlyingMachine();
FlyingMachine fm2 = new PassengerPlanePlaneExtendingFlyingMachine();
fm1 = fm2; //can be done

Overloading: Not related with the code you gave, But overloading is also another type of polymorphism called compile time polymorphism.

Can have a single method which accepts type FlyingMachine handle all types i.e. subclasses of FlyingMachine. Can only be achieved with Polymorphism.

это поможет вам понять использование полиморфизма.

class FlyingMachines {
    public void fly() {
        System.out.println("No implementation");
    }
}

class Jet extends FlyingMachines {
    public void fly() {
        System.out.println("Start, Jet, Fly");
    }
}

class FighterPlan extends FlyingMachines {
    public void fly() {
        System.out.println("Start, Fighter, Fight");
    }
}

public class PolymorphicTest {
    public static void main(String[] args) {
        FlyingMachines flm = new Jet();
        flm.fly();

        FlyingMachines flm2 = new FighterPlan();
        flm2.fly();
    }
}

Выход:

Start, Jet, Fly
Start, Fighter, Fight

почему полиморфизм необходим в java, заключается в том, что эта концепция широко используется при реализации наследования. Она играет важную роль в предоставлении объектам, имеющим разные внутренние структуры, одного и того же внешнего интерфейса.

поскольку у вас есть только один подклассFlyingMachine, Полиморфизм становится полезным, если у вас есть несколько видовFlyingMachine, Тогда у вас может быть метод, который принимает любой видFlyingMachine и использует егоfly() метод. Примером может бытьtestMaxAltitude(FlyingMachine).

Еще одна особенность, которая доступна только при полиморфизме, - это способность иметьList<FlyingMachine> и использовать его для храненияJet, Kite, или жеVerySmallPebbles.

Один из лучших примеров использования полиморфизма - это возможность ссылаться на интерфейсы, а не на реализации.

Например, лучше иметь метод, который возвращаетList<FlyingMachine> а неArrayList<FlyingMachine>, Таким образом, я могу изменить свою реализацию в методе наLinkedList илиStack не нарушая любой код, который использует мой метод.

 11 мар. 2018 г., 19:27
@TimPote Такой хороший ответ когда-либо ...
 16 июн. 2012 г., 17:02
@cheeken Я просто обновлял свой ответ, когда ты это писал. Смотрите мои обновления.
 16 июн. 2012 г., 17:00
+1, но более близким примером для демонстрации полезности может быть использованиеList<FlyingMachine> а неList<Jet>.

Он используется, когда объект вашего концептуального проекта можно рассматривать как специализацию другого объекта. Основная идея - «специализация». Отличным примером является так называемая таксономия, например, применяемая к живым существам. Собаки и люди являются млекопитающими. Это означает, что класс Mammals группирует всех сущностей, имеющих общие свойства и поведение.

Кроме того, ElectricCar и DieselCar являются специализацией автомобилей. Таким образом, у обоих есть isThereFuel (), потому что, когда вы ведете автомобиль, вы ожидаете знать, достаточно ли топлива для его вождения. Еще одна отличная концепция - «ожидание».

Всегда хорошая идея нарисовать диаграмму ER (отношения сущностей) домена вашего программного обеспечения перед его запуском. Это связано с тем, что вы вынуждены представлять, какие типы сущностей будут создаваться, и, если вы достаточно способны, вы можете сэкономить много кода, обнаруживая общее поведение между сущностями. Но сохранение кода - не единственное преимущество хорошего проекта.

Возможно, вам будет интересно узнать о так называемой «разработке программного обеспечения» что это набор приемов и концепций, который позволяет писать «чистый код»; (есть также большая книга под названием «Чистый код», которая широко предлагается программами).

Решение Вопроса

наследование представляет собой отношение IS-A, обычно мы можем сказать что-то вроде «пусть нашFlyingMachines летать & Quot ;. каждый конкретныйFlyingMachines (подкласс) IS-AFlyingMachines (родительский класс), скажемJetПодходит это "давай нашиFlyingMachines fly & quot ;, в то время как мы хотим, чтобы это fly фактически было функцией fly конкретного (подкласса), этот полиморфизм вступает во владение.

так что мы делаем вещи абстрактно, ориентированные интерфейсы и базовый класс, на самом деле не зависят от реализации деталей, полиморфизм сделает правильную вещь!

 baig77218 июн. 2012 г., 14:30
хм да это очищает мое замешательство :)

if & quot; условные выражения, предназначенные для создания кода производственного уровня, поскольку удаление условных обозначений повысит читабельность кода и поможет нам лучше писать примеры модульных тестов, которые мы знаем как & quot; n & quot; если есть n! (n факториальных) возможностей.

Давайте посмотрим, как

если у вас есть класс FlyingMachine, который принимает в конструкторе строку, определяющую тип FlyMachine, как показано ниже

class FlyingMachine{

    private type;

    public FlyingMachine(String type){
             this.type = type;
    }

    public int getFlyingSpeedInMph {
         if(type.equals("Jet"))
              return 600;
         if(type.equals("AirPlane"))
              return 300;
    }

 }

Мы можем создать два экземпляра FlyingMachine как

 FlyingMachine jet = new FlyingMachine("Jet");
 FlyingMachine airPlane = new FlyingMachine("AirPlane");

и получить скорость, используя

 jet.fylingSpeedInMph();
 airPlane.flyingSpeedInMph();

Но если вы используете полиморфизм, вы удалите условия if, расширив универсальный класс FlyMachine и переопределив getFlyingSpeedInMph, как показано ниже

class interface FlyingMachine {

     public int abstract getFlyingSpeedInMph;
}


class Jet extends FlyingMachine {
    @Override
    public int getFlyingSpeedInMph(){
          return 600;
    }
}

class Airplane extends FlyingMachine {
    @Override
    public int getFlyingSpeedInMph(){
          return 600;
    }
}

Теперь вы можете получить скорость полета, как показано ниже

 FlyingMachine jet = new Jet();
 jet.flyingSpeed();

 FlyingMachine airPlane = new AirPlane();
 airPlane.flyingSpeed();

Давайте поймем, почему и когда нам нужен полиморфизм.

Предположим, есть разные виды машин (например, автомобиль, скутер, стиральная машина, электродвигатель и т. Д.), И мы знаем, что каждая машина запускается и останавливается. Но логика запуска и остановки машины различна для каждой машины. Здесь каждая машина будет иметь разные реализации для запуска и остановки. Итак, для обеспечения разных реализаций нам нужен полиморфизм.

Здесь мы можем иметь машину базового класса сstart() а такжеstop() как его методы, и каждый тип машины может расширить эту функциональность и@Override эти методы.

flm.fly() а такжеj.fly() дать вам тот же ответ, потому что тип экземпляра на самом деле тот же, которыйJetпоэтому они ведут себя одинаково.

Вы можете увидеть разницу, когда вы:

FlyingMachines flm = new FlyingMachines();
flm.fly();

Jet j = new Jet();
j.bombarment();
j.fly();

Полиморфизм определяется как сигнатура одного метода с разным поведением. Как видите, обаFlyingMachines а такжеJet есть методfly() определен, но метод реализован по-другому, которые считают, что ведут себя по-разному.

Увидеть аа

Polymorphism
 16 июн. 2012 г., 18:02
Нет, переопределение определяется как одна и та же сигнатура метода с различным поведением. Полиморфизм - это более широкое представление, которое по существу включает в себя создание объекта одного типа и обработку его как другого типа (то есть обработку Jet как FlyingMachine). Наследование, переопределение и перегрузка - это инструменты, которые позволяют достичь эффективного полиморфизма (переопределение и перегрузка - это то, что называется специальным полиморфизмом).

flm.fly() and j.fly() give me the same answer?

Преимущество в том, что

FlyingMachines flm = new Jet();
flm.fly();

возвращается

"Start, Taxi, Fly"

вместо

"No implementation"

Это полиморфизм. Ты звонишьfly() на объекте типаFlyingMachine и он до сих пор знает, что это на самом делеJet и вызывает соответствующийfly() метод вместо неправильного, который выводит"No implementation".

Это означает, что вы можете написать методы, которые работают с объектами типаFlyingMachine и кормить его всеми видами подтипов, таких какJet или жеHelicopter и эти методы всегда будут делать правильные вещи, то есть вызыватьfly() метод соответствующего типа вместо того, чтобы всегда делать одно и то же, то есть выводить"No implementation".

Polymorphism

Полиморфизм бесполезен в вашем примере.

a) It gets useful when you have different types of objects and can write classes that can work with all those different types because they all adhere to the same API.

b) It also gets useful when you can add new FlyingMachines to your application without changing any of the existing logic.

а) и б) две стороны одной медали.

Позвольте мне показать, как.

Code example
import java.util.ArrayList;
import java.util.List;

import static java.lang.System.out;

public class PolymorphismDemo {

    public static void main(String[] args) {
        List<FlyingMachine> machines = new ArrayList<FlyingMachine>();
        machines.add(new FlyingMachine());
        machines.add(new Jet());
        machines.add(new Helicopter());
        machines.add(new Jet());

        new MakeThingsFly().letTheMachinesFly(machines);
    }
}

class MakeThingsFly {
    public void letTheMachinesFly(List<FlyingMachine> flyingMachines) {
        for (FlyingMachine flyingMachine : flyingMachines) {
            flyingMachine.fly();
        }
    }
}

class FlyingMachine {
    public void fly() {
        out.println("No implementation");
    }
}

class Jet extends FlyingMachine {
    @Override
    public void fly() {
        out.println("Start, taxi, fly");
    }

    public void bombardment() {
        out.println("Fire missile");
    }
}

class Helicopter extends FlyingMachine {
    @Override
    public void fly() {
        out.println("Start vertically, hover, fly");
    }
}
Explanation

а)MakeThingsFly класс может работать со всем, что имеет типFlyingMachine.

б) методletTheMachinesFly также работает без каких-либо изменений (!) при добавлении нового класса, напримерPropellerPlane:

public void letTheMachinesFly(List<FlyingMachine> flyingMachines) {
        for (FlyingMachine flyingMachine : flyingMachines) {
            flyingMachine.fly();
        }
    }
}

Это сила полиморфизма. Вы можете реализоватьразомкнут-принцип с этим.

polymorphism as stated clear by itself, a one which mapped for many.

java - это ой язык, поэтому он имеет реализацию для него путем абстрагирования, перегрузки и переопределения

помните, у java не было бы спецификации для полиморфизма во время выполнения.

у этого есть лучший пример для этого также.

public abstract class Human {

    public abstract String getGender();

}

class Male extends Human
{
    @Override
    public String getGender() {
        return "male";
    }
}

class Female extends Human
{
    @Override
    public String getGender() {
        return "female";
    }
}

Overriding

переопределить поведение базового класса. например, я хочу добавить подсчет скорости в существующую функциональность движения в моей базовой машине.

Overloading

может иметь поведение с тем же именем с другой подписью. например, конкретный президент говорит громко, а другой - только громко.

Ваш ответ на вопрос