SEARU.ORG
当前位置:SEARU.ORG > Linux 教程 > 正文

Java 的设计模式之一装饰者模式

刚开始接触装饰者的设计模式,感觉挺难理解的,不够后来花了一个晚上的时间,终于有头绪了

装饰者设计模式:如果想对已经存在的对象进行装饰,那么就定义一个类,在类中对已经有的对象进行功能的增强或添加另外的行为,这个类就叫装饰者类。被修饰的类叫被装饰者类,是已经存在有的功能。在装饰者类之间又可以互相装饰

特点:
          1.装饰类通过构造方法来接收被装饰者的对象,调用它里面的功能或行为
          2. 基于对被装饰对象的功能进行扩展,提供更强大的功能

Java中的IO流是典型的装饰者模式

下面来看一行简短的代码:

扩展一个接口,定义一个抽象的方法,这个接口实际上就是一个被装饰者类

interface Work {
    public void work();
}

画画类:

class Drawing implements Work { //实现接口
    
    @Override
    public void work() {  //必须实现接口中的方法
        // TODO Auto-generated method stub
        System.out.println("画画");
    }
}

上色类:

class Colour implements Work {
    
    Work w;//在内部维护一个被装饰的类
    
    public Colour(Work w) {
        this.w = w;
    }
    @Override
    public void work() {
        
        w.work();
        System.out.println("给画上色");
    }
}

装裱类:

class Mounting implements Work {
    
    Work w;//在内部维护一个被装饰的类
        
    public Mounting(Work w) {
        
        this.w = w;
    }
        
    @Override
    public void work() {
        
        w.work();
        System.out.println("给画装裱");
    }
}

测试类:

public class Test {

    public static void main(String[] args) throws FileNotFoundException {
        
        Work w = new Drawing();
        Colour c = new Colour(w);
        Mounting m = new Mounting(c);
        m.work();
    }
}

 

上面是一个简单的装饰者模式。

装饰者模式的设计原则:
               1.多用组合,少用继承
               继承的子类实现父类的行为,是在编译时静态决定的,而且继承的行为是相同的,但是利用装饰者之间的相互修饰(组合)
          就可以扩展出强大的功能,可以动态的进行扩展,也可以撤销
            2.对扩展开放,对修改关闭
              扩展是在继承的前提下实现,在子类中修改。扩展是在继承被装饰者类实现行为或功能,不需要修改装饰者的类,只是在此基础        上,装饰另外的功能或行为

需求:定义一个人吃面,可以加生菜,也可以加辣椒,也可以都加

EatNoodle类:

class EatNoodle {
    
    public void eat() {
        
        System.out.print("吃面");
    }
}

装饰者类

class SunEatNoodle1 {
    
    EatNoodle eatNd;
    
    public SunEatNoodle1(EatNoodle eatNd) {  //定义构造方法来接收被装饰者的对象
        
        this.eatNd = eatNd;
    }
    
    public void eat() {
        
        eatNd.eat();
        System.out.println("加点香菜,感觉好吃");
    }
}

装饰者之间的相互修饰

class SunEatNoodle2 {
    
    //EatNoodle eatNd;
    SunEatNoodle1 sunEat1;
    public SunEatNoodle2( SunEatNoodle1 sunEat1) {   //定义构造方法来接收装饰者的对象
        
        //this.eatNd = eatNd;
        this.sunEat1 = sunEat1;
    }
    
    public void eat() {
        
        System.out.println();
        //eatNd.eat();
        sunEat1.eat();
        System.out.println("再来点辣椒,就更好吃了");
    }
}

测试类:

public class Demo1 {

    public static void main(String[] args) {  
        
        EatNoodle eatNoodle = new EatNoodle();
        //eatNoodle.eat();
        
        SunEatNoodle1 sunEat1 = new SunEatNoodle1(eatNoodle);
        sunEat1.eat();
        
        SunEatNoodle2 sunEat2 = new SunEatNoodle2(sunEat1);//装饰者类之间的相互修饰
        sunEat2.eat();
    }

}

运行结果:

装饰者与继承的关系

在添加 不同功能的时候。我们会想到了用继承来实现。而且刚学装饰者模式的时候,觉得挺难理解的,装饰者的前世今生就是继承。那为什么不用继承呢?这样岂不是更容易理解,用起来也挺方便。下面通过一个简单的Demo做一下比较。

