padrão Decorator Head First Design Patterns--

Introdução Básica:
Decorator: Dinâmico nova funcionalidade anexado ao objeto, a expansão função de destino, é mais elástica do que a herança, Decorator também reflete o princípio do obturador (OCP), o padrão de decorador pode ser entendida como modo de embalagem.

Por exemplo: Queremos enviar um telefone celular, envie expressar nossas operações deve ser a seguinte:

① telefone choque envolvido com o filme, que é a primeira camada decorativa

② Em seguida, expressa a partir caixa de embalagem

, finalmente, com sacos plásticos ③ bom pacote

Tal telefone celular completa o pacote, o padrão Decorator é o princípio tal, olhada na seguinte descrição específica:

• classe representa FIG
  

(1) Componente

Define uma classe abstrata, para receber uma demanda adicionados dinamicamente.

(2) ConcreteComponent

ConcreteComponent queremos adicionar um novo comportamento dinâmico de objetos.

(3) decorador

Cada instância de um decorador pode segurar um objeto membro (Component),

Em outras palavras, o decorador tem uma variável de exemplo para manter uma referência a um componente de

(4) ConcreteDecorator

O verdadeiro decorador, responsável pelo objeto para adicionar novos métodos e comportamento.

O primeiro exemplo:

Decorator é uma classe abstrata: Bebidas
foi o decorador: Espresso, HouseBlend
decorador classe abstrata: CondimentDecorator
Decorator: Mocha

• código de implementação específica

/**
 * 被装饰者的抽象类：饮料
 */
public abstract class Beverage {

    String description = "Unknown Beverage";

    //成本
    public abstract double cost();

    //得到描述信息
    public String getDescription(){
        return description;
    }
}

/**
 * 被装饰者：浓咖啡
 */
public class Espresso extends Beverage {

    public Espresso() {
        description = "Espresso";
    }

    @Override
    public double cost() {
        return 2;
    }
}

/**
 * 被装饰者：混合咖啡
 */
public class HouseBlend extends Beverage {
    public HouseBlend() {
        description = "House Blend";
    }

    @Override
    public double cost() {
        return 1;
    }
}

/**
 * 装饰者的抽象类：调料
 */
public abstract class CondimentDecorator extends Beverage {

    public abstract String getDescription();

    @Override
    public double cost() {
        return 0;
    }
}

/**
 * 装饰者：摩卡
 */
public class Mocha extends CondimentDecorator {

	//聚合被装饰者，可以传入实现Beverage接口的所有对象
    Beverage beverage;
	//构造器，初始化beverage
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription()+",Mocha";
    }

    @Override
    public double cost() {
    	//调用被装饰者的成本，加上装饰者的成本
        return 3 + beverage.cost();
    }
}

/**
 * 测试
 */
public class CoffeeTest {
    public static void main(String[] args) {

        Beverage beverage = new Espresso();
        //一杯浓咖啡为2元
        System.out.println(beverage.getDescription()+","+beverage.cost());

        Beverage beverage1 = new HouseBlend();
        //一杯混合咖啡(1)加摩卡(3)为4元
        // 在单个混合咖啡中包装了摩卡
        beverage1 = new Mocha(beverage1);
        System.out.println(beverage1.getDescription()+","+beverage1.cost());

        //一杯混合咖啡(1)加摩卡(3)加摩卡(3)为7元
        //可以在包装好的基础上再次进行包装
        beverage1 = new Mocha(beverage1);
        System.out.println(beverage1.getDescription()+","+beverage1.cost());
    }
}

• resultados operacionais
  

Descobrimos que o trabalho escreveu embalagem, você pode conseguir uma função de embalagem!

• FIG classe de formulário
  

Um segundo exemplo:

• estrutura gráfico
  
• implementação de código

/**
 * 被装饰者抽象类
 */
public abstract class Drink {

    public String des;//描述
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    //计算费用的抽象 方法
    public  abstract float cost();
}

