《大话设计模式》简读

最新推荐文章于 2024-08-08 16:26:50 发布

_NiCat

最新推荐文章于 2024-08-08 16:26:50 发布

阅读量286

点赞数

分类专栏： java 随笔20170904 文章标签：设计模式

本文链接：https://blog.csdn.net/ten_color/article/details/77833102

版权

java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

随笔20170904

1 篇文章 0 订阅

订阅专栏

感谢《大话设计模式》作者程杰

简单工厂模式

客户端不关心对象如何创建, 只需知道传入工厂类的参数

计算器–面向对象–可维护、可复用、可扩展–业务与界面分离–业务分离（继承）

/**
 * Operation 父类
 * 抽象类  用于代表实现类
 * @author xmd
 *
 */
abstract class Operation{
    public double NumberA;
    public double NumberB;
    public abstract double GetResult();
}
class OperationAdd extends Operation{
    @Override
    public double GetResult() {
        return NumberA + NumberB;
    }   
}
class OperationSub extends Operation{
    @Override
    public double GetResult() {
        return NumberA - NumberB;
    }   
}
class OperationMul extends Operation{
    @Override
    public double GetResult() {
        return NumberA * NumberB;
    }   
}
class OperationDiv extends Operation{
    @Override
    public double GetResult() {
        if(NumberB == 0){
            throw new RuntimeException("除数为0");
        }
        return NumberA / NumberB;
    }   
}

/**
 * 简单工厂 
 * 根据运算符号生成相应的实现类
 * @author xmd
 *
 */
class OperationFactory {
    public static Operation createOperation(String operate){
        Operation opre = null;
        switch (operate) {
        case "+":
            opre = new OperationAdd();
            break;
        case "-":
            opre = new OperationSub();
            break;
        case "*":
            opre = new OperationMul();
            break;
        case "/":
            opre = new OperationDiv();
            break;
        }
        return opre;
    }
}
/**
 * 计算界面
 * @author xmd
 *
 */
public class Jiandangongchang {
    public static void main(String[] args) {
        Operation oper;
        oper = OperationFactory.createOperation("+");
        oper.NumberA=15;
        oper.NumberB=2;
        System.out.println(oper.GetResult());
    }
}

策略模式

封装算法，封装规则，应用于不同时间不同业务规则

让算法的变化,不会影响到使用算法的客户

商场收银

/**
 * 抽象算法类
 * @author xmd
 *
 */
abstract class Strategy{
    //算法方法
    public abstract void AlgorithmInterface();
}

class ConcreteStrategyA extends Strategy{
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法A实现");
    }
}
class ConcreteStrategyB extends Strategy{
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法B实现");
    }
}
class ConcreteStrategyC extends Strategy{
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法C实现");
    }
}
/**
 * 上下文  维护对Strategy对象的引用  配置ConcreteStrategy
 * @author xmd
 *
 */
class Context{
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void ContextInterface(){
        strategy.AlgorithmInterface();
    }
}
/**
 * 策略模式:
 * 通过Context组合Strategy成员对象，
 * 传入Context适当的Strategy成员对象，
 * 调用对应Strategy对象的algorithmInterface()。
 * @author xmd
 *
 */
public class celue {
    public static void main(String[] args) {
        Context context;
        //根据要求选择策略  可用简单工厂模式 实现选择方案
        context = new Context(new ConcreteStrategyA());
        context.ContextInterface();

        context = new Context(new ConcreteStrategyB());
        context.ContextInterface();

        context = new Context(new ConcreteStrategyC());
        context.ContextInterface();
    }
}

装饰模式

当某个对象的职责经常发生变化或者需要动态的增加职责

穿着

/**
 * 定义一个对象接口,可以给这些对象动态的添加职责
 * @author xmd
 *
 */
abstract class Component{
    public abstract void Opration();
}
/**
 * 定义一个具体的对象,也可以给这个对象添加职责
 * @author xmd
 *
 */
class ConcreteComponent extends Component{
    @Override
    public void Opration() {
        System.out.println("被装饰的具体对象");
    }
}
/**
 * 装饰抽象类, 从外类扩展Component的功能,但对于Component来说,是无需知道Decorate的存在
 * @author xmd
 *
 */
class Decorator extends Component{
    protected Component component;

