Existem três principais características de objetos orientados a objetos: encapsulamento, herança e polimorfismo. De uma certa perspectiva, o encapsulamento e a herança estão quase todos preparados para o polimorfismo. Este é o nosso último conceito e o ponto de conhecimento mais importante.
1. Definição:
Polimorfismo: refere -se a permitir que objetos de diferentes tipos respondam à mesma mensagem. Ou seja, a mesma mensagem pode adotar uma variedade de comportamentos diferentes de acordo com os diferentes objetos enviados. (Enviar uma mensagem é uma chamada de função)
2. A tecnologia para implementar o polimorfismo é chamada: ligação dinâmica, que se refere ao julgamento do tipo real do objeto referenciado durante a execução e chamando seu método correspondente de acordo com seu tipo real.
3. Função: elimine a relação de acoplamento entre os tipos.
4. Na realidade, existem inúmeros exemplos de polimorfismo. Por exemplo, pressionando a tecla F1, se o documento de ajuda AS3 estiver aparecendo atualmente na interface flash; Se a palavra ajuda estiver aparecendo atualmente sob a palavra; Se a ajuda do Windows estiver aparecendo atualmente sob a ajuda e suporte do Windows. O mesmo evento ocorre em diferentes objetos e produz resultados diferentes.
5. Abaixo estão três condições necessárias para a existência polimórfica, que exigem que todos a memorizem ao sonhar!
Três condições necessárias para o polimorfismo
1. Deve haver herança;
2. Deve haver reescrita;
3. A classe dos pais aponta para o objeto de classe infantil.
6. Benefícios do polimorfismo:
1) Substituição: O polimorfismo tem intercambiabilidade para o código existente. Por exemplo, o polimorfismo funciona na classe Circle Circle e também funciona em qualquer outra geometria circular, como um círculo.
2) Extensibilidade: O polimorfismo é extensível ao código. A adição de novas subclasses não afeta a operação e a operação dos polimorfismos das classes existentes, herança e outras características. De fato, é mais fácil obter funções polimórficas adicionando novas subclasses. Por exemplo, com base na realização do polimorfismo de cones, semicones e hemisférios, é fácil adicionar polimorfismos de esferas.
3) Capacidade de interface: o polimorfismo é alcançado por superclasses por meio de assinaturas de métodos, fornecendo uma interface comum às subclasses, e as subclasses são implementadas melhorando ou substituindo-as. Como mostrado na Figura 8.3. Na figura, a forma da super classe especifica dois métodos de interface que implementam o polimorfismo, computea () e computeVolume (). Subclasses, como círculo e esfera, melhoram ou substituem esses dois métodos de interface para alcançar o polimorfismo.
4) Flexibilidade: reflete operações flexíveis e diversas na aplicação e melhora a eficiência do uso.
5) Simplicidade: O polimorfismo simplifica o processo de redação e modificação de código do software de aplicativo, especialmente ao lidar com operações e operações de um grande número de objetos, esse recurso é particularmente proeminente e importante.
Código do caso de gato e cachorro
classe Animal {public void Eat () {System.out.println ("Eat");} public void Sleep () {System.out.println ("Sleep");}} classe Dog estende Animal {public void Eat () {System.out.out.println ("Dog Eat Meat");} vazio vazio (); estende Animal {public void Eat () {System.out.println ("Cat Eats Fish");} public void Sleep () {System.out.println ("Cat dorme em sua barriga");}} a classe de pombto (PIGN) {public void Eat () {System.out.println (" Acomoda de lado ");}} // classe de ferramenta para operações de animais Classe AnimalTool {private AnimalTool () {}/* // Chamando a função do gato public estático void usecat (cat c) {c.eat (); C.Sleep (); } // Chamando a função do cão public estático void usado (cão d) {D.Eat (); D.Sleep (); } // Chamando a função do porco public estático void usepig (porco p) {p.eat (); p.sleep (); } */public static void useanimal (animal a) {a.eat (); a.sleep ();} // classifica todas as possibilidades em animais} classe duotaidemo2 {public static void main (string [] args) {// eu gosto de gatos, então eu tenho um gato c = novo gato (); c.eat); Cat (); c2.Eat (); C2.Sleep (); // Gosto de gatos em particular e tenho outro CAT C3 = novo Cat (); C3.Eat (); C3.Sleep (); // ... System.out.println ("----------------------"); // O problema é o que eu levantou muito? Chamando o método, você não acha que é muito parecido? É que os nomes de objetos são diferentes. // Estamos planejando usar métodos para melhorar // Invoke o método para melhorar a versão // usecat (c); // usecat (c2); // usecat (c3); // animaltool.usecat (c); // animaltool.Usecat (c2); // animaltool.Usecat (c2); // Animaltool.usecat ( C3); Animaltool.Useanimal (C2); Animaltool.Useanimal (C2); Animaltool.Useanimal (C3); System.out.println ("--------------------"); // i como cães cães d = novo cachorro (); cão d2 = novo cachorro (); cão d3 = novo Cachorro (); // Animaltool.Usedog (d); // Animaltool.Usedog (d2); // Animaltool.Usedog (D3); Animaltool.Useanimal (d); Animaltool.Useanimal (d2); Animaltool.Useanimal ( d2); Animaltool.Useanimal (D3); System.out.println ("------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Porco (); // animaltool.Usepig (p); // Animaltool.Usepig (p2); // Animaltool.Usepig (P3); Animaltool.Useanimal (P2); Animaltool.Useanimal (P2); Animaltool.useanimal (P3); Leopardo ... // Definir a classe correspondente, herdar o método correspondente e adicionar chamadas de método à classe de ferramentas // Os primeiros poucos devem ser escritos, não tenho objeção //, no entanto, a classe de ferramentas é alterada sempre que se preocupa. public static void usecat (CAT C) {C.EAt ();7. Método de implementação de polimorfismo em Java: implementação da interface, herdando a classe pai para reescrita de métodos e sobrecarregar os métodos da mesma classe.
8. Classificação de polimorfismos em Java:
Em Java, os polimorfismos podem ser divididos aproximadamente nas seguintes situações:
1) Pessoa é a classe dos pais e o aluno é a classe infantil. Então: Personp = newStudent ();
2) FLIEBLE é uma interface e o pássaro é uma classe que implementa a interface, então: fliablef = newbird ();
3) FLIEL é uma classe abstrata, o pássaro é uma classe que herda FLILE, então: fliablef = newbird ();
Quando o polimorfismo, é necessário afirmar que P declara como uma referência à classe pai, mas na verdade é uma referência à classe infantil. Mas ele só pode chamar métodos na classe pai. Se o método na subclasse substituir o método da classe pai, o método da classe pai (chamada do método virtual) será chamado. O mesmo vale para o polimorfismo da interface. Talvez você pergunte, se F quiser chamar seu próprio método, isso não cometeria um erro? De fato, essa também é uma cobertura de método, porque a subclasse implementando a interface definitivamente implementará os métodos na interface; portanto, neste caso, o método no pássaro é chamado. Mas se o pássaro tem um método que não é definido na interface, f não poderá ser chamado.
9.InstanceOf Of Operator:
O mecanismo polimórfico da linguagem Java faz com que o tipo de declaração da variável de referência seja inconsistente com o tipo de objeto de referência real. Combinado com as regras de chamada de método virtual, podemos concluir que duas variáveis de referência declaradas como o mesmo tipo também podem ter comportamentos diferentes ao chamar o mesmo método. A instância do operador é introduzida aqui.
Então, se eu declarar Personp = newStudent (); Posso converter P para o aluno? É claro que isso pode ser feito, mas deve ser forçado (o filho quer ser pai e ele virá diretamente, mas se o pai quiser ser filho, ele será forçado).
Geralmente, a instância é adicionada ao fundir.
if (pinheiros
O polimorfismo percorre toda a aprendizagem de Java. Por exemplo, ao escrever declarações de captura ao lidar com exceções, estipulamos que as exceções da subclasse devem ser escritas nas exceções da classe frontal e pai devem ser escritas na parte traseira. Por que? O motivo é o polimorfismo. Nosso formato de declaração de captura: Catch (excepcione). Quando uma exceção é gerada, um programa Java gera automaticamente um objeto de exceção. Se uma exceção da classe infantil for gerada primeiro e a exceção da classe pai for escrita na frente, essa declaração de captura será definitivamente executada de acordo com o polimorfismo, e ela será lançada após a execução de uma declaração de captura.
10. Exemplo:
Embora eu não entenda muito bem o polimorfismo de Java, o exemplo a seguir me faz entender alguns:
classe a {public string show (d obj) .. {return ("a e d");} public string show (um obj) .. {return ("a e a");}} classe b estende um {public string show (b obj) .. {return (b e b "); B {} classe E {public static void main (string [] args) {a a1 = novo a (); a2 = new b (); b b = new b (); c c = novo c (); d d = novo D (); system.out.println (a1.show (b)); // ①system.out.println (a1.show (c)); // ②system.out.println (a1.show (d)); //③system.out.println(a2.show(b)) ;//④system.out.println(a2.Show(c)); ⑥system.out.println (b.show (b)); // ⑦system.out.println (b.show (c)); // ⑧system.out.println (b.show (d)); // ⑨}}(Iii) Resposta
① a e a ② a e a ③ a e d ④ b e a ⑤ b e a ⑥ a e d ⑦ b e b ⑧ b e b ⑨ a e d
**** Há uma boa resposta de uma pessoa ****
Existem dois pontos -chave para este problema:
Um é a relação entre a subclasse e a classe pai, e o outro é a questão dos métodos sobrecarregados.
Os objetos da subclasse podem ser usados diretamente como objetos pais, mas, caso contrário, eles não podem. Por exemplo, as pessoas são a classe dos pais e os alunos são a subclasse das pessoas; portanto, os objetos dos alunos devem ter os atributos dos objetos humanos, mas objetos humanos podem não necessariamente ter as características dos objetos dos alunos. Portanto, os objetos dos alunos podem ser usados como objetos humanos, mas objetos humanos não podem ser usados como objetos do aluno. Observe que, ao usar o objeto subclasse como objeto pai, o objeto subclasse perderá todas as características da subclasse e reterá apenas atributos e métodos com o mesmo nome da classe pai (o mesmo método de nome não é apenas o mesmo nome da função, mas também o tipo de parâmetro deve ser o mesmo, caso contrário, não será retido).
Se um método sobrecarregado for definido em uma classe, o sistema selecionará e chamará o método apropriado de acordo com o tipo do parâmetro ao chamar o método.
1) A1.Shows (B), não há método contendo parâmetros de classe B em A, mas um método que contém parâmetros de classe A é chamado de acordo com o princípio de que a classe pai do objeto de subclasse está disponível; portanto, o método é chamado.
publicStringshow(Aobj)...{return("AandA");}
2) A1.Show (C), Classe C é uma subclasse da Classe B e Classe B é uma subclasse da classe A, para que os objetos Classe C possam ser usados como um objeto Classe A. O resultado é o mesmo que acima.
3) A1.show (d), chame diretamente o método em um de acordo com o tipo de parâmetro
publicStringshow(Dobj)...{
return("AandD");}
4) A2.Show (B), A2 era originalmente um objeto B, mas foi atribuído à Variável Classe A, então A2 mantém apenas propriedades e métodos com o mesmo nome da classe pai A2.Show (b) chama o método reservado na classe B com o mesmo nome da classe pai e o mesmo parâmetro que a classe pai
public String show(A obj)...{
return ("B and A");
}
5) A2.Show (c), o método reservado da classe B não possui métodos de parâmetros de classe C, mas existem métodos de parâmetros da classe pai B que contêm C, então o método chamado
public String show(A obj)...{
return ("B and A");
}
Eu acho que essa explicação é mais razoável: A2 era originalmente um objeto da classe B, mas o valor foi atribuído à classe A, C é uma subclasse de B, e B é uma subclasse de A, então A2 mantém as propriedades e os métodos da classe B com o mesmo nome que A.
6) A2.Show (d), a chamada é da classe A
public String show(D obj)...{
return ("A and D");
}
7) B.Show (b), ligue para o
public String show(B obj)...{
return ("B and B");
}
8) B.Show (c), não há método com o parâmetro C na classe B, mas existe um método com o parâmetro B, portanto o método é chamado
public String show(B obj)...{
return ("B and B");
}
9) B.Show (D), a explicação é a mesma que 8
Resumir
O exposto acima é o conteúdo inteiro do resumo deste artigo do polimorfismo Java, e espero que seja útil para todos. Se você tiver alguma dúvida, deixe uma mensagem a qualquer momento e aguarde seus valiosos comentários!