O que é polimorfismo, o que é e como é utilizado?

https://stackoverflow.com/questions/1031273

06-07-2019
|

Pergunta

Solução

Se você pensar nas raízes gregas do termo, ele deve se tornar óbvio.

Poli = muitos: poligon = muitos lados, poliestireno = muitos estilosos ^(uma), poliglota = muitos idiomas, e assim por diante.
Morph = mudança ou forma: morfologia = estudo da forma biológica, morfeu = o deus grego dos sonhos capazes de assumir qualquer forma.

Portanto, o polimorfismo é a capacidade (na programação) de apresentar a mesma interface para diferentes formas subjacentes (tipos de dados).

Por exemplo, em muitos idiomas, números inteiros e carros alegóricos são implicitamente polimórficos, pois você pode adicionar, subtrair, multiplicar e assim por diante, independentemente do fato de que os tipos são diferentes. Eles raramente são considerados objetos no termo usual.

Mas, da mesma maneira, uma aula como BigDecimal ou Rational ou Imaginary Também pode fornecer essas operações, mesmo que elas operem em diferentes tipos de dados.

O exemplo clássico é o Shape classe e todas as classes que podem herdar (quadrado, círculo, dodecaedro, polígono irregular, splat e assim por diante).

Com o polimorfismo, cada uma dessas classes terá diferentes dados subjacentes. Uma forma de ponto precisa de apenas duas coordenadas (assumindo que está em um espaço bidimensional, é claro). Um círculo precisa de um centro e raio. Um quadrado ou retângulo precisa de duas coordenadas para os cantos superior esquerdo e inferior direito e (possivelmente) uma rotação. Um polígono irregular precisa de uma série de linhas.

Ao responsabilizar a classe por seu código e seus dados, você pode alcançar o polimorfismo. Neste exemplo, toda classe teria Draw() função e o código do cliente pode simplesmente fazer:

shape.Draw()

Para obter o comportamento correto para qualquer forma.

Isso contrasta com a maneira antiga de fazer as coisas em que o código foi separado dos dados, e você teria funções como drawSquare() e drawCircle().

Orientação de objetos, polimorfismo e herança são todos conceitos intimamente relacionados e são vitais para saber. Houve muitas "balas de prata" durante minha longa carreira, que basicamente fracassaram, mas o paradigma OO acabou sendo bom. Aprenda, entenda, adore - você ficará feliz por ter feito :-)

^(uma) Originalmente, escrevi isso como uma piada, mas acabou sendo correto e, portanto, não tão engraçado. O estireno do mãe é feito de carbono e hidrogênio, C₈H₈, e o poliestireno é feito de grupos disso, (C₈H₈)_n.

Talvez eu deva ter declarado que um pólipo foi muitas ocorrências da letra p Embora, agora que eu tive que explicar a piada, mesmo isso também não parece engraçado.

Às vezes, você deve sair enquanto está atrasado :-)

Outras dicas

O polimorfismo é quando você pode tratar um objeto como uma versão genérica de algo, mas quando você o acessa, o código determina qual tipo exato ele é e chama o código associado.

Aqui está um exemplo em C#. Crie quatro classes em um aplicativo de console:

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

Agora crie o seguinte no principal () do módulo para o aplicativo do console:

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

Neste exemplo, criamos uma lista do veículo da classe base, que não sabe quantas rodas cada uma de suas subclasses tem, mas sabe que cada subclasse é responsável por saber quantas rodas possui.

Em seguida, adicionamos uma bicicleta, carro e caminhão à lista.

Em seguida, podemos percorrer cada veículo da lista e tratá-los de forma idêntica; no entanto, quando acessamos a propriedade de cada veículos, a classe do veículo delega a execução desse código na subclasse relevante.

Diz-se que esse código é polimórfico, pois o código exato executado é determinado pela subclasse que está sendo referenciada em tempo de execução.

Espero que isso ajude você.

A partir de A compreensão e a Aplicação de Polimorfismo em PHP, Obrigado Steve Guidetti.

Polimorfismo é uma palavra longa para um conceito muito simples.

Polimorfismo descreve um padrão na programação orientada a objeto em que classes diferentes de funcionalidade, enquanto a partilha de uma interface comum.

