图解设计模式--简单易懂

迭代器模式

通过聚合对象的遍历行为分离出来，抽象成迭代器来实现，目的是不暴露内部结构。
主要角色
1.抽象聚合（Aggregate）：定义存储，添加，删除聚合对象以及迭代器对象的接口。
2具体聚合（ConcreteAggregate）:实现抽象聚合类，返回一个具体迭代器的实例
3抽象迭代器（Iterator）:定义访问和遍历聚合元素的接口，
4具体迭代器（Concretelterator）:实现迭代器接口中的所有方法。

Aggregate有一个iterator方法返回Iterator接口对象。
Iterator的实现类是ConcreteIterator
ConcreteAggregate继承了Aggregate接口，重写iterator类，return ConcreteIterator是Iterator的实例。
ConcreteAggregate继承了父亲的方法，重写方法后

适配器模式Adapter
类适配器模式（使用继承的适配器）
对象适配器模式（使用委托的适配器）

1.类适配器模式。
一个接口Print对外提供两个抽象方法。一个类Banner正好有两个方法可用不同名，子类PrintBanner继承Banner实现Print，PrintBanner重写Print方法去调用Banner的党法。
就是把Banner的方法适配到Print上
代码如下：

public interface Print {
    public abstract void printWeak();
    public abstract void printStrong();
}

public class Banner {
    private  String string;

    public Banner(String string) {
        this.string = string;
    }
    public void showWithParent(){
        System.out.println("("+string+")");
    }
    public void showWithAster(){
        System.out.println("*"+string+"*");
    }
}

public class PrintBanner extends Banner implements Print{
    //如果父类只有一个有参构造，没有无参构造，子类必须继承构造方法，super调用父类的构造
    public PrintBanner(String string) {
        super(string);
    }

    @Override
    public void printWeak() {
        showWithParent();
    }

    @Override
    public void printStrong() {
        showWithAster();
    }
}

public class Main {
    public static void main(String[] args) {
        Print p=new PrintBanner("Hello");
        p.printStrong();
        p.printWeak();
    }
}

2.对象适配模式
把Print改成抽象类，一个类只能继承一个类，让对外提供方法的子类PrinterBanner继承Print类，重写方法，聚合Banner，去调用Banner的方法。
代码如下：

public abstract class Print {
    //方法是抽象的，类一定是抽象的
    public abstract void printWeak();
    public abstract void printStrong();
}

public class Banner {
    private  String string;

    public Banner(String string) {
        this.string = string;
    }
    public void showWithParent(){
        System.out.println("("+string+")");
    }
    public void showWithAster(){
        System.out.println("*"+string+"*");
    }
}

public class PrintBanner extends Print {
    private Banner banner;
    @Override
    public void printWeak() {
        banner.showWithParent();
    }

    @Override
    public void printStrong() {
        banner.showWithAster();
    }
}

public class Main {
    public static void main(String[] args) {
        Print p=new PrintBanner("Hello");
        p.printStrong();
        p.printWeak();
    }

}

Adapter模式的角色：
Targer（对象）
Client（请求者）
Adaptee（被适配）
Adapter（适配）

Template Method模板模式

再父类中定义处理流程的框架，再子类中实现具体的处理，这种模式就叫Templatemethod
父类是抽象类，子类继承父类，实现父类的抽象方法，父类的一般方法调用自己抽象方法。
代码如下：

public abstract class  AbstractDisplay {//抽象类
    public abstract void open();//交给子类的抽象方法
    public abstract void print();//交给子类的抽象方法
    public abstract void close();//交给子类的抽象方法
    public final void display(){
        open();
        for(int i=0;i<5;i++){
            print();
        }
        close();
    }
}

public class CharDisplay extends AbstractDisplay {
    private char ch;

    public CharDisplay(char ch) {//接收字符保存再ch中
        this.ch = ch;
    }
    @Override
    public void open() {
        System.out.print("<<");
    }
    @Override
    public void print() {
        System.out.print(ch);
    }
    @Override
    public void close() {
        System.out.println(">>");
    }
}

public class StringDisplay extends AbstractDisplay {
    private String string;
    private int width;

    public StringDisplay(String string) {
        this.string = string;//将传进来的字符串保存string
        this.width=string.getBytes().length;//把字符串的长度也保存
    }

    @Override
    public void open() {
    pringLine();
    }

    @Override
    public void print() {
        System.out.println("|"+string+"|");
    }

    @Override
    public void close() {
    pringLine();
    }
    public void pringLine(){
        System.out.print("+");
        for (int i=0;i<width;i++){
            System.out.print("-");
        }
        System.out.println("+");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractDisplay d1=new CharDisplay('H');
        AbstractDisplay d2=new StringDisplay("Hello");
        AbstractDisplay d3=new StringDisplay("你好世界");
        d1.display();
        d2.display();
        d3.display();
    }
}

Template Method模式的角色：
AbstractClass(抽象类):再模板中实现模板方法，声明所有的抽象方法
ConcreteClass(具体类)

