装饰者设计模式_装饰着设计模式-CSDN博客

本文链接：https://blog.csdn.net/zxiang248/article/details/51817007

装饰者设计模式：增强一个类的功能，而且还可以让这些装饰类互相装饰

装饰者设计模式设计初衷：通常使用继承来实现功能的扩展，如果这些需要扩展的功能繁多，那么势必会生成许多子类，增加系统的复杂性。

装饰者设计模式特点：装饰者与被装饰者拥有共同的超类，继承的目的是为了继承类型而不是行为。

应用：实际上Java 的I/O API就是使用Decorator实现的。

person.java

package zx.decorator.test2;

public class Person {

    public Person(){};

    private String name;

    public Person(String name){
        this.name=name;
    }

    public void show(){
        System.out.println("装饰的"+name);
    }
}

Finery.java

package zx.decorator.test2;

public class Finery extends Person{

    protected Person component;

    //装扮
    public void Decorator(Person component){
        this.component=component;
    }

    @Override
    public void show() {
        if(component!=null){
            component.show();
        }
    }
}

class TShirts extends Finery{
    @Override
    public void show() {
        super.show();
        System.out.println("大T恤");
    }
}

class BigTrouser extends Finery{

    @Override
    public void show() {
        super.show();
        System.out.println("跨裤");
    }
}

class Sneakers extends Finery{

    @Override
    public void show() {
        super.show();
        System.out.println("运动鞋");
    }
}

在Finery类中的构造方法里面传入的参数是父类Person，根据多态，只要是父类的实现类都可以传入进去。
又因为在每个具体装饰类中，都会先调用super方法，而该super已经由构造传递并指向了具体的某一个装饰者类（这个可以根据需要调换位置），那么调用的即为装饰类的方法，即表现出一种装饰、链式的类似于过滤的行为。
Test.java

package zx.decorator.test2;

public class Test {

    public static void main(String[] args) {
        Person person = new Person("zx");
        System.out.println("第一种装扮");
        Sneakers sneakers = new Sneakers();
        BigTrouser bigTrouser = new BigTrouser();
        TShirts tShirts = new TShirts();

        sneakers.Decorator(person);
        bigTrouser.Decorator(sneakers);
        tShirts.Decorator(bigTrouser);
        tShirts.show();

    }

}

输出
这里写图片描述

/*
 BufferedReader是不是拓展了FileReader的功能。
 BuferedWriter 也是拓展了FileWriter的功能。

 需求1： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号。

 需求2：编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号。

 需求3： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号。

 需求4： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号+ 分号。

 需求5： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有分号+ 双引号。

 需求6： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有双引号+ 行号。

 需求7： 编写一个类拓展BufferedReader的功能， 增强readLine方法返回 的字符串带有行号+ 分号+双引号。

----| Reader
-----------| BufferedReader
---------------| BufferedLineNum  带行号
---------------| BufferedSemi    带分号
---------------| BufferedQuto   带双引
---------------| 子类.. 
---------------|

增强一个类的功能时候我们可以选择使用继承：

通过继承实现增强一个类的功能优点：   代码结构清晰，通俗易懂。

缺点： 使用不灵活，会导致继承的体系过于庞大。

 */
class BufferedLineNum extends BufferedReader{
    //行号
    int count = 1 ;

    public BufferedLineNum(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line = super.readLine(); 
        if(line ==null){
            return null;
        }
        line = count+" "+ line;
        count++;
        return line;
    }   
}


//带分号的缓冲输入字符流
class BufferedSemi extends BufferedReader{

    public BufferedSemi(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line =  super.readLine();
        if(line==null){
            return null;
        }
        line = line+";";
        return line;
    }
}


//带双引号的缓冲输入字符流
class  BufferedQuto extends BufferedReader{

    public BufferedQuto(Reader in) {
        super(in);
    }

    @Override
    public String readLine() throws IOException {
        String line = super.readLine();
        if(line==null){
            return null;
        }
        line = "\""+line+"\"";
        return line;
    }
}