    /**
     *实际执行Component的Opration()
     */
    @Override
    public void Opration() {
        if(component != null){
            component.Opration();
        }
    }

    public void setComponent(Component component) {
        this.component = component;
    }
}
/**
 * 具体的装饰对象,起到给Component添加职责
 * @author xmd
 *
 */
class ConcreteDecoratorA extends Decorator{
    private String addedState;

    @Override
    public void Opration() {
        super.Opration();
        addedState = "new State";
        System.out.println("具体装饰对象A的操作");
    }
}
/**
 * 具体的装饰对象,起到给Component添加职责
 * @author xmd
 *
 */
class ConcreteDecoratorB extends Decorator{

    @Override
    public void Opration() {
        super.Opration();
        AddedBehacior();
        System.out.println("具体装饰对象A的操作");
    }

    private void AddedBehacior() {
        System.out.println("具体装饰对象B独有方法");
    }
}

public class zhuangshi {
    public static void main(String[] args) {
        ConcreteComponent component = new ConcreteComponent();
        ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA();
        ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB();

        concreteDecoratorA.setComponent(component);//为component装饰A
        concreteDecoratorB.setComponent(concreteDecoratorA);//为component装饰A后再装饰B
        concreteDecoratorB.Opration();
    }
}

代理模式

为其他对象提供一种代理以控制对这个对象的访问。隐藏真实访问对象,同时可以处理别的事情

/**
 * 定义了RealSubject和Proxy共用的接口
 * @author xmd
 *
 */
abstract class Subject{
    public abstract void Request();
}
/**
 * 真实类
 * @author xmd
 *
 */
class RealSubject extends Subject{

    @Override
    public void Request() {
        System.out.println("真实的请求");
    }
}
class Proxy extends Subject{
    private RealSubject realSubject;
    @Override
    public void Request() {
        if(realSubject == null)
            realSubject = new RealSubject();
        realSubject.Request();
    }
}
public class daili {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.Request();
    }
}

工厂方法

克服了简单工厂模式违背开闭原则,又保持了封装对象创建过程的优点。一个类想要由自己的子类来定义某对象的创建过程。

雷锋

/**
 * 雷锋
 * @author xmd
 *
 */
class LeiFeng{
    public void Sweep(){
        System.out.println("扫地");
    }

    public void Wash(){
        System.out.println("洗衣");
    }
}
/**
 * 学习雷锋学生
 * @author xmd
 *
 */
class Undergraduate extends LeiFeng{}
/**
 * 学习雷锋志愿者
 * @author xmd
 *
 */
class Volunteer extends LeiFeng{}

/**
 * 工厂接口 
 * @author xmd
 *
 */
interface Factory {
      public LeiFeng createLeiFeng();
}
/**
 * 工厂实现类 具体实现学生
 * @author xmd
 *
 */
class GraduateFactory  implements Factory{

    @Override
    public LeiFeng createLeiFeng() {
        return new Undergraduate();
    }
}
/**
 * 工厂实现类 具体实现学生
 * @author xmd
 *
 */
class VolunteerFactory  implements Factory{

    @Override
    public LeiFeng createLeiFeng() {
        return new Volunteer();
    }
}
public class gongchangfangfa {
    public static void main(String[] args) {
        Factory factory = new GraduateFactory();
        Undergraduate student = (Undergraduate) factory.createLeiFeng();
        student.Sweep();

        Factory VFactory = new VolunteerFactory();
        Volunteer volunteer = (Volunteer) VFactory.createLeiFeng();
        volunteer.Sweep();
    }
}

原型模式

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。简化对象的创建过程,隐藏了对象创建的细节,又对性能大大的提高。频繁使用一个对象,比如在循环体中

/**
 * 原型类 
 * 一个类重写了 Object 内定义的 clone() ，需要同时实现 Cloneable 接口
 * 如果没有implements Cloneable的类调用Object.clone()方法就会抛出CloneNotSupportedException。 
 * (1)浅克隆（shallow clone），浅拷贝是指拷贝对象时仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。 
 *(2)深克隆（deep clone），深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。 
 * @author xmd
 *
 */
abstract class Prototype implements Cloneable{
    private String id;

    public Prototype(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
    public abstract Prototype Clone() throws CloneNotSupportedException;
}
/**
 * 具体原型类
 * @author xmd
 *
 */
class ConcretePrototype extends Prototype{

