Por causa da epidemia em casa entediado, passar por cima o modo de design. Altamente recomendado "Head First Design Patterns" livro, lê-lo várias vezes, e cada benefício tempo.
conceito padrão de estratégia
padrão Strategy define uma família de algoritmos, encapsular-los, para que eles possam substituir um ao outro, este modo permite que o algoritmo variar independentemente de clientes usando o algoritmo.
Relacionadas com os princípios de design: identificar aplicações podem exigir mudanças no lugar, colocá-los independente e não precisa alterar o código que mistura .
Popular falar este princípio é colocar os novos requisitos de código necessárias alterações pacote, e distinção código previamente estável.
Outra maneira de pensar deste princípio: a parcela foi removido e variam encapsulado, de modo que você pode facilmente ser alterado ou ampliado nesta seção, sem afetar o resto não requer alterações.
Quase todos os padrão de projeto fornece uma maneira de tornar o sistema "uma parte da mudança" não vai afetar outras partes.
Para dar um exemplo para ilustrar o modo de política específica, exemplos utilização pato no livro, nós precisamos fazer pato diferente implementar um comportamento diferente, por exemplo, seria chamar mosca pato real, patos de brinquedo não vai voar, não chame e não gerar o código redundância, e de acordo com os princípios de design que acabamos de mencionar.
Código de exemplo
Primeiro, olhe para uma má implementação, o primeiro é um pato classe abstrata, pato herdar todas desta classe.
public abstract class Duck {
public void swim() {
System.out.println("鸭子游泳");
}
public abstract void display();
}
Chegou a dizer o vôo e chamados de interfaces, patos esses atos precisam implementar estas duas interfaces.
public interface Flyable {
void fly();
}
public interface Quackable {
void quack();
}
Mais uma vez é uma espécie de pato.
public class MallardDuck extends Duck implements Flyable, Quackable {
@Override
public void display() {
System.out.println("Mallard");
}
@Override
public void fly() {
System.out.println("fly");
}
@Override
public void quack() {
System.out.println("quack");
}
}
public class RedheadDuck extends Duck implements Flyable, Quackable {
@Override
public void display() {
System.out.println("Red head");
}
@Override
public void fly() {
System.out.println("read head fly");
}
@Override
public void quack() {
System.out.println("quack");
}
}
public class RubberDuck extends Duck implements Quackable {
@Override
public void display() {
System.out.println("Rubber");
}
@Override
public void quack() {
System.out.println("quack");
}
}
Sinta isso, este tipo de aplicação, onde o mau? redundância de código, repetindo muito código, se um número de patos para modificar seu comportamento, que seria uma ah pesadelo.
Voltando aos nossos princípios de design anteriores, para identificar mudanças nos aplicativos, além de e independente, e não misturar a variável código imutável.
mudança separada e parte imutável
Para atingir este objetivo, vamos criar duas classes, e a classe independente de classe Pato, a fim de alcançar o seu comportamento, por isso, do nosso ponto de vista o exemplo acima, que "voar" e "quack" O comportamento dos dois. Tais como o comportamento chamada, podemos alcançar "quack", "charlatão" e "não chama", afinal, não é o mesmo nome para um pato.
Como o comportamento já aponta, seguido pelo design do seu comportamento, que por sua vez envolve um princípio de design: para a programação de interface, em vez de programação.
Desenhe o foco, o que isso significa? Para a programação de interface, tomamos neste caso está em causa, é na classe "Duck", o comportamento não é específico para o desempenho através da implementação, ao usar a interface em vez de, por exemplo, "FlyBehavior" e "comportamento QuackBehavior' para substituir o pato, eles apenas responsável por chamar métodos, a implementação específica para atingir pelo comportamento destas duas classes de interfaces.
Para comparar a diferença entre as duas em duas formas, a primeira maneira, temos implementando a interface desses dois atos, o foco em alcançar patos em classe, nenhuma maneira de mudar, quando precisamos mudar apenas modificando os patos código para a mudança. E uma espécie de trás, subclasses de pato usando o desempenho comportamento da interface, a implementação real é conseguido através de classe comportamental, não amarrado em uma subclasse de patos. Isso proporciona uma mudança conveniente.
Vamos olhar código.
implementação da estratégia código de modo
Patos classe abstrata,
public abstract class Duck {
QuackBehavior quackBehavior;
FlyBehavior flyBehavior;
public abstract void display();
public void performQuack() {
quackBehavior.quack();
}
public void performFly() {
flyBehavior.fly();
}
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}
Lá, nós incluímos duas interfaces, uma "QuackBehavior" a "FlyBehavior" para executar uma ação performQuack e dois métodos performFly, os seguintes dois métodos descritos, podemos mudar o comportamento dos métodos de patos.
Vamos olhar o comportamento vôo da interface, e sua classe de implementação.
public interface FlyBehavior {
void fly();
}
public class FlyNoWay implements FlyBehavior {
@Override
public void fly() {
System.out.println("can't fly");
}
}
public class FlyWithWings implements FlyBehavior {
@Override
public void fly() {
System.out.println("Fly with Wings");
}
}
Aqui está uma interface muito simples, duas classes de implementação. De igual modo, uma estrutura de interface de chamada semelhante.
public interface QuackBehavior {
void quack();
}
public class Quack implements QuackBehavior {
@Override
public void quack() {
System.out.println("Quack");
}
}
public class Squeak implements QuackBehavior {
@Override
public void quack() {
System.out.println("Squeak");
}
}
public class MuteQuack implements QuackBehavior {
@Override
public void quack() {
System.out.println("<< Silence >>");
}
}
Dois patos classes.
public class MalardDuck extends Duck {
@Override
public void display() {
System.out.println("Malard");
}
public MalardDuck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
this.flyBehavior = flyBehavior;
this.quackBehavior = quackBehavior;
}
}
public class RedHeadDuck extends Duck {
@Override
public void display() {
System.out.println("red head duck");
}
public RedHeadDuck(FlyBehavior flyBehavior, QuackBehavior quackBehavior) {
this.flyBehavior = flyBehavior;
this.quackBehavior = quackBehavior;
}
}
categoria de teste
public class Test {
public static void main(String[] args) {
MalardDuck malardDuck = new MalardDuck(new FlyWithWings(), new Quack());
malardDuck.display();
malardDuck.performFly();
malardDuck.performQuack();
System.out.println("-----------");
RedHeadDuck redHeadDuck = new RedHeadDuck(new FlyNoWay(), new MuteQuack());
redHeadDuck.display();
redHeadDuck.performQuack();
redHeadDuck.performFly();
System.out.println("change ---------");
redHeadDuck.display();
redHeadDuck.setFlyBehavior(new FlyWithWings());
redHeadDuck.performFly();
redHeadDuck.setQuackBehavior(new Quack());
redHeadDuck.performQuack();
}
}
Nós construtor, especifique o comportamento de patos, modificar o comportamento de patos pelo método conjunto, de modo que quando é preciso aumentar o comportamento, você pode simplesmente adicionar um novo comportamento da classe, reatribua comportamento pato lata, sem modificar classe pato alcançado.
Há também o uso de um princípio de design, combinação multi-purpose, herança menor .
Use uma combinação de sistemas estabelecidos com grande flexibilidade, não só a família de algoritmos podem ser embalados como tal, mas também "ser alterada dinamicamente o comportamento de tempo de execução" em linha com o comportamento do objeto, enquanto a combinação do padrão de interface correta pode ser.
Aqui todo o modo política para fugir. Mais tarde há novas idéias, em seguida, adicioná-lo.
