23种设计模式中篇

结构型设计模式 ，共7种

（1）桥接模式

（2）装饰者模式

（3）组合模式

（4）适配器模式

（5）外观模式

（6）享元模式

（7）代理模式

桥接模式【jdbc采用的就是这种模式】

将抽象和实现部分的分离，更好的可扩展性，桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围有一定的局限性

//抽象的实现类
public interface Memory {

    void addMemory();
}

//具体的实现类
public class Memory6G  implements Memory{

    @Override
    public void addMemory() {
        System.out.println("安装了6G内存");
        
    }

}

//具体的实现类
public class Memory8G  implements Memory{

    @Override
    public void addMemory() {
        System.out.println("安装了8G内存");
    }

}

//具体部分的抽象
public abstract class Phone {
    
    protected  Memory memory;

    public void setMemory(Memory memory) {
        this.memory = memory;
    }
    
    protected abstract void buyPhone();
}

public class Huiwei extends Phone{

    
    @Override
    protected void buyPhone() {
        System.out.println("购买华为手机");
        memory.addMemory();
        
    }

}

public class Xiaomi extends  Phone {

    @Override
    protected void buyPhone() {
        System.out.println("购买小米手机");
        memory.addMemory();
    }

}

public class MainClass {

    public static void main(String[] args) {
        
        Phone  phone =   new Huiwei();
        phone.setMemory(new Memory6G());
        phone.buyPhone();
        System.out.println("===============");
        phone.setMemory(new Memory8G());
        phone.buyPhone();
        
    }
}

装饰者模式【jdk中有关流的操作】

给已经存在的对象动态的添加功能

//被装饰对象基类
public abstract class Girl {

    String description = "no particular";
 
    public String getDescription(){
        return description;
    }

}

//具体被装饰对象
public class AmericanGirl extends Girl {

    public AmericanGirl() {
        description = "American Girl";
    }

}

//装饰者抽象类
public abstract class GirlDecorator extends Girl {
 
    public abstract String getDescription();
 
}

//具体装饰者
public class Science extends GirlDecorator {

    private Girl girl;

    public Science(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String getDescription() {
        return this.girl.getDescription() + "  Like Science";
    }

    public void caltulateStuff() {
        System.out.println("scientific calculation!");
    }
}

//具体装饰者
public class Art extends GirlDecorator {
 
    private Girl girl;
 
    public Art(Girl girl){
        this.girl = girl;
    }
 
    @Override
    public String getDescription() {
        return this.girl.getDescription() + "  Like Art";
    }
 
    public void draw() {
        System.out.println("draw pictures!");
    }
}

public class MainClass {
 
    public static void main(String[] args) {
        //普通美国女孩
        Girl g1 = new AmericanGirl();
        System.out.println(g1.getDescription());
        
        //喜欢科学
        Girl g2 = new Science(g1);
        System.out.println(g2.getDescription());
 
        //喜欢艺术
        Girl g3 = new Art(g2);
        System.out.println(g3.getDescription());
    }
}

组合模式

将对象组合成树形结构以表示“部分-整体”的层次结构。即对象包含对象，整体包含部分，组合模式使客户端可以使用一致的方法操作单个对象和组合对象

/**
 * 节点公共抽象类
 */
public abstract class Node {

    private String name;

    /**
     * 带参数的构造方法
     * @param name
     */
    public Node(String name){
        this.name = name;
    }

    /**
     * 获得节点信息
     * @return
     */
    public String getInfo(){
        return "名称："+name;
    }
}

/**
 * 叶子节点（文件）
 */
public class File extends Node {
    
    /**
     * 调用父类的构造方法
     * @param name
     */
    public File(String name) {
        super(name);
    }
}

/**
 * 分支节点（文件夹）
 */
public class Folder extends Node{

    /**
     * 子集
     */
    private ArrayList children = new ArrayList();

    /**
     * 带参数的构造方法
     * @param name
     */
    public Folder(String name){
        super(name);
    }

    /**
     * 新增节点，有可能是文件也有可能是文件夹
     * @param node
     */
    public void add(Node node){
        this.children.add(node);
    }

    /**
     * 获得子集
     *
     * @return
     */
    public ArrayList getChildren() {
        return children;
    }
}

public class MainClass {

    public static void main(String[] args) {

        //定义根节点
        Folder root = new Folder("root");

        //定义二级节点的文件夹
        Folder imageFolder = new Folder("image-folder");
        Folder documentFolder = new Folder("document-folder");
        //定义二级节点的文件
        File systemFile = new File("system-file.bat");

        //定义三级节点的文件夹
        Folder pngFolder = new Folder("png-folder");
        Folder gifFolder = new Folder("gif-folder");
        //定义三级节点的文件
        File testHtml = new File("test.html");
        File testJS = new File("test.js");

        //填充一级文件夹
        root.add(imageFolder);
        root.add(documentFolder);
        root.add(systemFile);
        //填充二级图片文件夹
        imageFolder.add(pngFolder);
        imageFolder.add(gifFolder);
        //填充二级文档文件夹
        documentFolder.add(testHtml);
        documentFolder.add(testJS);
        System.out.println(root.getInfo());
        //打印出来
        getChildrenInfo(root.getChildren(), 1);

    }

