设计模式之结构型模式

1、适配器模式

/**
 * 目标抽象类：定义客户所需接口
 */
public interface Target {
    void m1();
    void m2();
}

/**适配器模式：
 * 适用场景：（1）系统需要使用一些现有的类，而这些类的接口不符合系统的需要，甚至没有这些类的源代码
 * （2）想创建一个可以重复使用的类，用于一些彼此之间没有太大关联的一些类
 * 优点：适配器模式将目标类和适配者类解耦，通过引入适配器类来重用现有的适配者类，无需修改原有结构
 * 适配器类：适配者类和适配器类是关联关系，并且适配者作为对象被适配器引入，所以此种适配器也叫对象适配器
 */
public class Adapter implements Target {
    private ClassA classA;
    private ClassB classB;

    public Adapter(){
        classA=new ClassA();
        classB=new ClassB();
    }
    @Override
    public void m1(){
        classA.m1();
    }
    @Override
    public void m2(){
        classB.m2();
    }
}

/**
 * 适配者类
 */
public class ClassA {
    public void m1(){
        System.out.println("ClassA--m1");
    }
    public void m2(){
        System.out.println("ClassA--m2");
    }
}

/**
 * 适配者类
 */
public class ClassB {
    public void m1(){
        System.out.println("ClassB--m1");
    }
    public void m2(){
        System.out.println("ClassB--m2");
    }
}

/**
 * 缺省适配器类:定义成抽象类，使用空方法实现Target接口的所有接口。
 */
public abstract class AbstractAdapter implements Target {
    public void m1() {
    }

    public void m2() {
    }
}

2、代理模式

/**
 * 抽象主题类
 */
public interface Subject {
    void request();
}

/**
 * 代理模式
 * 代理类
 */
public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        realSubject = new RealSubject();
    }

    public void proRequest() {
        System.out.println("proRequest");
    }

    @Override
    public void request() {
        proRequest();
        realSubject.request();
        afterRequest();
    }

    public void afterRequest() {
        System.out.println("afterRequest");
    }
}

/**
 * 真实主题类
 */
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject");
    }
}

3 桥接模式

有pen和pencil两种笔（第一维度），如果让两种笔都实现蓝色和红色功能（第二维度），则使用桥接模式

/**
 * 抽象类
 */
public abstract class Abstraction {
    protected Implementor implementor;//与Implementor接口建立关联关系

    public void setImplementor(Implementor implementor){
        this.implementor=implementor;
    }

    public abstract void operate();

}
public class Pen extends Abstraction {
    @Override
    public void operate() {
        System.out.println("paint by pen");
        implementor.paint();
    }
}

public class PenCil extends Abstraction {
    @Override
    public void operate() {
        System.out.println("paint by pencil");
        implementor.paint();
    }
}

public interface Implementor {
    void paint();
}    

public class BlueImplementor implements Implementor {
    @Override
    public void paint() {
        System.out.println("color is blue");
    }
}

public class RedImplementor implements Implementor {
    @Override
    public void paint() {
        System.out.println("color is red");
    }
}

 4、组合模式

public interface File {
    void operate();
}

public class Folder implements File {
    private List<File> files=new ArrayList<>();

    @Override
    public void operate() {
        for (File file : files){
            file.operate();// 此处递归调用了子节点的operate
        }
    }

    public List<File> getFiles() {
        return files;
    }

    public void addFiles(File file) {
        this.files.add(file);
    }
}

public class ImageFile implements File {
    @Override
    public void operate() {
        System.out.println("kill imageFile");
    }
}

public class TextFile implements File {
    @Override
    public void operate() {
        System.out.println("kill TextFile");
    }
}

public class Test {

    /**
     * 需求：有folder1{imageFile1,folder{imageFile,textFile}}的文件夹结构，现需要遍历folder1中的所有文件并进行杀毒操作

     * 组合模式是用来处理树形结构的模型
     * 容器类（Folder）和叶子类(ImageFile和TextFile)都实现了接口File，进而可以对容器类和叶子类进行统一处理
     * @param args
     */
    public static void main(String[] args){
        Folder folder=new Folder();
        ImageFile imageFile=new ImageFile();
        TextFile textFile=new TextFile();
        folder.addFiles(imageFile);
        folder.addFiles(textFile);

        Folder folder1=new Folder();
        ImageFile imageFile1=new ImageFile();
        folder1.addFiles(imageFile1);
        folder1.addFiles(folder);

        folder1.operate();
    }

}

输出：

kill imageFile
kill imageFile
kill TextFile