A beleza de polimorfismo é que o código de trabalho com as diferentes classes não precisam saber qual a classe em que está a utilizar, pois todos eles são usados da mesma forma.Um mundo real analogia para o polimorfismo é um botão.Todo mundo sabe como usar um botão:você simplesmente aplicar pressão para ele.O que um botão "não", no entanto, depende do que ele é ligado e o contexto em que é usado, mas o resultado não afeta a forma como ele é usado.Se o seu chefe diz que você pressione um botão, você já tem todas as informações necessárias para executar a tarefa.

No mundo da programação, o polimorfismo é usado para fazer aplicações mais modular e extensível.Em vez de bagunçado instruções condicionais para a descrição de diferentes cursos de ação, pode criar objetos intercambiáveis que você selecionar com base em suas necessidades.Que é o objetivo básico de polimorfismo.

Se alguém disser cortado para essas pessoas

O cirurgião
O cabeleireiro
O ator

O que vai acontecer?

O cirurgião começaria a fazer uma incisão.
O cabeleireiro começaria a cortar o cabelo de alguém.
O ator parava abruptamente de agir da cena atual, aguardando orientação diretora.

Portanto, a representação acima mostra o que é o polimorfismo (mesmo nome, comportamento diferente) na OOP.

Se você está indo para uma entrevista e o entrevistador pergunta que conta/mostra um exemplo ao vivo para o polimorfismo na mesma sala em que estamos sentados, digamos-

Resposta - Porta / janelas

Quer saber como?

Através da porta / janela - uma pessoa pode vir, o ar pode vir, a luz pode vir, a chuva pode vir, etc.

Para entender melhor e de maneira simples, usei o exemplo acima. Se você precisar de referência para o código, siga as respostas acima.

Explicação simples, por analogia,

O Presidente dos Estados Unidos emprega polimorfismo.Como?Bem, ele tem muitos conselheiros:

Conselheiros Militares
Consultores Jurídicos
Físicos nucleares (como consultores)
Conselheiros médicos
etc etc.

Todos Devem apenas ser responsável por uma coisa:Exemplo:

O presidente não é um especialista em revestimento de zinco, ou física quântica.Ele não sabe de muitas coisas - mas ele sabe apenas uma coisa:como executar o país.

É um bocado o mesmo com o código:preocupações e responsabilidades devem ser separados para as classes relevantes/pessoas.Caso contrário, você teria o presidente do saber, literalmente, tudo no mundo - toda a Wikipédia.Imagine ter toda a wikipédia em uma classe de seu código:seria um pesadelo para os manter depois.

Por que isso é uma má idéia para um presidente para saber todas estas coisas específicas?

Se o presidente fosse especificamente dizer às pessoas o que fazer, o que significaria que o presidente precisa sei exatamente o que fazer.Se o presidente precisa saber de coisas específicas de si mesmo, o que significa que quando você precisa fazer uma mudança, então você precisa para fazê-lo em dois lugares, não apenas um.

Por exemplo, se o EPA alterações poluição leis, em seguida, quando o que acontece:você teria que fazer uma alteração para o EPA Classe e também o Presidente de classe.Alterar o código em dois lugares em vez de um, pode ser perigoso, porque é muito mais difícil de manter.

Existe uma abordagem melhor?

Há uma abordagem melhor:o presidente não precisa saber de nada, ele pode exigir o melhor conselho, de pessoas especificamente com a tarefa de fazer essas coisas.

Ele pode usar um polimórfico abordagem para dirigir o país.

Exemplo de utilização de um polimórfico abordagem:

Tudo o que o presidente faz é pedir às pessoas para aconselhá-lo - e é o que ele realmente faz na vida real - e é isso que um bom presidente deve fazer.seus conselheiros, todos respondem de forma diferente, mas todos sabem que o presidente meios:Advise().Ele tem centenas de pessoas streaming em seu escritório.Na verdade, não importa quem eles são. Todos o presidente sabe é que, quando ele pede-lhes para "Aconselhar" eles sabem como responder adequadamente:

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

Esta abordagem permite que o presidente execute o país, literalmente, sem saber nada sobre militares coisas, ou a saúde ou a diplomacia internacional:os detalhes são deixados para os especialistas.A única coisa que o presidente precisa saber é isto:"Advise()".

O que você DON ' T quer:

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

NÃO!NÃO!NÃO!No cenário acima, o presidente está fazendo todo o trabalho:ele sabe sobre o aumento de números de tropas e de condições pré-existentes.Isso significa que, se o oriente médio de políticas de mudanças, em seguida, o presidente teria que mudar de comandos, bem como o Petraeus classe bem.Só devemos ter para alterar o Petraeus classe, porque o Presidente não deveria ter para se atolar em que tipo de detalhe.Ele não precisa de saber sobre os detalhes.Tudo o que ele precisa saber é que, se ele faz um pedido, tudo o que irá ser tomadas de cuidados.Todos os detalhes devem ser deixadas para os especialistas.

