装饰器和外观设计模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
//ReadFile抽象类
public abstract class FileRead {
    public abstract void read();
}

//读取文本文件类
public class FileTextRead extends FileRead {
    String name = "文本";
    @Override
    public void read() {
        System.out.println(name + "文件直接读取.....");
    }
}

//读取音乐文件类
public class FileMusicRead extends FileRead {
    String name = "音乐";
    @Override
    public void read() {
        System.out.println(name + "文件直接读取.......");
    }
}

//读取视频文件类
public class FileVedioRead extends FileRead {
    String name = "视频";
    @Override
    public void read() {
        System.out.println(name + "文件直接读取,......");
    }
}

/**
* 缓冲类，同样继承ReadFile类，但是里面创建了父类对象，可以传入其三个子类对象
* 实现了三个子类各自功能的同时还增加了缓冲机制
*/
public class BufferdFileRead extends FileRead {
    private FileRead fileRead;
	
	//这里会实现多态
    public BufferdFileRead(FileRead fileRead) {
        this.fileRead = fileRead;
    }

    @Override
    public void read() {	
        //这个read方法是缓冲类自己的read
        //这个read是传入的FileRead类对象或者其子类对象的read方法
        fileRead.read();	
        System.out.println("缓存。。。。。");
    }
}

//测试
public class test {
    public static void main(String[] args) {
        FileTextRead fileTextRead = new FileTextRead();
        FileMusicRead fileMusicRead = new FileMusicRead();
        FileVedioRead fileVedioRead = new FileVedioRead();

        new BufferdFileRead(fileTextRead).read();
        new BufferdFileRead(fileMusicRead).read();
        new BufferdFileRead(fileVedioRead).read();
    }
}

//执行结果
文本文件直接读取.....
缓存。。。。。
音乐文件直接读取.......
缓存。。。。。
视频文件直接读取,......
缓存。。。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class BufferedInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
    protected volatile InputStream in;

    /**
     * 构造方法
     */
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
    
    /**
    * 装饰代码，增强功能
    */
    public void f() {
        //功能增强代码
        in.f();
    }
    
    /**
    * 其他不需要增强的方法，重新调用一下InputStream中的方法，否则无法将最终读取数据的任务委派给传递进来的InputStream对象
    */
    public void function() {
        in.fiunction();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
> public class FilterInputStream extends InputStream {
>     /**
>      * The input stream to be filtered.
>      */
>     protected volatile InputStream in;
> 
>     /**
>      * 构造方法
>      */
>     protected FilterInputStream(InputStream in) {
>         this.in = in;
>     }
> 
>     public int read() throws IOException {
>         return in.read();
>     }
> 
>     public int read(byte b[]) throws IOException {
>         return read(b, 0, b.length);
>     }
> 
>     public int read(byte b[], int off, int len) throws IOException {
>         return in.read(b, off, len);
>     }
> 
>     public long skip(long n) throws IOException {
>         return in.skip(n);
>     }
> 
>     public int available() throws IOException {
>         return in.available();
>     }
> 
>     public void close() throws IOException {
>         in.close();
>     }
> 
>     public synchronized void mark(int readlimit) {
>         in.mark(readlimit);
>     }
> 
>     public synchronized void reset() throws IOException {
>         in.reset();
>     }
> 
>     public boolean markSupported() {
>         return in.markSupported();
>     }
> }

1
2
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(new File("D:/Java/Blog/Demo.txt")));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public interface CommonService {

    /** 方法 */
    void function();
} 

public class AServiceImpl implements CommonService {

    /**  A的方法实现 */
    @Override
    public void function() {
        System.out.println("执行A的方法");
    }
}

public class BServiceImpl implements CommonService {

    /**  实现的公共接口 */
    private CommonService commonService;

    /** 构造方法 */
    public BServiceImpl(CommonService commonService) {
        this.commonService = commonService;
    }

    /** 执行B的方法 */
    @Override
    public void function() {
        System.out.println("执行B所需要的其他代码.......");
        commonService.function();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package facade;
public class FacadePattern
{
    public static void main(String[] args)
    {
        Facade f=new Facade();
        f.method();
    }
}
//外观角色
class Facade
{
    private SubSystem01 obj1=new SubSystem01();
    private SubSystem02 obj2=new SubSystem02();
    private SubSystem03 obj3=new SubSystem03();
    public void method()
    {
        obj1.method1();
        obj2.method2();
        obj3.method3();
    }
}
//子系统角色
class SubSystem01
{
    public  void method1()
    {
        System.out.println("子系统01的method1()被调用！");
    }   
}
//子系统角色
class SubSystem02
{
    public  void method2()
    {
        System.out.println("子系统02的method2()被调用！");
    }   
}
//子系统角色
class SubSystem03
{
    public  void method3()
    {
        System.out.println("子系统03的method3()被调用！");
    }   
}