    /**
     * 递归遍历文件
     * @param arrayList
     */
    @SuppressWarnings("rawtypes")
    private static void getChildrenInfo(ArrayList  arrayList , int level){

        int length = arrayList.size();
        for(int m = 0;m<length;m++){
            Object item = arrayList.get(m);
            //如果是叶子节点就直接打印出来名称
            if(item instanceof File){
                System.out.println(printBlank(level)+ "文件  ： " +  ((File) item).getInfo());
            }else {
                //如果是分支节点就先打印分支节点的名称，再递归遍历子节点
                System.out.println(printBlank(level)  + "文件夹  ： " + ((Folder)item).getInfo());
                getChildrenInfo(((Folder)item).getChildren() , level +1);
            }

        }

    }

    private static String printBlank(int level) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < level; i++) {
            sb.append("*");
        }
        return sb.toString();
    }

}

 适配器模式

系统需要使用现有的类，而此类的接口不符合系统的需要。适配器将一个对象包装起来用以改变其接口  

//已经存在的类
public class Phone {
    public void typecPhone() {
        System.out.println("信息从Typec口的手机输出。");
    }
}

//适配接口
public interface Vga {
    void vgaInterface();
}

// 实现一个Type-c转VGA适配器，
public class Typec2Vga implements Vga{

    private Phone phone;
    
    public Typec2Vga(Phone phone) {
        // TODO Auto-generated constructor stub
        this.phone = phone;
    }
    
    @Override
    public void vgaInterface() {
        // TODO Auto-generated method stub
        if(phone != null) {
            phone.typecPhone();
            System.out.println("接收到Type-c口信息，信息转换成VGA接口中...");
            System.out.println("信息已转换成VGA接口，显示屏可以对接。");
        }
    }
}

public class MainClass {

    
    public static void main(String[] args) {
        
        Phone phone = new Phone();
        Vga vga = new Typec2Vga(phone);
        vga.vgaInterface();
    }
}

外观模式

为子系统中的一组接口提供了一个统一的访问接口，使得子系统更加容易使用

public class CPU {

    public void  start() {
        System.out.println("CPU start");
    }
    
    public void shutdown() {
        System.out.println("CPU shutdown");
    }
}

public class Disk {

    public void  start() {
        System.out.println("Disk start");
    }
    
    public void shutdown() {
        System.out.println("Disk shutdown");
    }
}

public class Memory {
    
    public void  start() {
        System.out.println("Memory start");
    }
    
    public void shutdown() {
        System.out.println("Memory shutdown");
    }
}

//外观
public class Computer {

    private CPU cpu;
    
    private Memory memory;
    
    private Disk disk;

    public Computer(CPU cpu, Memory memory, Disk disk) {
        super();
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }
    
    public void start() {
        cpu.start();
        memory.start();
        disk.start();
    }

}

public class MainClass {

    public static void main(String[] args) {
        
        CPU cpu = new CPU();
        Memory memory = new Memory();
        Disk disk = new Disk();
        Computer  computer = new Computer(cpu, memory, disk);
        computer.start();
        
    }

    
}

享元模式

通过共享技术来有效的支持大量细粒度的对象，为了尽量不创建多余的对象【线程池技术就是采用的享元模式】

public class FlyweightModel {
    /*
     * 享元模式—围棋落子
     */
    public static void main(String[] args) {
        String color = "黑";
        int x = 0;
        int y = 0;
        WQFlyweight wqFlyweight;
        for (int i = 0; i < 5; i++) {
            x = (int) (19 * Math.random());
            y = (int) (19 * Math.random());
            if (color.equals("黑")) {
                color = "白";
            } else {
                color = "黑";
            }
            wqFlyweight = WQFlyweightFactory.getWQFlyweight(color);
            if (wqFlyweight != null) {
                wqFlyweight.put(x, y);
            }
        }
    }
}

//享元模式实现围棋落子
//1、抽象享元类(外部状态（x，y）)
interface WQFlyweight {
    void put(int x, int y);// 外部状态,棋子位置
}

//2、具体享元类(内部状态（黑，白）)
class WQConFlyweight implements WQFlyweight {
    private String color;

    public WQConFlyweight(String color) {
        this.color = color;
    }

    @Override
    public void put(int x, int y) {
        System.out.println(color + "子：落于" + "（" + x + "," + y + "）" + "位置");
    }
}

//3、享元工厂类
class WQFlyweightFactory {
    // 确保内部状态实例只有两个
    private static WQFlyweight WHITE;
    private static WQFlyweight BLACK;

    private WQFlyweightFactory() {
    };

    public static WQFlyweight getWQFlyweight(String color) {
        if (color.equals("白")) {
            if (WHITE == null) {
                WHITE = new WQConFlyweight("白");
            }
            return WHITE;
        } else if (color.equals("黑")) {
            if (BLACK == null) {
                BLACK = new WQConFlyweight("黑");
            }
            return BLACK;
        }
        return null;
    }

}

 代理模式

客户端并不直接调用实际对象，而是通过调用代理来间接的调用实际对象

public interface Subject {
    void visit();
}

public class RealSubject implements Subject {

    private String name = "byhieg";
    @Override
    public void visit() {
        System.out.println(name);
    }
}

public class DynamicProxy implements InvocationHandler {
    private Object object;

    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(object, args);
        return result;
    }
}

public class MainClass {

    public static void main(String[] args) {
        
        Subject realSubject = new RealSubject();
        DynamicProxy proxy = new DynamicProxy(realSubject);
        ClassLoader classLoader = realSubject.getClass().getClassLoader();
        Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new  Class[]{Subject.class}, proxy);
        subject.visit();
        
    }
}