优点：逻辑算法都在父类中写好了，调试bug比价好找
父类和子类是共同工作的，子类实现父类的抽象方法必须知道这些抽象方法被调用的时机。
再子类中可以使用父类中定义的方法
可以通过子类中增加方法以实现新的功能
再子类中重写父类方法可以改变程序的行为
再抽象类阶段确定处理的流程

Factory Method模式

Factory Method是用Template Method模式来构建生长城实例工厂，这就是FactoryMethod模式。
父类决定实例的生成方式，但不决定所要生成的具体的类，具体的处理全部交给子类负责。

Factory接口提供创建Product接口的方法，IDCardFactory实现了Factory，负责创建IDCard.看似是Factory创建Product，实则是儿子创建儿子，Product想创建啥样的就弄啥样的儿子，不取决于Factory。
代码如下：

public abstract class Factory {
    public final Product create(String owner){
        Product p=createProduct(owner);
        registerProduct(p);
        return p;
    }
    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}

public  abstract class Product {
    public abstract void use();
}

public class IDCard extends Product{
    private String owner;
    IDCard(String owner){
        System.out.println("制作"+owner+"IDCard");
        this.owner=owner;
    }
    @Override
    public void use() {
        System.out.println("使用"+owner+"IDCard");
    }

    public String getOwner(){
        return owner;
    }
}

public class IDCardFactory extends Factory {
    private List owners=new ArrayList();
    protected Product createProduct(String owner){
        return new IDCard(owner);
    }
    protected void registerProduct(Product product){
        owners.add(((IDCard)product).getOwner());
    }
    public List getOwners(){
        return owners;
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        Factory factory=new IDCardFactory();
        Product card1 = factory.createProduct("小明");
        Product card2 = factory.createProduct("小刚");
        Product card3 = factory.createProduct("大名");
        card1.use();
        card2.use();
        card3.use();
    }
}

单例模式Singleton

饿汉式单例
只会生成一个实例，Singleton定义static字段，并将其初始化为Singleton类的实例，类加载时初始化一次，Singleton的构造函数时private。线程安全
代码如下：

public class Singleton {
    private static Singleton singleton=new Singleton();
    private Singleton(){
        System.out.println("生成一个实例");
    }
    public static Singleton getInstance(){
        return singleton;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        Singleton obj1=Singleton.getInstance();
        Singleton obj2=Singleton.getInstance();
        if (obj1==obj2){
            System.out.println("同一个实例");
        }else {
            System.out.println("不是同一个实例");
        }
        System.out.println("End");
    }
}

懒汉式单例
什么时候用什么时候调用才生成实例，线程不安全
代码如下：

public class SingletonLazy {
    private static SingletonLazy instance;
    private SingletonLazy(){}
    public static synchronized SingletonLazy getInstance(){
        if (instance==null){
            instance=new SingletonLazy();
        }
        return instance;
    }
}

Prototype模式

MessageBox类和UnderLinePen类是两个实现了Product接口的类。只要事先将这两个类注册到Manage类中，随时复制新的实例。

代码如下

public interface Product extends Cloneable{
    public abstract void use(String s);
    public abstract Product createClone();
}

public class MessageBox implements Product {
    private char decochar;
    public MessageBox(char decochar){
        this.decochar=decochar;
    }
    @Override
    public void use(String s) {
        int length=s.getBytes().length;
        for(int i=0;i<length+4;i++){
            System.out.print(decochar);
        }
        System.out.println("");
        System.out.println(decochar+" "+s+" "+decochar);
        for (int i=0;i<length+4;i++){
            System.out.print(decochar);
        }
        System.out.println("");
    }

    @Override
    public Product createClone() {
        Product p=null;
        try {
            p= (Product) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}

public class UnderlinePen implements Product {
    private char ulchar;
    public UnderlinePen(char ulchar){
        this.ulchar=ulchar;
    }
    @Override
    public void use(String s) {
        int length=s.getBytes().length;
        System.out.println("\""+s+"\"");
        System.out.println(" ");
        for(int i=0;i<length;i++){
            System.out.print(ulchar);
        }
        System.out.println("");
    }

    @Override
    public Product createClone() {
        Product p=null;
        try {
            p= (Product) clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}

public class Manager {
    private HashMap showcase=new HashMap();
    public void register(String name,Product proto){
        showcase.put(name,proto);

    }
    public Product create(String protoname){
        Product p= (Product) showcase.get(protoname);
        return p.createClone();
    }
}

public class Main {
    public static void main(String[] args) {
        Manager manager=new Manager();
        UnderlinePen upen=new UnderlinePen('~');
        MessageBox messageBox=new MessageBox('*');
        MessageBox messageBox1=new MessageBox('/');
        manager.register("strong message",upen);
        manager.register("warning box",messageBox);
        manager.register("slash box",messageBox1);
        Product p1=manager.create("strong message");
        p1.use("HelloWorld");
        Product p2=manager.create("warning box");
        p2.use("HelloWorld");
        Product p3=manager.create("slash box");
        p3.use("HelloWorld");
    }
}