java学习之IO装饰设计模式

装饰设计模式就是对已有的对象的功能进行增强

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

例如：你有个对象有个功能 是在N年前建立的，如今你觉得功能不够用了 写个类把对象传进来就可以解决问题了 如果这个功能写错了 我就把自己写的功能去掉又不影响以前的功能灵活性相当强的。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

package com.gh.decorator;
/**
 * 具体的装饰者对象：黑豆;
 * @author ganhang
 *
 */
public class BlackBeanDecorator extends Decorator{

    public BlackBeanDecorator(Drink drink) {
        super(drink);
    }
    @Override
    public String description() {
        return super.description()+"+黑豆";
    }
    @Override
    public int cost() {
        return super.cost()+2;
    }
}

package com.gh.decorator;
/**
 * 装饰者父（基）类
 * @author ganhang
 *
 */
public abstract class Decorator implements Drink{
    private Drink drink;
    public Decorator(Drink drink) {
        this.drink=drink;
    }
    @Override
    public String description() {
        return drink.description();
    }

    @Override
    public int cost() {
        return drink.cost();
    }

}

package com.gh.decorator;
/**
 * 被装饰者对象的接口
 * @author ganhang
 *
 */
public interface Drink {
    //饮料的介绍
    public String description();
    //饮料的价格
    public int cost();
}

package com.gh.decorator;
/**
 * 具体的装饰者：鸡蛋；
 * @author ganhang
 *
 */
public class EggDecorator extends Decorator{

    public EggDecorator(Drink drink) {
        super(drink);
    }
    @Override
    public String description() {
        return super.description()+"+鸡蛋";
    }
    @Override
    public int cost() {
        return super.cost()+3;
    }
}

package com.gh.decorator;

/**
 * 具体的装饰者对象:纯豆浆;
 * @author ganhang
 *
 */
public class SoyaBeanMilk implements Drink{

    @Override
    public String description() {
        return "纯豆浆";
    }

    @Override
    public int cost() {
        return 5;
    }
    
}

package com.gh.decorator;

/**
 * 具体的装饰者对象：糖；
 * 
 * @author ganhang
 * 
 */
public class SugarDecorator extends Decorator {

    public SugarDecorator(Drink drink) {
        super(drink);
    }

    @Override
    public String description() {
        return super.description() + "+糖";
    }

    @Override
    public int cost() {
        return super.cost()+1;
    }
}

package com.gh.decorator;

public class test {
    public static void main(String[] args) {
        //生产一杯豆浆
        Drink soya=new SoyaBeanMilk();
        //豆浆里加鸡蛋
        EggDecorator eggsoya=new EggDecorator(soya);
        //加了鸡蛋的豆浆里加糖
        SugarDecorator sugarEggSoya=new SugarDecorator(eggsoya);
        //再加个黑豆。。。
        BlackBeanDecorator blackBeanSugarEggSoya=new BlackBeanDecorator(sugarEggSoya);
        //输出描述
        System.out.println(blackBeanSugarEggSoya.description());
        //输出价格
        System.out.println("价格是："+blackBeanSugarEggSoya.cost());
        
    }
}

刚好看了个视频 关于装饰设计模式 觉得挺精辟的就保留了下来

什么是装饰设计模式:

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

如一个简单的demo 人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了增强了吃饭的功能  虽然例子不是恰当 能说明问题就行

看代码：

//穷的时候吃饭简简单单的吃饭
class Person
{
    public void chiFan(){

        System.out.println("吃饭");
    }
}

//富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭
class SuperPerson
{
    private Person p;
    public SuperPerson(Person p){

        this.p=p;
    }

    public void superChiFan(){
        //吃饭前来杯开胃酒增加食量
        System.out.println("开胃酒");
        p.chiFan();
        //吃完饭后来根烟
        System.out.println("来根烟");
    }

}
public class PersonDemo
{   public static void main(String args[]){
    Person p=new Person();

    SuperPerson sp= new SuperPerson(p);

    sp.superChiFan();
    }
}

 以上只是简单说明一下，在JAVA IO中用了很多增强 如：FileRead中read()方法 只是一个一个字节去读，为了读得更快在BufferedReader就增强了read()方法而产生了reandLine()一行一行的去读

有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？

装饰是构造函数参数传递进行增强

如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的