设计模式23种

设计模式

创建型模式

单例模式 Singleton

public class Singleton{
    private Singleton singleton=new Singleton();
    private Singleton(){}
    public Singleton getInstance(){
        return singleton;
    }
}

工厂模式 Factory

public class Factory{
    public static IFactoryable get(String str){
        if(str.equels("1"))
            return new Class1();
        if(str.equels("2"))
            return new Class2();
        else return new Class3();
    }
}

public class Class1 implements IFactoryable{  }
public class Class2 implements IFactoryable{  }
public class Class3 implements IFactoryable{  }

原型模式 Prototype

public class Prototype implements Cloneable{
    @override
    public Prototype clone(){
        return super.clone();
    }
}

建造者模式 Builder

public class PersonBuilder{
    String name;
    public PersonBuilder setName(String name){
        this.name=name;
    }

    public Person build(){
        return new Person(this);
    }
}
public class Person{
    String name;
    public Person(PersonBuilder builder){
        this.name=builder.name;
    }
}

结构型模式

外观模式 Facade

​ 外观模式为内部定义一个访问入口，该入口整合了内部功能。

​ 开机的过程，只需按下电源键，而不需要逐一开启CPU，显示器等。

public class Facade{
    private CPU cpu=new CPU();
    private Mainboard mainboard=new Mainboard();

   public void startSystem(){
        cpu.start();
        mainboard.start();
    }
}

public class CPU{
    public void start{
    }
}

public class Mainboard{
    public void start{
    }
}

享元模式 Flyweight

​ Flyweight即羽量级模式，用于减少内存开销

public class FlyweightTest{
    public void test(){
       IFlyweight fw= FlyweightFactory.getFlyweight(String mark);
       fw.action("");
    }
}

public interface IFlyweight{
    void action(String key);
}


public class FlyweightImpl{
    @Override
    public void action(String key){        
    }
}

public class FlyweightFactory{
    private static Map<String,IFlyweight> map=new HashMap<>();

    public static IFlyweight getFlyweight(String key){
        if(map.exist(key))
            return map.get(key);
        else
            map.put(key,new FlywieghtImpl());
    }

    public static  int getSize(){
        return map.size();
    }
}

组合模式 Composition

​ 该模式用于解决树形结构的数据访问问题

//定义基元
public abstarct class Component{

}

public class File extends Componet{
    String filename;
}

//定义同类型的容器
public class Folder extends Component{
    Component[] files;
    String foldername;
    public Folder(Component[] comp){
        files=comp;
    }
}

适配器模式 Adapter

interface IPlugin5V{
    void plugin();
}

public Class Plugin220V{
    public void plugin(){   
    }
}

public Class Adapter implements IPlugin5V(){
    @Override
    public void plugin(){

    }
}

代理模式 Proxy

public class OldClass{

}

public class Proxy {
    OldClass oc=new OldClass();

    public void test(){
        this.method1();
        oc.test();
    }

}

桥接模式 Bridge

Abstraction：抽象类。 
RefinedAbstraction：扩充抽象类。 
Implementor：实现类接口。 
ConcreteImplementor：具体实现类 。

interface IDraw{
    void drawShape(int x,int y);
}

public class DrawSqure implements IDraw{
    @Override
    public void drawShape(int x,int y){

    }
}

public class DrawRectangle implements IDraw{
    @Override
    public void drawShape(int x,int y ){

    }
}

public abstract class Shape(){
    protected IDraw draw;
    public DrawShape(IDraw draw){
        this.draw=draw;
    }
    public abstract void draw();
}

public class Bridge extends Shape(){
    @Override
    public void Bridge(IDraw draw){
        super(draw);
    }
    public void draw(){
        draw.drawShape();
    }
}

public class Test{
    public void test(){
        Bridge bridge=new Bride(new DrawSqure());
        bridge.draw();
    }
}

装饰模式 Decorator

抽象组件（Component）：需要装饰的抽象对象。 
具体组件（ConcreteComponent）：是我们需要装饰的对象。
抽象装饰类（Decorator）：内含指向抽象组件的引用及装饰者共有的方法。 
具体装饰类（ConcreteDecorator）：被装饰的对象。

interface IDrink{
    void drink();
}

public class Coffee implements IDrink{
    private IDrink drink;
    public Coffee(IDrink drink){

    }
    @Override
    public void drink(){
        method1();
        dink.drink();
    }
    public void method1(){

    }
}

行为型

迭代

责任链

命令

访问者

中介者

解释器

状态

备忘录

观察者

策略

模板