    public ConcretePrototype(String id) {
        super(id);
    }

    @Override
    public Prototype Clone() throws CloneNotSupportedException {
            return (Prototype) this.clone();
    }
}
public class yuanxing {

    public static void main(String[] args) throws CloneNotSupportedException {
        ConcretePrototype cPrototype1 = new ConcretePrototype("1");
        ConcretePrototype cPrototype2 = (ConcretePrototype) cPrototype1.Clone();
        System.out.println(cPrototype1.getId());
        System.out.println(cPrototype2.getId());
    }
}

模板方法

定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,模板方法使得子类不改变算法的结构,即可重定义该算法的某些特定步骤。把不变行为搬移到超类,去除子类中的重复代码,体现它的优势。通过父类调用子类,这是一种反向的控制

学生抄写考试题

/**
 * 父类  包含了公共方法
 * @author xmd
 *
 */
abstract class AbstractClass{
    public abstract void PrimitveOperation1();
    public abstract void PrimitveOperation2();

    public void TemplateMethod(){
        PrimitveOperation1();
        PrimitveOperation2();
    }
}
class ConcreteClassA extends AbstractClass{

    @Override
    public void PrimitveOperation1() {
        System.out.println("A类方法1实现");
    }

    @Override
    public void PrimitveOperation2() {
        System.out.println("A类方法2实现");

    }
}
class ConcreteClassB extends AbstractClass{

    @Override
    public void PrimitveOperation1() {
        System.out.println("B类方法1实现");
    }

    @Override
    public void PrimitveOperation2() {
        System.out.println("B类方法2实现");

    }
}
public class mubanfangfa {
    public static void main(String[] args) {
        AbstractClass abstractClass;

        abstractClass = new ConcreteClassA();
        abstractClass.TemplateMethod();

        abstractClass = new ConcreteClassB();
        abstractClass.TemplateMethod();
    }
}

外观模式

为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这一接口使得这一子系统更加容易使用。1.减少客户端处理的对象数目2.对客户端屏蔽了子系统, 实现了解耦合

package dhsjms;

class SubSystemOne{
    public void MethodOne(){
        System.out.println("子系统方法一");
    }
}
class SubSystemTwo{
    public void MethodTwo(){
        System.out.println("子系统方法二");
    }
}
class SubSystemThree{
    public void MethodThree(){
        System.out.println("子系统方法三");
    }
}
class Facade{
    SubSystemOne subSystemOne;
    SubSystemTwo subSystemTwo;
    SubSystemThree subSystemThree;
    public Facade() {
        subSystemOne = new SubSystemOne();
        subSystemTwo = new SubSystemTwo();
        subSystemThree = new SubSystemThree();
    }

    public void MethodA(){
        System.out.println("方法组A---");
        subSystemOne.MethodOne();
        subSystemTwo.MethodTwo();
        subSystemThree.MethodThree();
    }
    public void MethodB(){
        System.out.println("方法组B---");
        subSystemOne.MethodOne();
        subSystemThree.MethodThree();
    }

}
public class waiguan {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.MethodA();
        facade.MethodB();
    }

}

建造者模式

将一个复杂对象的构建和它的表示分离,使得同样的构建过程可以创建不同的表示。建造者隐藏了该对象是如何组装的,所以需要改变一个产品的的内部表示,只需要在定义一个新的具体的建造者就可以了

/**
 * 产品类，由多个部件组成
 */
class Product{
    List<String> parts = new ArrayList<String>();

    public void Add(String part){
        parts.add(part);
    }
    public void Show(){
        System.out.println("产品 创建 ----");
        for (String psrt:parts) {
            System.out.println(psrt);

        }
    }
}

/**
 * 抽象建造这类，确定产品俩个部件A,B组成，并声明一个得到产品
 * 建造后结果的方法GetResult()
 */
abstract class Builder{
    public abstract void BuidPartA();
    public abstract void BuidPartB();
    public abstract Product GetResult();
}
class ConcreteBuilder1 extends Builder{
    private Product product = new Product();
    @Override
    public void BuidPartA() {
        product.Add("部件A");
    }

    @Override
    public void BuidPartB() {
        product.Add("部件B");
    }

