Polimorfismo vs Substituindo vs Sobrecarga
https://stackoverflow.com/questions/154577
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Em termos de Java, quando alguém pergunta:
o que é polimorfismo?
Será que sobrecarga ou primordial ser uma resposta aceitável?
Eu acho que há um pouco mais do que isso.
se você tivesse uma classe base abstrata que define um método com nenhuma implementação, e você definiu esse método na classe sub, é que ainda overridding?
Eu acho que sobrecarga não é a resposta certa, com certeza.
Solução
A maneira mais clara para expressar polimorfismo é através de uma classe base sumário (ou interface)
public abstract class Human{
...
public abstract void goPee();
}
Esta classe é abstrato porque o método goPee() não é definível para seres humanos. Só é definível para as subclasses masculino e feminino. Além disso, a Human é um conceito abstrato - Você não pode criar um ser humano que é macho nem fêmea. Tem que ser uma coisa ou outra.
Por isso, diferir a execução usando a classe abstrata.
public class Male extends Human{
...
@Override
public void goPee(){
System.out.println("Stand Up");
}
}
e
public class Female extends Human{
...
@Override
public void goPee(){
System.out.println("Sit Down");
}
}
Agora podemos dizer uma sala inteira cheia de seres humanos para ir fazer xixi.
public static void main(String[] args){
ArrayList<Human> group = new ArrayList<Human>();
group.add(new Male());
group.add(new Female());
// ... add more...
// tell the class to take a pee break
for (Human person : group) person.goPee();
}
A execução deste renderia:
Stand Up
Sit Down
...
Outras dicas
Polimorfismo é a capacidade de uma instância de classe a se comportar como se fosse uma instância de outra classe em sua árvore de herança, na maioria das vezes uma das suas classes ancestrais. Por exemplo, em Java todas as classes herdam de Object. Portanto, você pode criar uma variável do tipo Object e atribuir a ele uma instância de qualquer classe.
Um override é um tipo de função que ocorre em uma classe que herda de outra classe. Uma função override "substitui" a função herdada da classe base, mas faz isso de uma forma que ele é chamado, mesmo quando uma instância de sua classe está fingindo ser um tipo diferente através de polimorfismo. Referindo-se ao exemplo anterior, você pode definir sua própria classe e substituir a função toString (). Porque esta função é herdado do objeto, ele ainda estará disponível se você copiar uma instância dessa classe em uma variável do tipo de objeto. Normalmente, se você chamar toString () em sua classe enquanto ele está fingindo ser um objeto, a versão do toString que vai realmente fogo é o definido no próprio objeto. No entanto, porque a função é uma substituição, a definição de toString () da sua classe é usada mesmo quando verdadeiro tipo da instância de classe está escondido atrás de polimorfismo.
Sobrecarga é a ação de definir vários métodos com o mesmo nome, mas com diferentes parâmetros. Ele não está relacionado com qualquer substituindo ou polimorfismo.
Aqui está um exemplo de polimorfismo 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 ());
}
A função principal não sabe o tipo do animal e depende do comportamento do método MakeNoise () de uma determinada aplicação.
Editar: Parece que Brian me bater para o soco. Engraçado, utilizamos o mesmo exemplo. Mas o código acima deve ajudar a esclarecer os conceitos.
meios Polimorfismo mais do que uma forma, mesmo objecto realizar diferentes operações de acordo com a exigência.
O polimorfismo pode ser conseguido através de duas maneiras, essas são
- Método substituindo
- Método sobrecarga
Método sobrecarga significa escrever dois ou mais métodos na mesma classe usando mesmo nome método, mas a passagem de parâmetros é diferente.
método de substituição meios usamos os nomes de métodos nas diferentes classes, que método das médias classe pai é usada na classe infantil.
Em Java para alcançar polimorfismo uma variável de referência super classe pode conter o objeto sub classe.
Para alcançar o polimorfismo todo desenvolvedor deve usar os mesmos nomes de método no projeto.
Ambos substituindo e sobrecarga são usados ??para atingir polimorfismo.
Você poderia ter um método em uma classe que é substituído em um ou mais subclasses. O método faz coisas diferentes, dependendo de qual classe foi usado para instanciar um objeto.
abstract class Beverage {
boolean isAcceptableTemperature();
}
class Coffee extends Beverage {
boolean isAcceptableTemperature() {
return temperature > 70;
}
}
class Wine extends Beverage {
boolean isAcceptableTemperature() {
return temperature < 10;
}
}
Você também pode ter um método que é sobrecarregado com dois ou mais conjuntos de argumentos. O método faz coisas diferentes com base no Tipo (s) de argumento (s) passado.
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);
}
}
Está certo que a sobrecarga não é a resposta.
Nem está substituindo. Primordial é o meio pelo qual você começa polimorfismo. O polimorfismo é a capacidade de um objecto de variar o comportamento com base no seu tipo. Isto é melhor demonstrado quando o chamador de um objeto que exibe polimorfismo não tem conhecimento de que tipo específico é o objeto.
Especificamente dizendo sobrecarga ou substituir não dá a imagem completa. O polimorfismo é simplesmente a capacidade de um objeto para se especializar seu comportamento com base no seu tipo.
Eu concordo com algumas das respostas aqui em que a sobrecarga é uma forma de polimorfismo (polimorfismo paramétrico) no caso em que um método com o mesmo nome podem se comportar de forma diferente dar diferentes tipos de parâmetros. Um bom exemplo é a sobrecarga de operador. Você pode definir "+" para aceitar diferentes tipos de parâmetros - cordas dizer ou int de -. E com base nesses tipos, "+" irá se comportar de forma diferente
O polimorfismo também inclui métodos imperiosas herança e, embora possam ser abstrato ou virtual no tipo base. Em termos de polimorfismo à base de herança, Java suporta apenas uma única classe de herança a limitarem comportamento polimórfica para que de uma única cadeia de tipos base. Java faz apoiar a implementação de múltiplas interfaces que ainda é outra forma de comportamento polimórfico.
Polimorfismo significa simplesmente "muitas formas".
Não requer herança para alcançar ... como a implementação de interface, que não é herança em tudo, serve as necessidades polimórficas. Indiscutivelmente, a implementação de interface serve necessidades polimórficas "melhor" do que herança.
Por exemplo, se você criar uma super-classe para descrever todas as coisas que podem voar? Eu não deveria pensar. Você seria melhor ser servido para criar uma interface que descreve vôo e deixar por isso mesmo.
Assim, desde interfaces de descrever o comportamento, e nomes de métodos descrevem o comportamento (para o programador), não está muito longe de um trecho de considerar a sobrecarga de método como uma forma menor de polimorfismo.
O exemplo clássico, cães e gatos são animais, os animais têm o makeNoise método. Eu possível percorrer uma variedade de animais que chamam makeNoise sobre eles e esperar que eles iriam fazer lá respectiva implementação.
O código de chamada não tem que saber o animal específico que eles são.
Isso é o que eu penso de como polimorfismo.
O polimorfismo é a capacidade de um objeto para aparecer em várias formas. Isso envolve o uso de herança e funções virtuais para construir uma família de objetos que podem ser trocados. A classe base contém os protótipos das funções virtuais, possivelmente não implementadas ou com implementações padrão como os ditames da aplicação, e as várias classes derivadas cada implementos los de forma diferente para afetar diferentes comportamentos.
Nem:
A sobrecarga é quando você tem o mesmo nome de função que usa parâmetros diferentes.
primordial é quando uma classe criança substitui um método pai com um de sua própria (isso em iteself não constitui polimorfismo).
O polimorfismo é a ligação tardia, por exemplo, a classe base (pai) métodos estão sendo chamados, mas não até a execução faz o know aplicativo que o objeto real é - pode ser uma classe criança cujos métodos são diferentes. Isso ocorre porque qualquer classe criança pode ser usado onde uma classe base é definida.
Em Java você vê polimorfismo muito com a biblioteca de coleções:
int countStuff(List stuff) {
return stuff.size();
}
Lista é a classe base, o compilador não tem nenhuma pista se você está contando uma lista ligada, vetor, matriz ou uma lista personalizada de implementação, desde que ele age como uma lista:
List myStuff = new MyTotallyAwesomeList();
int result = countStuff(myStuff);
Se você estava sobrecarregando você teria que:
int countStuff(LinkedList stuff) {...}
int countStuff(ArrayList stuff) {...}
int countStuff(MyTotallyAwesomeList stuff) {...}
etc...
e a versão correta do countStuff () seria escolhido pelo compilador para corresponder aos parâmetros.
O termo refere-se a sobrecarga de ter várias versões de algo com o mesmo nome, geralmente métodos com listas de parâmetros diferentes
public int DoSomething(int objectId) { ... }
public int DoSomething(string objectName) { ... }
Assim, essas funções podem fazer a mesma coisa, mas você tem a opção de chamá-lo com um ID ou um nome. Não tem nada a ver com a herança, classes abstratas, etc.
Substituir geralmente se refere a polimorfismo, como você descreveu na sua pergunta
sobrecarga é quando você define 2 métodos com o mesmo nome, mas diferentes parâmetros
substituindo é onde você alterar o comportamento da classe base através de uma função com o mesmo nome em uma subclasse.
Assim Polimorfismo está relacionada a substituir, mas realmente não sobrecarregar.
No entanto, se alguém me deu uma resposta simples de "substituir" para a pergunta "Qual é o polimorfismo?" Gostaria de pedir para mais explicações.
substituindo é mais como esconder um método herdado declarando um método com o mesmo nome e assinatura como o método de nível superior (método super), este adiciona um comportamento polimórfica para a classe. em outras palavras, a decisão de escolher o método de nível wich a ser chamado será feita em tempo de execução e não em tempo de compilação. Isto leva ao conceito de interface e implementação.
o que é polimorfismo?
De java tutorial
A definição de dicionário de polimorfismo refere-se a um princípio em biologia em que um organismo ou espécies podem ter muitas formas ou fases diferentes. Este princípio também pode ser aplicado a programação orientada a objetos e linguagens como a linguagem Java. subclasses de uma classe pode definir os seus próprios comportamentos únicos e ainda compartilhar um pouco da mesma funcionalidade da classe pai.
Ao considerar os exemplos e definição, primordial resposta deve ser aceite.
Quanto à sua segunda pergunta:
Se você tivesse uma classe base abstrata que define um método com nenhuma implementação, e você definiu esse método na classe sub, é que ainda overridding?
Ele deve ser chamado primordial.
Tenha um olhar para este exemplo para entender os diferentes tipos de substituir.
- Classe base não fornece nenhuma implementação e sub-classe tem que substituir o método completo - (abstrato)
- Classe base fornece implementação padrão e sub-classe pode alterar o comportamento
- Sub-classe acrescenta extensão para implementação da classe base, chamando
super.methodName()como primeira declaração - base define classe estrutura do algoritmo (método molde) e sub-classe irá substituir uma parte do algoritmo
trecho de código:
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();
}
}
}
saída:
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:
Eu acho que os caras você está misturando conceitos. Polimorfismo é a capacidade de um objeto a se comportar de maneira diferente em tempo de execução. Para conseguir isso, você precisa de dois requisitos:
- ligação tardia
- Herança.
Dito isto sobrecarga significa algo diferente para primordial , dependendo do idioma que você está usando. Por exemplo, em Java não existe primordial e sobrecarga . Sobrecarregado métodos com assinatura diferente para sua classe base estão disponíveis na subclasse. Caso contrário eles seriam substituído (por favor, ver que eu quero dizer agora o fato de que não há maneira de chamar seu método de classe base de fora do objeto).
No entanto, em C ++ que não é assim. Qualquer sobrecarregado método, independentemente se a assinatura é a mesma ou não (quantidade diffrrent, tipo diferente) é bem substituído . Essa é a-dia, o método da classe base não está mais disponível na subclasse ao ser chamado de fora do objeto de subclasse, obviamente.
Portanto, a resposta é quando se fala sobre o uso de Java sobrecarga . Em qualquer outra língua pode ser diferente como acontece em c ++
Embora, Polimorfismo já está explicado em grandes detalhes neste post, mas eu gostaria colocar mais ênfase sobre o porquê de parte dela.
Por polimorfismo é tão importante em qualquer idioma OOP.
Vamos tentar construir uma aplicação simples para uma TV com e sem Herança / Polimorfismo. Postar cada versão do aplicativo, fazemos uma pequena retrospectiva.
Supondo, você é um engenheiro de software em uma empresa de TV e você está convidado a escrever software para o volume, brilho e cor controladores para aumentar e diminuir seus valores no comando do usuário.
Você começa com aulas de redação para cada uma destas características, adicionando
- conjunto: -. Para definir um valor de um controlador (Supondo que isso tem controlador de código específico)
- começar: -. Para obter um valor de um controlador (Supondo que tem o código de controlador específico)
- ajustar: - Para validar a entrada e definindo um controlador (validações genéricos .. independente de controladores) .
- mapeamento de entrada do usuário com os controladores: -. Para obter entrada do usuário e invocando controladores em conformidade
Aplicação Versão 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;
}
}
}
}
Agora você tem a nossa primeira versão do aplicativo pronto para ser implantado trabalhando. Tempo para analisar o trabalho feito até agora.
Problemas na TV Aplicação Versão 1
- Ajustar (valor int) código é duplicado em todas as três classes. Você gostaria de minimizar a duplicidade de código. (Mas você não acha que de código comum e movê-lo para alguma classe super para evitar código duplicado)
Você decide viver com isso, desde que o aplicativo funciona como esperado.
Depois de, por vezes, o seu patrão volta para você e lhe pede para adicionar a funcionalidade de reinicialização para o aplicativo existente. Redefinir iria definir todos controlador de 3 três a seus respectivos valores padrão.
Você começar a escrever uma nova classe (ResetFunctionV2) para a nova funcionalidade e mapear o código de mapeamento de entrada do usuário para este novo recurso.
Aplicação Version 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;
}
}
}
}
Então você tem sua aplicação pronta com recurso Reset. Mas, agora você começa a perceber que
Problemas na TV Aplicação Version 2
- Se um novo controlador é introduzido no produto, você tem que mudar código de recurso Reset.
- Se a contagem do controlador cresce muito alta, você teria problema em manter as referências dos controladores.
- código de recurso Reset é intimamente ligado com todos os controladores de código de classe (para obter e valores padrão definidos).
- classe recurso Reset (ResetFunctionV2) pode acessar outro método da classe Controller (ajustar) o que é indesejável.
Ao mesmo tempo, você ouvir de você chefe que você pode ter que adicionar um recurso em que cada de controladores, no start-up, precisa verificar para a versão mais recente do driver do repositório de drivers hospedado da empresa via internet.
Agora você começa a pensar que este novo recurso a ser adicionado se assemelha com recurso de redefinição e Questões de Aplicação (V2) será multiplicado se você não re-fator de sua aplicação.
Você começar a pensar em usar a herança para que você possa tirar proveito da capacidade polimórfico de JAVA e você adicionar uma nova classe abstrata (ControllerV3) para
- Declare a assinatura de get e set método.
- Conter ajustar implementação do método que foi anteriormente replicados entre todos os controladores.
- método Declare setDefault para que recurso de redefinição pode ser facilmente implementado aproveitando Polimorfismo.
Com essas melhorias, você tem a versão 3 do seu aplicativo de TV pronto com você.
Aplicação Versão 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;
}
}
}
}
Embora a maior parte do problema listado na lista questão da V2 foram abordados exceto
Problemas na TV Aplicação Versão 3
- classe recurso Reset (ResetFunctionV3) pode acessar outro método da classe Controller (ajustar) o que é indesejável.
Mais uma vez, você pensa em resolver este problema, como agora você tem uma outra característica (atualização de driver durante a inicialização) para implementar também. Se você não corrigi-lo, ele vai ficar replicada para novos recursos também.
Assim você dividir o contrato definido na classe abstrata e escrever 2 interfaces para
- recurso Reset.
- Driver Update.
E ter sua classe 1º concreto implementá-las como abaixo
Aplicação Versão 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;
}
}
}
}
Agora, todas a questão enfrentada por você foi abordado e você percebeu que com o uso de herança e polimorfismo você poderia
- Mantenha várias partes do aplicativo de baixo acoplamento. (Reset ou componentes do recurso Driver Update não precisam estar cientes de classes do controlador reais (volume, brilho e cor), qualquer classe que implementa onreset ou OnStart será aceitável para redefinir ou Atualizar driver recurso componentes respectivamente).
- aprimoramento de aplicativos se torna mais fácil. (New adição de redefinição de impacto controlador vai ou componente recurso de atualização de driver, e agora é realmente fácil para você adicionar novos)
- Mantenha camada de abstração. (Agora recurso de redefinição pode ver único método setDefault de controladores e recurso de redefinição pode ver único método checkForDriverUpdate de controladores)
Hope, isso ajuda: -)
O polimorfismo é mais provável na medida em que é significa está em causa ... a imperiosa de java
É tudo sobre comportamento diferente do objeto SAME em diferentes situações (Em forma de programação ... você pode chamar argumentos diferentes)
Eu acho que o exemplo abaixo irá ajudá-lo a compreender ... Embora não seja código java PURE ...
public void See(Friend)
{
System.out.println("Talk");
}
Mas se mudarmos o argumento ... O comportamento será alterado ...
public void See(Enemy)
{
System.out.println("Run");
}
A Pessoa (aqui o "objeto") é o mesmo ...
O polimorfismo é um múltiplo implementações de um objeto ou você poderia dizer que múltiplas formas de um objeto. digamos que você tenha Animals classe como a classe base abstrata e tem um método chamado movement() que define a maneira que o animal se move. Agora, na realidade, temos diferentes tipos de animais e movem-se de forma diferente bem alguns deles com 2 pernas, outros com 4 e algumas sem pernas, etc .. Para definir diferente movement() de cada animal na terra, precisamos aplicar polimorfismo. No entanto, é necessário definir mais classes i.e. classe Dogs Cats Fish etc. Então é necessário estender essas classes do Animals classe base e substituir seu movement() método com uma nova funcionalidade movimento com base em cada animal que tem. Você também pode usar Interfaces para conseguir isso. A palavra-chave aqui é substituir, a sobrecarga é diferente e não é considerado como polimorfismo. com sobrecarga pode definir vários métodos "com o mesmo nome", mas com diferentes parâmetros no mesmo objeto ou classe.
Polimorfismo refere-se à capacidade de uma língua para ter diferentes objecto tratado de maneira uniforme, utilizando um único interfaces; como tal, está relacionada com a substituir, de modo que a interface (ou a classe de base) é polimórfico, o implementador é o objecto que substituições (as duas faces da mesma medalha)
De qualquer forma, a diferença entre os dois termos é melhor explicada usando outras linguagens, como C ++: um objeto polimórfico em C ++ se comporta como contrapartida java se a função de base é virtual, mas se o método não é virtual o salto código é resolvidas estaticamente , e o verdadeiro tipo não verificada em tempo de execução assim, polimorfismo incluem a capacidade de um objeto a se comportar de forma diferente dependendo da interface usada para acessá-lo; deixe-me dar um exemplo em pseudocódigo:
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
(supondo que makeRumor não é virtual)
java não verdadeiramente oferecer este nível de polimorfismo (chamado também objeto de corte).
animais a = new dog (); cão b = new dog ();
a.makeRumor() -> prints thump
b.makeRumor() -> prints woff
em ambos os casos ele só irá imprimir woff .. desde a e b está se referindo ao cão classe
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());
}
}