Isso permite que o presidente a fazer o que ele faz de melhor:definir a política geral, de boa aparência e jogar golfe :P.

Como é que é, na verdade, implementado através de uma base de classe ou uma interface comum

Que, na verdade, é polimorfismo, em poucas palavras.Exatamente como é feito?Através de "implementação de uma interface comum" ou usando uma classe base (herança) - ver acima respostas que detalhe mais claramente.(A fim de compreender mais claramente esse conceito, você precisa saber o que uma interface é, e você vai precisar para entender que a herança é.Sem isso, você pode lutar.)

Em outras palavras, Petraeus, Condições e HealthOfficials seriam todas as classes, que "implementar uma interface" - vamos chamá-lo de IAdvisor interface que contém apenas um método: Advise().Mas agora estamos chegando em aspectos específicos.

Este seria o ideal

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

Resumo

Tudo o que você realmente precisa saber é isto:

O presidente não precisa saber os detalhes - aqueles que são deixados para os outros.
De todos, o presidente precisa saber é perguntar a quem já anda na porta para conselhos a ele - e nós sabemos que eles vão realmente saber o que fazer quando solicitada para aconselhar (porque todos eles são, na verdade, assessores (ou IAdvisors :) )

Eu realmente espero que o ajude.Se você não entende nada de postar um comentário e eu vou tentar de novo.

O polimorfismo é a capacidade de tratar uma classe de objeto como se fosse a classe pai.

Por exemplo, suponha que haja uma classe chamada animal e uma classe chamada cachorro que herda do animal. O polimorfismo é a capacidade de tratar qualquer objeto de cachorro como um objeto animal como assim:

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

Polimorfismo:

É o conceito de programação orientada a objeto.A capacidade de objetos diferentes para responder, cada um à sua maneira, para mensagens idênticas é chamada de polimorfismo.

Polimorfismo resulta do fato de que cada classe vive em seu próprio espaço de nomes.Os nomes atribuídos dentro de uma definição de classe não entram em conflito com nomes atribuídos em qualquer lugar fora dela.Isso é verdadeiro tanto das variáveis de instância de um objeto da estrutura de dados e de métodos do objeto:

Assim como os campos de uma estrutura de C são protegidos espaço de nomes, de modo são uma instância do objeto de variáveis.
Método de nomes também estão protegidos.Ao contrário os nomes de funções C, método de nomes não são símbolos globais.O nome de um método em um classe não pode entrar em conflito com nomes de método em outras classes;dois muito diferentes classes podem implementar idêntico métodos.

Nomes de método são parte da interface de um objeto.Quando é enviada uma mensagem solicitando que um objeto faz algo, a mensagem de nomes o método que o objeto deve executar.Devido a diferentes objetos podem ter métodos com o mesmo nome, o significado de uma mensagem deve ser entendida em relação a determinado objeto que recebe a mensagem.A mesma mensagem enviada para dois diferentes objetos podem invocar dois diferentes métodos.

A principal vantagem do polimorfismo é que ele simplifica a interface de programação.Ele permite que as convenções que podem ser reutilizados na aula, depois da aula.Em vez de inventar um novo nome para cada nova função que você adicionar a um programa, o mesmo nome pode ser reutilizado.A interface de programação pode ser descrita como um conjunto de resumos de comportamentos, muito para além das classes que a implementam.

Exemplos:

Exemplo-1: Aqui está um exemplo simples escrito em 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()

Exemplo-2: Polimorfismo é implementado em Java usando o método a sobrecarga de e método substituindo conceitos.

Vamos Considerar o exemplo de Carro para discutir o polimorfismo.Tomar qualquer marca como a Ford, Honda, Toyota, BMW, Benz, etc., Tudo é do tipo Carro.

Mas cada um tem suas próprias características avançadas e a mais avançada tecnologia envolvida em sua mover comportamento.

Agora vamos criar um tipo básico de Carro

Car.java

public class Car {

    int price;
    String name;
    String color;

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

}

Vamos implementar o Carro Ford exemplo.

Ford estende o tipo de Automóvel para herdar todos os seus membros(métodos e propriedades).

Ford.java

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