    @Override
    public Product GetResult() {
        return product;
    }
}
class ConcreteBuilder2 extends Builder{
    private Product product = new Product();
    @Override
    public void BuidPartA() {
        product.Add("部件X");
    }

    @Override
    public void BuidPartB() {
        product.Add("部件Y");
    }

    @Override
    public Product GetResult() {
        return product;
    }
}
class Director{
    public void Construct(Builder builder){
        builder.BuidPartA();
        builder.BuidPartB();
    }
}
public class jianzaozhe {
    public static void main(String[] args){
        Director director = new Director();
        Builder builder1 = new ConcreteBuilder1();
        Builder builder2 = new ConcreteBuilder2();

        director.Construct(builder1);
        Product product1 = builder1.GetResult();
        product1.Show();

        director.Construct(builder2);
        Product product2 = builder2.GetResult();
        product2.Show();
    }
}

观察者

发布-订阅模式,定义了一种一对多的依赖关系,让多个观察者对象,同时监听一个主题对象,这个主题对象在状态发生变化时,会通知所有的观察者对象,是它们能够自动更新自己。解除了通知者和具体观察者的耦合,让耦合的双方依赖于抽象,使得各自的变换不会影响到另一方。当一个对象的改变，需要同时改变其他对象的时候，而且它不知道具体有多少对象需要改变

/**
 * 抽象通知者，把所有观察者对象的引用保存在一个聚类里，每个主题都可以有任何熟量的观察者。
 */
abstract class Subject{
     private List<Observer> observers = new ArrayList<Observer>();
     //增加观察者
     public void Attach(Observer observer){
         observers.add(observer);
     }

     //移除观察者
     public void Detach(Observer observer){
         observers.remove(observer);
     }
     //通知
    public void Notify(){
        for (Observer o:observers) {
            o.update();
        }
    }
}

/**
 * 抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知是更新自己。
 */
abstract class Observer{
    public abstract void update();
}

/**
 * 具体通知者，将有关状态存入具体观察者对象
 */
class ConcreteSubject extends Subject{
    //具体被观察者的状态
    private String subjectState;

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    public String getSubjectState() {
        return subjectState;
    }
}
class ConcreteObserver extends Observer{
    private String name;
    private String observerState;
    private ConcreteSubject subject;

    public ConcreteObserver(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void update() {
        observerState = subject.getSubjectState();
        System.out.println("观察者的最新状态是："+name+observerState);
    }

    public ConcreteSubject getSubject() {
        return subject;
    }

    public void setSubject(ConcreteSubject subject) {
        this.subject = subject;
    }
}
public class guanchazhe {
    public static void main(String[] args){
        ConcreteSubject s = new ConcreteSubject();
        s.Attach(new ConcreteObserver("X",s));
        s.Attach(new ConcreteObserver("Y",s));
        s.Attach(new ConcreteObserver("Z",s));

        s.setSubjectState("ABC");
        s.Notify();
    }
}

抽象工厂

提供一个创建一系列相关或相关依赖对象的接口,而无需指定他们具体的类。在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理

/***
 * 用于客服端访问，解除与具体数据库访问的耦合
 */
class Department{}
interface IDepartment{
    void Insert(Department department);
    Department getDepartment(int id);
}

class SqlserverDepartment implements IDepartment{
    @Override
    public void Insert(Department department) {
        System.out.println("Sqlserver  insert Department");
    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("Sqlserver  select  Department");
        return null;
    }
}
class AccessDepartment implements  IDepartment{
    @Override
    public void Insert(Department department) {
        System.out.println("Access  insert Department");
    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("Access  select Department");
        return null;
    }
}

/**
 * IFactory接口，定义了一个用来创建Department对象 的 抽象工厂接口
 */
interface IFactory{
    IDepartment CreateDepartment();
}
class SqlserverFactory implements  IFactory{
    @Override
    public IDepartment CreateDepartment() {
        return new SqlserverDepartment();
    }
}
class AccessFactory implements  IFactory{
    @Override
    public IDepartment CreateDepartment() {
        return new AccessDepartment();
    }
}

public class chouxianggongchang {
    public static void main(String[] args){
        Department department = new Department();

        IFactory iFactory = new AccessFactory();//只需更换工厂即可

        IDepartment idepartment = iFactory.CreateDepartment();
        idepartment.Insert(department);
        idepartment.getDepartment(2);

    }
}

状态模式

当一个对象的内在状态改变时,允许改变其行为,这个对象看起来改变了其类。消除庞大的条件分支,将特定状态的行为放入一个对象中。通过把各种状态判断逻辑分布到State的子类中,减少相互之间的依赖

/**
 * 抽象状态
 */
abstract class State{
    public abstract void Hanlde(Context context);
}

/**
 * 具体状态1
 */
class ConcreteStateA extends State{
    @Override
    public void Hanlde(Context context) {
        context.setState(new ConcreteStateB());//转入新的状态
    }
}
class ConcreteStateB extends State{
    @Override
    public void Hanlde(Context context) {
        context.setState(new ConcreteStateA());
    }
}
class Context{
    private State state;

    public Context(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }
    public void Request(){
        state.Hanlde(this);
    }
}
public class zhuangtai {
    public static void main(String[] args){
        Context context = new Context(new ConcreteStateA());
        context.Request();
        context.Request();
        context.Request();
        context.Request();
        context.Request();
    }
}

适配器

将一个类的接口转换成客户希望的另一个接口, 使得原本由于接口不兼容不能再一起工作的类,可以在一起工作。通过引入适配器,可以复用现有的类,而不需要修改源代码,将目标类和适配者解耦合,解决了接口和复用环境不一致的情况。

/**
 * 客户所期待的接口
 */
class Target{
    public void Request(){
        System.out.println("普通接口");
    }
}

/**
 * 需要适配的类
 */
class Adaptee{
   public void SpecificRequest(){
       System.out.println("特殊请求");
   }
}

/**
 * 将源接口转成目标接口
 */
class Adapter extends Target{
    private Adaptee adaptee = new Adaptee();

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

public class shipeiqi {
    public static void main(String[] args){
        Target target = new Adapter();
        target.Request();
    }
}

备忘录

在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后可将对象恢复到保存的状态。把要保存的细节放到备忘录中，当修改保存的信息时，不会影响客户端

/**
 * 发起类
 */
class Originator{
    private String state;
    //创建一个备忘录，将当前需要保存的信息导入并new出一个Memento对象
    public Memento CreateMenento(){
        return new Memento(state);
    }
    //恢复数据
    public void SetMemento(Memento memento){
        state = memento.getState();
    }
    public void Show(){
        System.out.println("state" + state);
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

/**
 * 备忘录
 */
class Memento{
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

/**
 * 管理者
 */
class Caretaker{
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

public class beiwanglu {
    public static void main(String[] args){
        Originator originator = new Originator();
        originator.setState("On");
        originator.Show();

        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.CreateMenento());

        originator.setState("Off");
        originator.Show();

        originator.SetMemento(caretaker.getMemento());//恢复
        originator.Show();
    }
}

组合

将对象组合成树形结构,以表示整体-部分的结构, 使得用户对单个对象和组合对象的使用具有一致性。简化客户端代码，在定义组合的那些类中不需要写一些充斥着选择语句的函数。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断的递归下去

/**
 * 用于访问和管理Component的子部件
 */
abstract class Component{
    protected String name;

    public Component(String name) {
        this.name = name;
    }

    public abstract void Add(Component component);
    public abstract void Remove(Component component);
    public abstract void Display(int depth);
}

/**
 * 叶子节点
 */
class Leaf extends Component{
    public Leaf(String name) {
        super(name);
    }

    @Override
    public void Add(Component component) {
        System.out.println("not leaf add");
    }

    @Override
    public void Remove(Component component) {
        System.out.println("npt leaf Remove");
    }

    @Override
    public void Display(int depth) {
        while(depth>0){
            System.out.print("-");
            depth--;
        }
        System.out.println(name);
    }
}

/**
 * 枝点
 */
class Composite extends Component{
    private List<Component> childrens = new ArrayList<Component>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void Add(Component component) {
        childrens.add(component);
    }

    @Override
    public void Remove(Component component) {
        childrens.remove(component);
    }

    @Override
    public void Display(int depth) {
        int d = depth;
        while(d>0){
            System.out.print("-");
            d--;
        }
        System.out.println(name);

        for (Component component : childrens ) {
            component.Display(depth+2);
        }
    }
}
public class zuhe {
    public static void main(String[] args){
        Composite root = new Composite("root");
        root.Add(new Leaf("Leaf A"));
        root.Add(new Leaf("Leaf B"));

        Composite comp = new Composite("Composite X");
        comp.Add(new Leaf("Leaf Xa"));
        comp.Add(new Leaf("Leaf Xb"));

        root.Add(comp);

        Composite comp2 = new Composite("Composite XY");
        comp2.Add(new Leaf("Leaf XYa"));
        comp2.Add(new Leaf("Leaf XYb"));
        root.Add(comp2);

        Leaf leaf = new Leaf("Leaf D");
        root.Add(leaf);
        root.Remove(leaf);

        root.Display(1);
    }

}

迭代器

提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示.分离了集合对象的遍历行为,不暴露集合的内部结构,又可让外部访问集合内的数据

/**
 * Iterator抽象类
 */
abstract class Iterator{
    public abstract Object First();
    public abstract Object Next();
    public abstract boolean IsDone();
    public abstract Object CurrentItem();
}
abstract class Aggregate{
    public abstract Iterator CreateIterator();//创建迭代器
}
class ConcreteIterator extends Iterator{
    private ConcreteAggregate concreteAggregate;
    private  int current=0;

    public ConcreteIterator(ConcreteAggregate concreteAggregate) {
        this.concreteAggregate = concreteAggregate;
    }

    @Override
    public Object First() {
        return concreteAggregate.getObject(0);
    }

    @Override
    public Object Next() {
        Object ret = null;
        current++;
        if(current < concreteAggregate.getCount()){
            ret = concreteAggregate.getObject(current);
        }
        return ret;
    }

    @Override
    public boolean IsDone() {
        return current >= concreteAggregate.getCount();
    }

    @Override
    public Object CurrentItem() {
        return concreteAggregate.getObject(current);
    }
}
class ConcreteAggregate extends Aggregate{
    private List<Object> items = new ArrayList<Object>();

    @Override
    public Iterator CreateIterator() {
        return new ConcreteIterator(this);
    }
    public int getCount(){
        return items.size();
    }

    public Object getObject(int index){
        return items.get(index);
    }

    public void setObject(Object object){
        items.add(object);
    }
}
public class diedaiqi {
        public static void main(String[] args){
            ConcreteAggregate aggregate = new ConcreteAggregate();
            aggregate.setObject("一");
            aggregate.setObject("二");
            aggregate.setObject("四");
            aggregate.setObject("三");
            aggregate.setObject("七");
            aggregate.setObject("九");
            aggregate.setObject("八");

            Iterator iterator = new ConcreteIterator(aggregate);

            Object object = iterator.First();
            while(!iterator.IsDone()){
                System.out.println(iterator.CurrentItem());
                iterator.Next();
            }
        }
}

单例

保证一个类只有一个实例,并提供一个访问它的全局访问点

class Singleton{
    private static Singleton singleton;
    private Singleton(){}

    public static Singleton getSingleton(){
        if(singleton == null) singleton = new Singleton();
        return singleton;
    }
}
public class danli {
    public static void main(String[] args){
        Singleton s1 = Singleton.getSingleton();
        Singleton s2 = Singleton.getSingleton();
        if(s1 == s2){
            System.out.println("==");
        }
    }
}

桥接模式

将抽象部分与它的实现部分分离,使它们都可以独立的变化。1.类和类继承关系会保持较小的规模,不太可能增长为庞然大物。2.使得抽象之间可以独立的变化,起到了解耦合的作用。使用场景: 一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。

abstract class Implementor{
    public abstract void Operation();
}

class ConcreteImplementorA extends Implementor{
    @Override
    public void Operation() {
        System.out.println("Impl A");
    }
}
class ConcreteImplementorB extends Implementor{
    @Override
    public void Operation() {
        System.out.println("Impl B");
    }
}
class Abstraction{
    protected Implementor implementor;

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }
    public void Operation(){
        implementor.Operation();
    }
}
class RefinedAbstraction extends Abstraction{
    @Override
    public void Operation() {
        implementor.Operation();
    }
}
public class qiaojie {
    public static void main(String[] args){
        Abstraction abstraction = new RefinedAbstraction();

        abstraction.setImplementor(new ConcreteImplementorA());
        abstraction.Operation();

        abstraction.setImplementor(new ConcreteImplementorB());
        abstraction.Operation();
    }
}