# 23种设计模式 Uncompleted

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {
        return instance;
    }
}
 
        Copied!
    

public class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
 
        Copied!
    

public class Singleton {
    private static Singleton instance;
    private Singleton() {

    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
 
        Copied!
    

public class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
 
        Copied!
    

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
 
        Copied!
    

public class Singleton() {
    private Singleton() {

    }

    public static Singleton getInstance() {
        return SingletonHolder.sInstance;
    }

    private static class SingletonHolder {
        private static final Singleton sInstance = new Singleton();
    }
}
 
        Copied!
    

public enum Singleton {
    INSTANCE;
}
 
        Copied!
    

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<String, Object>();

    private Singleton() {

    }

    public static void registerService(String key, Objectinstance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static ObjectgetService(String key) {
        return objMap.get(key);
    }
}
 
        Copied!
    

// 创建抽象产品族类，定义抽象产品的公共接口
abstract class AbstractProduct {
    public abstract void show();
}

// 创建抽象产品类，定义具体产品的公共接口
abstract class ContainerProduct extends AbstractProduct {
    @Override
    public abstract void show();
}

// 创建抽象产品类，定义具体产品的公共接口
abstract class MouldProduct extends AbstractProduct {
    @Override
    public abstract void show();
}

// 创建具体产品类，定义生产的具体产品
// 容器A类
class ContainerProduct A extends ContainerProduct {
    @Override
    public void show() {
        System.out.println("生产出了容器产品A");
    }
}

// 容器B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

// 模具A类
class MouldProductA extends MouldProduct{
    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

// 模具B类
class MouldProductB extends MouldProduct{
    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

// 创建抽象工厂类，定义具体工厂的公共接口
abstract class Factory {
    public abstract Product ManufactureContainer();
    public abstract Product ManufactureMould();
}

// 创建具体工厂类，定义工厂创建具体产品实例的方法
// 生产A产品的工厂
class FactoryA extends Factory {
    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

// 生产B产品的工厂
class FactoryB extends Factory {
    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

// 具体实现类（调用类）
public class AbstractFactoryPattern {
    public static void main(String[] args) {
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();
    }
}
 
        Copied!
    

class Prototype implements Cloneable {
    public Prototype clone() {
        Prototype prototype = null;
        try {
            prototype = (Prototype) super.clone();
        } catch (CloneNotSupportException e) {
            e.printStackTrace();
        }
        return prototype;
    }
}

class ConcretePrototype extends Prototype {
    public void show() {
        System.out.println("原型模式实现类");
    }
}

public class Client {
    public static void main(String[] args) {
        ConcretePrototype cp = new ConcretePrototype();
        for (int i = 0; i < 5; i++) {
            ConcretePrototype clonecp = (ConcretePrototype) cp.clone();
            clonecp.show();
        }
    }
}
 
        Copied!
    

// 子系统角色，由若干个类组成
public class SubClass1 {
    public void method1() {
        System.out.println("这是子系统1中的方法1");
    }
    public void method2() {
        System.out.println("这是子系统1中的方法2");
    }
}

public class SubClass2 {
    public void method1() {
        System.out.println("这是子系统2中的方法1");
    }
    public void method2() {
        System.out.println("这是子系统2中的方法2");
    }
}

// 外观角色类
public class FacadeClass {
    // 把子系统中的几个方法汇总到了一起
    public void FacadeMethod() {
        SubClass1 s1 = new SubClass1();
        s1.method1();
        SubClass2 s2 = new SubClass2();
        s2.method2();
    }
}

// 客户端主类
public class ClientClass {
    public static void main(String[] args) {
        FacadeClass fc = new FacadeClass();
        fc.FacadeMethod();
    }
}
 
        Copied!
    

public interface Target {
    public void Request();
}

public class Adaptee {
    public void SpecificRequest() {

    }
}

public class Adapter extends Adaptee implements Target {
    @Override
    public void Request() {
        this.SpecificRequest();
    }
}

public class AdapterPattern {
    public static void main(String[] args) {
        Target mAdapter = new Adapter();
        mAdapter.Request();
    }
}
 
        Copied!
    

public interface Target {
    public void Request();
}

public class Adaptee {
    public void SpecificRequest() {

    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void Request() {
        this.adaptee.SepcificRequest();
    }
}

public class AdapterPattern {
    public static void main(String[] args) {
        Target mAdapter = new Adapter(new Adaptee());
        mAdapter.Request();
    }
}
 
        Copied!
    

// 首先定义Implementer接口，定义了一个operation()方法
public interface Implementer {
    public void operation();
}

// 定义了Implementator接口的两个实现类
public class ConcreteImplementerA implements Implementer {
    @Override
    public void operation() {
        System.out.println("OperationA");
    }
}

public class ConcreteImplementerB implements Implementer {
    @Override
    public void operation() {
        System.out.println("OperationB");
    }
}

// 定义了桥接类Abstraction，这是一个抽象类，有对Implementer接口的引用
public abstract class Abstraction {
    private Implementer implementer;

    public Implementer getImplementer() {
        return implementer;
    }

    public void setImplementer(Implementer implementer) {
        this.implementer = implementer;
    }

    // 通过引用Implementer，调用其operation()方法
    public void operation() {
        implementer.operation();
    }
}

public class RefinedAbstraction extends Abstraction {
    @Override
    protected void operation() {
        super.getImplementer().operation();
    }
}

// 测试类
public class BridgeTest {
    public static void main(String[] args) {
        Abstraction abstraction = new RefinedAbstraction();

        abstraction.setImplementer(new ConcreteImplementerA());
        abstraction.operation();

        abstraction.setImplementer(new ConcreteImplementerB());
        abstraction.operation();
    }
}
 
        Copied!
    

// 创建图片接口
public interface Image {
    void display();
}

// 创建实现图片接口的类
public class RealImage implements Image {
    private Image fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }

    private void loadFromDisk(String fileName) {
        System.out.println("Loading " + fileName + " from disk");
    }
}

// 创建代理图片类
public class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        readImage.display();
    }
}

// 主测试类
public class ProxyTest {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        image.display();

    }
}
 
        Copied!
    

public interface Component {
    void operation();
}

public class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        super();
        this.component = component;
    }

    public Decorator() {
        super();
    }

    public void operation() {
        component.operation();
    }
}

public class ConcreteComponent implements Component {
    public ConcreteComponent() {
        super();
    }