/**
 * 缓冲层
 */
public class Coffee extends Drink {
    @Override
    public float cost() {
        return super.getPrice();
    }
}

/**
 * 被装饰者：意大利咖啡
 */
public class Espresso extends Coffee {

    public Espresso(){
        setDes("意大利咖啡");
        setPrice(6.0f);
    }
}


/**
 * 装饰者抽象类：
 */
public class Decorator extends Drink {
    private Drink obj;

    public Decorator(Drink obj) {//组合
        this.obj = obj;
    }

    @Override
    public float cost() {
        //getPrice自己的价格
        return super.getPrice() + obj.cost();
    }


    public String getDes(){
        //obj.getDes()被装饰者的信息
        return super.des+" "+super.getPrice()+"&&"+obj.getDes();
    }
}


/**
 * 被装饰者：LongBlack
 */
public class LongBlack extends Coffee {
    public LongBlack() {
        setDes("LongBlack");
        setPrice(5.0f);
    }
}

/**
 * 被装饰者：ShortBlack
 */
public class ShortBlack extends Coffee {
    public ShortBlack() {
        setDes("ShortBlack");
        setPrice(4.0f);
    }
}

/**
 * 装饰者：
 */
public class Milk extends Decorator {
    public Milk(Drink obj) {
        super(obj);
        setDes("牛奶");
        setPrice(2.0f);
    }

}

/**
 * 装饰者：
 */
public class Soy extends Decorator {
    public Soy(Drink obj) {
        super(obj);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

/**
 * 装饰者：
 */
public class Chocolate extends Decorator {

    public Chocolate(Drink obj) {
        super(obj);
        setDes("巧克力");
        setPrice(3.0f);
    }
}

public class CoffBar {
    public static void main(String[] args) {

        //1.点一份LongBlank
        Drink order = new LongBlack();
        System.out.println("费用1="+order.cost());
        System.out.println("描述="+order.getDes());
        
        //2.加一份牛奶
        order = new Milk(order);
        System.out.println("加入一份牛奶后的费用1="+order.cost());
        System.out.println("描述="+order.getDes());

        //3.加入一份巧克力
        order = new Chocolate(order);
        System.out.println("加入一份牛奶,一份巧克力后的费用1="+order.cost());
        System.out.println("描述="+order.getDes());
    }
}

• resultados operacionais
  
• FIG classe de formulário
  

Java I / O

• A partir do código fonte JDK, podemos encontrar

//装饰者抽象类类继承了被装饰者：InputStream 
public class FilterInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
     //聚合了抽象组件componment
    protected volatile InputStream in;

    /**
     * Creates a <code>FilterInputStream</code>
     * by assigning the  argument <code>in</code>
     * to the field <code>this.in</code> so as
     * to remember it for later use.
     *
     * @param   in   the underlying input stream, or <code>null</code> if
     *          this instance is to be created without an underlying stream.
     */
    //利用构造方法初始化InputStream 
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
----------------------------------------------------------------------------------------
//被装饰者继承抽象类InputStream
public
class FileInputStream extends InputStream
{
    .......
}
----------------------------------------------------------------------------------------
//实际的装饰者继承装饰者抽象类
public
class DataInputStream extends FilterInputStream implements DataInput {

    ...
 }

resumo:

1. Padrão decorador, um grupo de classes decoradas usados para embrulhar componentes de concreto.
2. classe decorador reflete o tipo de componentes a serem decorados (na verdade, eles têm o mesmo tipo, herança ou interfaces foram atingidos).
3. decorador acrescenta o comportamento anterior pode ser decorador / ou atrás de seu comportamento, até mesmo o comportamento de todo o decorador substituído off, para atingir uma finalidade específica.
4. Você pode usar um número ilimitado de decoradores de embalagem componente.
O componente cliente do decorador é geralmente transparente, em particular, dependerá do tipo de cliente a menos que o componente.