public class Demo1 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\Demo1.java");
        //建立数据的输入通道
        FileReader fileReader = new FileReader(file);
        //建立带行号的缓冲输入字符流
        BufferedLineNum bufferedLineNum = new BufferedLineNum(fileReader);

        //带有分号的缓冲输入字符流
        BufferedSemi bufferedSemi = new BufferedSemi(fileReader);

        //带有双引号的缓冲输入字符流
        BufferedQuto bufferedQuto = new BufferedQuto(fileReader);

        String line = null;
        while((line = bufferedQuto.readLine())!=null){
            System.out.println(line);
        }
    }
}

通过装饰者设计模式实现

//带行号的缓冲输入字符流
class BufferedLineNum2 extends BufferedReader {

    // 在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;

    int count = 1;

    public BufferedLineNum2(BufferedReader bufferedReader) {
        super(bufferedReader);
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException {
        String line = bufferedReader.readLine();
        if (line == null) {
            return null;
        }
        line = count + " " + line;
        count++;
        return line;
    }
}

// 带分号缓冲输入字符流
class BufferedSemi2 extends BufferedReader {

    // 为什么要继承? 是为了让这些装饰类的对象可以作为参数进行传递，达到互相装饰 的效果。

    // 在内部维护一个被装饰类的引用。
    BufferedReader bufferedReader;

    public BufferedSemi2(BufferedReader bufferedReader) {
        // new BuffereLineNum();
        super(bufferedReader);
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException {
        String line = bufferedReader.readLine(); // 如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
        if (line == null) {
            return null;
        }
        line = line + ";";
        return line;
    }

}

// 缓冲类带双引号
class BufferedQuto2 extends BufferedReader {

    // 在内部维护一个被装饰的类
    BufferedReader bufferedReader;

    public BufferedQuto2(BufferedReader bufferedReader) { // new BufferedSemi2();
        super(bufferedReader); 
        this.bufferedReader = bufferedReader;
    }

    public String readLine() throws IOException {
        String line = bufferedReader.readLine(); // 如果这里的ReadLine方法是调用了buffereLineNum的readLine方法，问题马上解决。
        if (line == null) {
            return null;
        }
        line = "\"" + line + "\"";
        return line;
    }

}

public class Demo2 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\Demo1.java");
        FileReader fileReader = new FileReader(file);
        // 建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        // 建立带行号的缓冲输入字符流
        BufferedLineNum2 bufferedLineNum = new BufferedLineNum2(bufferedReader);

        // 带分号的缓冲输入字符流
        BufferedSemi2 bufferedSemi2 = new BufferedSemi2(bufferedLineNum);

        // 带双引号的缓冲输入字符流
        BufferedQuto2 bufferedQuto2 = new BufferedQuto2(bufferedSemi2);

        String line = null;
        while ((line = bufferedQuto2.readLine()) != null) {
            System.out.println(line);
        }
    }

}

练习：一家三口每个人都会工作，儿子的工作就是画画，母亲的工作就是在儿子的基础上做一个增强，不单止可以画画，还可以上涂料。爸爸的工作就是在妈妈基础上做了增强，就是上画框。

interface Work{

    public void work();
}

class Son implements Work{

    @Override
    public void work() {
        System.out.println("画画...");
    }
}


class Mather implements Work{

    //需要被增强的类。
    Work worker;

    public Mather(Work worker){
        this.worker = worker;
    }

    @Override
    public void work() {
        worker.work();
        System.out.println("给画上颜色..");
    }
}


class Father implements Work{

    //需要被增强的类的引用
    Work worker;

    public Father(Work worker){
        this.worker = worker;
    }

    @Override
    public void work() {
        worker.work();
        System.out.println("上画框...");
    }
}

public class Demo3 {

    public static void main(String[] args) {
        Son s = new Son();
//      s.work();
        Mather m = new Mather(s);
//      m.work();
        Father f = new Father(s);
        f.work();
    }
}