    public void operation();
}

public class ConcreteDecorator extends Decorator {
    public void operation() {
        super.operation();
    }
}
 
        Copied!
    

// 齐天大圣接口
public interface MonkeyKing {
    public void move();
}

// 猴子类，是齐天大圣的本尊（具体实现）
public class Monkey implements MonkeyKing {
    @Override
    public void move() {
        System.out.println("Monkey move");
    }
}

// 72变类
public class Change implements MonkeyKing {
    private MonkeyKing king;

    public Change(MonkeyKing king) {
        this.king = king;
    }

    @Override
    public void move() {
        this.king.move();
    }
}

// 具体的变化类，变成鱼
public class Fish extends Change {
    public Fish(MonkeyKing king) {
        super(king);
    }

    @Override
    public void move() {
        super.move();
        System.out.println("Change fish");
    }
}

// 具体的变化类，变成鸟
public class Bird extends Change {
    public Bird(MonkeyKing king) {
        super(king);
    }

    @Override
    public void move() {
        super.move();
        System.out.println("Change bird");
    }
}

public class Client {
    public static void main(String[] args) {
        MonkeyKing king = new Monkey();
        MonkeyKing bird = new Bird(king);
        bird.move();
    }
}
 
        Copied!
    

// 享元工厂类（含有一个享元池）
public class FlyweightFactory {
    // 定义一个HashMap用于存储享元对象，实现享元池
    private HashMap flyweights = new HashMap();
    public Flyweight getFlyweight(String key) {
        // 如果对象存在，则直接从享元池中获取
        if (flyweights.containsKey(key)) {
            return (Flyweight)flyweights.get(key);
        }
        // 如果对象不存在，先创建一个新的对象添加到享元池中，然后返回它
        else {
            Flyweight fw = new ConcreteFlyweight();
            flyweights.put(key, fw);
            return fw;
        }
    }
}

// 享元类
public class Flyweight {
    // 内部状态intrinsicState作为成员变量，同一个享元对象其内部状态是一致的
    private String intrinsicState;
    public Flyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    // 如果是外部状态，则使用时由外部设置，不保存在享元对象中，即使是同一个对象
    public void operation(String extrinsicState) {

    }
}
 
        Copied!