需求:用继承来实现通过readLine读取代码  ,每一行加上一个行号和分号的功能

//1.添加行号,默认继承BufferedReader
class BufferedReaderLineNum extends BufferedReader {
    
    int count = 0;
    
    public BufferedReaderLineNum(BufferedReader in) { //Reader:默认创建一个目标文件的缓冲字符输入流的大小         
        super(in);
    }
    
    @Override//3.重写父类的readLine方法
    public String readLine() throws IOException {
        
        String countent = super.readLine();//调用父类默认的行号
        
        if (countent == null) {
            return null;
        }
        
        //System.out.println(count + " " + countent);
        count++;
        return count + " " + countent;
    }
}

//添加分号
class BufferedReaderSemicolon extends BufferedReader {
BufferedReader reader;
public BufferedReaderSemicolon(BufferedReader in) {//Reader:默认创建一个目标文件的缓冲字符输入流的大小 super(in); this.reader = in; } @Override//3.重写父类的readLine方法 public String readLine() throws IOException { String countent = reader.readLine(); if (countent == null) { //判断数据已经读完 return null; } return countent + ";"; } } public class Demo1 { public static void main(String[] args) throws IOException { //FileReader用于字符输入流,FileInputStream是用字节输入流 //1.创建通道,拿到一个指定的目标文件 FileReader fileRead = new FileReader("C:\\java\\decorator\\Test.java"); BufferedReader reader = new BufferedReader(fileRead); //2.创建行号的缓冲流 BufferedReaderLineNum readerLineNum = new BufferedReaderLineNum(reader); //.创建分号的缓冲流 BufferedReaderSemicolon readerSemicolon = new BufferedReaderSemicolon(readerLineNum); String content = null; //使用readLine(),包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null while((content = readerSemicolon.readLine()) != null) { System.out.println(content); } //4.关闭资源 readerLineNum.close(); } } 

然后再通过装饰者模式来实现上面的功能:

//添加行号
class BufferederReadLineNum extends BufferedReader {
    
    BufferedReader bufferedReader;    //1.内部维护的被装饰者的类
    int count = 1;
    
    public BufferederReadLineNum(BufferedReader read) {
        super(read);//如果没有这行代码,会显示编译报错,显示没有隐式性的给这个构造函数定义
        this.bufferedReader = read;
    }

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

//2.添加分号
class BufferedReaderSemicolon1 extends BufferedReader {
    
    BufferedReader bufferedReader;    //1.内部维护的被装饰者的类
    
    public BufferedReaderSemicolon1(BufferedReader read) { 
        super(read);
        this.bufferedReader = read;
    }
    
    @Override//3.重写父类的readLine方法
    public String readLine() throws IOException {
        
        String countent = super.readLine();  //调用父类默认的行号
        if (countent == null) {   //判断数据已经读完
            return null;
        }
        
        return countent + ";";
    }
}



public class Test2 {

    public static void main(String[] args) throws IOException {
        
        //1.创建通道,拿到一个指定的目标文件
        FileReader fileRead = new FileReader("C:\\java\\代码\\src\\Test.java");
        
        //2.创建缓冲区 
        BufferedReader bufferedReader = new BufferedReader(fileRead);
                
        //3创建分号的缓冲流  
        BufferedReaderSemicolon1 readerSemicolon = new BufferedReaderSemicolon1(bufferedReader);
        
        //创建行号的缓冲流    在装饰者创建的
        BufferederReadLineNum readerLineNum = new BufferederReadLineNum(readerSemicolon);
                
        //4.读取数据
        String content = null;
        //使用readLine(),包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null
        while((content = readerLineNum.readLine()) != null) {
            System.out.println(content);
        }
        //5.关闭资源
        readerLineNum.close();
        
    }
}

通过上面的代码,可能不能完全看出使用装饰者模式的强大功能,你可以在多创建几个类,添加多个功能,结果就显而易见了。

在实现多个功能的时候,使用继承的体系会过于庞大,显得很臃肿。

使用了装饰者来进行动态性的添加一些附加功能,确保在运行时,不用改变该对象的结构就可以在外部添加附加的功能。通常也是通过继承来实现给定类的功能扩展来实现更强大的功能。提高了代码的可维护性和简洁性。

未经允许不得转载:SEARU.ORG » Java 的设计模式之一装饰者模式

赞 (0)
分享到:更多 ()

评论 0