Acima Ford classe estende a classe de Carro e também implementa o método move ().Apesar de o método move já está disponível para a Ford, através da Herança, a Ford ainda tem implementado o método em sua própria maneira.Isso é chamado de método de substituir.

Honda.java

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

Assim como a Ford, a Honda também se estende o tipo de Automóvel e implementado o método de mover em sua própria maneira.

Método primordial é um importante recurso para permitir que o Polimorfismo.Usando o Método primordial, o Sub-tipos, que podem alterar a forma como os métodos de trabalho que estão disponíveis através de herança.

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

  }
}

Polimorfismo Exemplo De Saída:

No PolymorphismExample classe principal método, eu criei três objetos - de Carro, Ford e Honda.Todos os três objetos são conhecidos pelo tipo de Carro.

Por favor, note um ponto importante aqui que Um super tipo de classe pode referir-se a uma Sub-classe do tipo de objeto, mas o vice-verso não é possível.A razão é que todos os membros da super classe estão disponíveis para a subclasse usando a herança, e durante o tempo de compilação, o compilador tenta avaliar se o tipo de referência que estamos usando tem o método que ele está tentando acessar.

Assim, para as referências carro,f e h na PolymorphismExample, o movimento existe um método do tipo de Carro.Assim, o compilador passa o processo de compilação, sem quaisquer problemas.

Mas quando chega o tempo de execução de execução, a máquina virtual invoca os métodos em objetos que são sub-tipos.Assim, o método move() é invocada a partir de suas respectivas implementações.

Assim, todos os objetos do tipo Carro, mas durante o tempo de execução, a execução depende de o Objeto sobre o qual a invocação acontece.Isso é chamado de polimorfismo.

Geralmente, isso se refere a capacidade de um objeto do tipo A se comportar como um objeto do tipo B. na programação orientada a objetos, isso geralmente é alcançado por herança. Alguns links da Wikipedia para ler mais:

Editar: links quebrados corrigidos.

O polimorfismo é o seguinte:

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
}

Você pode passar apenas um copo em vez de uma instância específica. Isso ajuda na generalidade porque você não precisa fornecer uma instância de medida () específica por cada tipo de copo

Eu sei que essa é uma pergunta mais antiga com muitas respostas boas, mas gostaria de incluir uma resposta de uma frase:

Tratar um tipo derivado como se fosse o tipo de base.

Existem muitos exemplos acima que mostram isso em ação, mas sinto que essa é uma boa resposta concisa.

(Eu estava navegando em outro artigo sobre algo totalmente diferente .. e o polimorfismo apareceu ... agora eu pensei que sabia o que era o polimorfismo ... mas aparentemente não desta maneira bonita explicada .. queria escrevê -lo em algum lugar .. Melhor ainda vai compartilhar ...)

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

Leia a partir desta parte:

..... polimorfismo. Essa é uma maneira nerd de dizer que substantivos diferentes podem ter o mesmo verbo aplicado a eles.

O termo polimorfismo vem de:

poli = muitos

morfismo = a capacidade de mudar

Na programação, o polimorfismo é uma "técnica" que permite "olhar" para um objeto como sendo mais de um tipo de coisa. Por exemplo:

Um objeto estudantil também é um objeto de pessoa. Se você "olhar" (ou seja, lançar) para o aluno, provavelmente poderá pedir o ID do aluno. Você nem sempre pode fazer isso com uma pessoa, certo? (Uma pessoa não é necessariamente um estudante, portanto, pode não ter um identificador de estudante). No entanto, uma pessoa provavelmente tem um nome. Um aluno também.

Conclusão, "Olhando" para o mesmo objeto de diferentes "ângulos" pode dar a você diferentes perspectivas (ou seja, propriedades ou métodos diferentes)

Portanto, essa técnica permite criar coisas que podem ser "analisadas" de diferentes ângulos.

Por que usamos o polimorfismo? Para iniciantes ... abstração. Neste ponto, deve ser informações suficientes :)

De um modo geral, é a capacidade de interagir com vários tipos diferentes de objeto usando o mesmo ou uma API superficialmente semelhante. Existem várias formas:

Sobrecarga da função: Definindo várias funções com o mesmo nome e diferentes tipos de parâmetros, como SQRT (float), SQRT (duplo) e SQRT (complexo). Na maioria dos idiomas que permitem isso, o compilador selecionará automaticamente o correto para o tipo de argumento que está sendo transmitido para ele, portanto, esse é o polimorfismo em tempo de compilação.
Métodos virtuais no OOP: Um método de classe pode ter várias implementações adaptadas às especificidades de suas subclasses; Diz -se que cada um deles substitui a implementação fornecida na classe base. Dado um objeto que pode ser da classe base ou de qualquer uma de suas subclasses, a implementação correta é selecionada em tempo, portanto, esse é o polimorfismo em tempo de execução.
Modelos: um recurso de alguns idiomas OO pelos quais uma função, classe etc. pode ser parametrizada por um tipo. Por exemplo, você pode definir uma classe de modelo genérico de "lista" e, em seguida, instanciá -la como "lista de números inteiros", "lista de strings", talvez até "lista de listas de strings" ou similares. Geralmente, você escreve o código uma vez para uma estrutura de dados do tipo de elemento arbitrário, e o compilador gera versões para os vários tipos de elementos.

Vamos usar uma analogia. Para um determinado script musical, todos os músicos que tocam que ele dá seu próprio toque na interpretação.

O músico pode ser abstraído com interfaces, o gênero ao qual o músico pertence pode ser uma classe Abstrac que define algumas regras globais de interpretação e todo músico que toca pode ser modelado com uma classe concreta.

Se você é um ouvinte do trabalho musical, tem uma referência ao Script, por exemplo, 'Fuga and Tocata', de Bach, e a todo músico que o realiza faz isso polimorfical à sua maneira.

Este é apenas um exemplo de um possível design (em 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());
}

Eu forneci uma visão geral de alto nível do polimorfismo para outra pergunta:

Polimorfismo em C ++

Espero que ajude. Um extrato...

... ajuda a começar a partir de um teste simples para ele e definição de [polimorfismo]. Considere o código:

Type1 x;
Type2 y;

f(x);
f(y);

Aqui, f() é realizar alguma operação e está recebendo os valores x e y como entradas. Ser polimórfico, f() deve ser capaz de operar com valores de pelo menos dois tipos distintos (por exemplo int e double), encontrando e executando código apropriado para o tipo.

(continuou em Polimorfismo em C ++ )

O polimorfismo é uma capacidade de objeto que pode ser tomado de várias formas. Por exemplo, na classe humana, um homem pode agir de várias formas quando falamos sobre relacionamentos. Ex: Um homem é pai de seu filho e é marido de sua esposa e é professor de seus alunos.

O polimorfismo é a capacidade de um objeto de assumir muitas formas. O uso mais comum de polimorfismo no OOP ocorre quando a referência da classe pai é usada para se referir a um objeto de classe infantil. Neste exemplo, escrito em Java, temos três tipos de veículo. Criamos três objeto diferente e tentamos executar o método das rodas:

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

}

O resultado é:

Para mais informações por favor visite https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/polymorphismexample.java. Espero que ajude.

O polimorfismo é a capacidade do programador de escrever métodos de mesmo nome que fazem coisas diferentes para diferentes tipos de objetos, dependendo das necessidades desses objetos. Por exemplo, se você estava desenvolvendo uma aula chamada Fraction e uma aula chamada ComplexNumber, ambos podem incluir um método chamado display(), mas cada um deles implementaria esse método de maneira diferente. No PHP, por exemplo, você pode implementá -lo assim:

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

Saídas:

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

Algumas das outras respostas parecem implicar que o polimorfismo é usado apenas em conjunto com a herança; por exemplo, talvez Fraction e ComplexNumber Ambos implementam uma classe abstrata chamada Number isso tem um método display(), qual fração e complexNumber são então obrigados a implementar. Mas você não precisar herança para aproveitar o polimorfismo.

Pelo menos em idiomas dinâmicos como PHP (não sei sobre C ++ ou Java), o polimorfismo permite que o desenvolvedor chame um método sem necessariamente saber o tipo de objeto antes do tempo e confiar que a implementação correta do método irá ser chamado. Por exemplo, digamos que o usuário escolha o tipo de Number criada:

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

Nesse caso, o apropriado display() O método será chamado, mesmo que o desenvolvedor não saiba com antecedência se o usuário escolherá uma fração ou um número complexo.

Na programação orientada a objetos, o polimorfismo refere-se à linguagem de programação Capacidade de processar objetos de maneira diferente, dependendo do seu tipo de dados ou classe. Mais especificamente, é a capacidade de redefinir os métodos para classes derivadas.

O polimorfismo significa literalmente, várias formas. (ou muitas formas): Objeto de diferentes classes e método de mesmo nome, mas os fluxos de trabalho são diferentes. Um exemplo simples seria:

Considere uma pessoa x.

Ele é apenas uma pessoa, mas age tantos. Você pode perguntar como:

Ele é um filho para sua mãe. Um amigo de seus amigos. Um irmão para sua irmã.

O polimorfismo em OOP significa que uma classe pode ter tipos diferentes, a herança é uma maneira de implementar o polimorfismo.

por exemplo, Forma é uma interface, tem Quadrado, Círculo, Diamante subtipos. Agora você tem um objeto quadrado, você pode usar o quadrado para moldar automaticamente, porque o quadrado é uma forma. Mas quando você tenta abaixar a forma de quadrado, deve fazer fundição de tipo explícito, porque não pode dizer que a forma é quadrada, também pode ser circular. Então você precisa lançá -lo manualmente com código como Square s = (Square)shape, e se a forma for circular, você ficará java.lang.ClassCastException, porque o círculo não é quadrado.

Polimorfismo:

Execução diferente de acordo com a instância da classe, não o tipo de variável de referência.

Uma variável de referência de tipo de interface pode se referir a qualquer uma das instâncias de classe que implementam essa interface.

O polimorfismo é a capacidade de usar um objeto em uma determinada classe, onde todos os componentes que compõem o objeto são herdados pelas subclasses da classe dada. Isso significa que, uma vez que esse objeto é declarado por uma classe, todas as subclasses abaixo dele (e suas subclasses, e assim por diante, até que você atinja a subclasse mais distante/mais baixa) herde o objeto e seus componentes (maquiagem).

Lembre -se de que cada classe deve ser salva em arquivos separados.

O código a seguir exemplifica o polimorfismo:

A superclasse:

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

O Pai, uma subclasse:

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

A criança, outra subclasse:

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

O método de execução, refere -se a classe pai para iniciar:

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

Observe que cada classe precisa ser declarada em arquivos *.java separados. O código deve compilar. Observe também que você pode usar continuamente o nome Manchenn e o Familytree mais abaixo. Esse é o conceito de polimorfismo. O conceito de herança também é explorado aqui, onde uma classe é usada ou é definida ainda mais por uma subclasse.

Espero que isso ajude e deixe claro. Vou postar os resultados quando encontrar um computador que possa usar para verificar o código. Obrigado pela paciência!

O polimorfismo permite que a mesma rotina (função, método) atue em diferentes tipos.

Como muitas respostas existentes estão confundindo a subtipagem com o polimorfismo, aqui estão três maneiras (incluindo a subtipagem) para implementar o polimorfismo.

Polimorfismo parametérico (genérico) Permite que uma rotina aceite um ou mais parâmetros de tipo, além dos parâmetros normais, e se executa nesses tipos.
Polimorfismo de subtipo Permite que uma rotina atue em qualquer subtipo de seus parâmetros.
Polimorfismo ad hoc Geralmente usa a sobrecarga de rotina para conceder comportamento polimórfico, mas também pode se referir a outras implementações de polimorfismo.

Veja também:

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

https://en.wikipedia.org/wiki/polymorphism_(computer_science)

Nas linguagens orientadas a objetos, o polimorfismo permite o tratamento e o manuseio de diferentes tipos de dados através da mesma interface. Por exemplo, considere a herança em C ++: classe B é derivada da classe A. Um ponteiro do tipo A* (ponteiro para a classe A) pode ser usado para lidar com um objeto de classe A e um objeto da classe B.

O polimorfismo em termos de codificação é quando seu objeto pode existir como vários tipos por meio de herança etc. Se você criar uma classe chamada "Shape" que define o número de lados que seu objeto possui, então você pode criar uma nova classe que a herda como "quadrado ". Quando você posteriormente faz uma instância de "quadrado", poderá lançá -lo de volta e para frente de "Shape" para "Square", conforme necessário.

O polimorfismo oferece a capacidade de criar um módulo chamando outro e ainda ter o ponto de dependência de tempo de compilação contra o fluxo de controle, em vez do fluxo de controle.

Ao usar o polimorfismo, um módulo de alto nível não depende do módulo de baixo nível. Ambos dependem de abstrações. Isso nos ajuda a aplicar o princípio da inversão de dependência (https://en.wikipedia.org/wiki/dependency_inversion_principle).

Foi aqui que encontrei a definição acima. Cerca de 50 minutos no vídeo, o instrutor explica o acima.https://www.youtube.com/watch?v=tmuno5rznee

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow