Java设计模式-常用类型汇总

1、工厂方法

/**

 * @Theme 工厂方法

 * @author j.LONG

 * 概述: 定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

 */

public class FactoryMethod {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.当一个类不知道它所必须创建的对象的类的时候。

           2.当一个类希望由它的子类来指定它所创建的对象的时候。

           3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

        *

        * 参与者:

           1.[产品] --> 定义工厂方法所创建的对象的接口。

           2.[具体的产品] --> 实现Product接口。

           3.[创造者] --> 声明工厂方法，该方法返回一个Product类型的对象。

           4.[具体的创造者] --> 重定义工厂方法以返回一个ConcreteProduct实例。

        */

        IWorkFactory studentWorkFactory = new StudentWorkFactory();

        studentWorkFactory.getWork().doWork();

       

        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();

        teacherWorkFactory.getWork().doWork();

    }

}

/* ---------------产品----------------------- */

interface Work {

    void doWork();

}

/* ----------------具体的产品---------------------- */

class StudentWork implements Work {

    public void doWork() {

        System.out.println("学生做作业!");

    }

}

class TeacherWork implements Work {

    public void doWork() {

        System.out.println("老师审批作业!");

    }

}

/* ----------------创造者---------------------- */

interface IWorkFactory {

    Work getWork();

}

/* ----------------具体的创造者---------------------- */

class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {

        return new StudentWork();

    }

}

class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {

        return new TeacherWork();

    }

}

2、代理模式

/**

 * @Theme 代理模式

 * @author j.LONG

 * 概述: 为其他对象提供一种代理以控制对这个对象的访问。

 */

public class Proxy {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.远程代理（RemoteProxy）为一个对象在不同的地址空间提供局部代表。

           2.虚代理（VirtualProxy）根据需要创建开销很大的对象。

           3.保护代理（ProtectionProxy）控制对原始对象的访问。

        *

        * 参与者:

           1.[代理] --> 保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。

           2.[主题] -->  定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。

           3.[真正的主题] --> 定义Proxy所代表的实体。

        */

       Object obj = new ProxyObject();

       obj.action();

    }

}

/* ---------------代理----------------------- */

class ProxyObject implements Object {

    Object obj;

    public ProxyObject() {

       System.out.println("------这是代理类------");

       obj = new ObjectImpl();

    }

    public void action() {

       System.out.println("**代理开始**");

       obj.action();

       System.out.println("**代理结束**");

    }

}

/* ---------------主题---------------------- */

interface Object {

    void action();

}

/* ---------------真正的主题----------------------- */

class ObjectImpl implements Object {

    public void action() {

       System.out.println("========");

       System.out.println("这是被代理的类...");

       System.out.println("========");

    }

}

3、单例模式

/**

 * @Theme 单例模式

 * @author j.LONG

 * 概述: 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

 */

public class Singleton {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

           2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

        *

        * 参与者:

             [单例] --> 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。

        */

       SingletonPattern sing = SingletonPattern.getInstance();

       SingletonPattern sing2 = SingletonPattern.getInstance();

       System.out.println(sing);

       System.out.println(sing2);

    }

}

/* ---------------单例----------------------- */

class SingletonPattern {

    private static SingletonPattern sing;

    private SingletonPattern() {}

    public static SingletonPattern getInstance() {

       if (sing == null) {

           sing = new SingletonPattern();

       }

       return sing;

    }

}

4、策略模式

/**

 * @Theme 策略模式

 * @author j.LONG

 * 概述: 定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。

 */

public class Strategy {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

           2.算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

           3.一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现。

        *

        * 参与者:

           1.[策略] --> 定义所有支持的算法的公共接口。

           2.[具体的战略] --> 以Strategy接口实现某具体算法。

           3.[上下文] --> 可定义一个接口来让Stategy访问它的数据。

        */

       Context ctx = new Context(new StrategyImplA());

       ctx.doMethod();

       ctx = new Context(new StrategyImplB());

       ctx.doMethod();

       ctx = new Context(new StrategyImplC());

       ctx.doMethod();

    }

}

/* ----------------策略---------------------- */

abstract class StrategyPattern {

    public abstract void method();

}

/* -----------------具体的战略--------------------- */

class StrategyImplA extends StrategyPattern {

    public void method() {

       System.out.println("这是第一个实现");

    }

}

class StrategyImplB extends StrategyPattern {

    public void method() {

       System.out.println("这是第二个实现");

    }

}

class StrategyImplC extends StrategyPattern {

    public void method() {

       System.out.println("这是第三个实现");

    }

}

/* -----------------上下文--------------------- */

class Context {

    StrategyPattern stra;

    public Context(StrategyPattern stra) {

       this.stra = stra;

    }

    public void doMethod() {

       stra.method();

    }

}

5、模板方法

/**

 * @Theme 模板方法

 * @author j.LONG

 * 概述: 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

 */

public class TemplateMethod {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

           2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。

           3.控制子类扩展。

        *

        * 参与者:

           1.[抽象类] --> 定义抽象的原语操作（primitiveoperation），具体的子类将重定义它们以实现一个算法的各步骤。

           2.[具体类] --> 实现原语操作以完成算法中与特定子类相关的步骤。

        */

       Template temp = new TemplateConcrete();

       temp.update();

    }

}

/* -------------------------------------- */

abstract class Template {

    public abstract void print();

    public void update() {

       System.out.println("开始打印");

       for (int i = 0; i < 3; i++) {

           print();

       }

    }

}

/* -------------------------------------- */

class TemplateConcrete extends Template {

    @Override

    public void print() {

       System.out.println("这是子类的实现");

    }

}

6、责任链模式

/**

 * @Theme 责任链模式

 * @author j.LONG

 * 概述: 这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者.

         将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

 */

public class Cor {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

           2.你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

           3.可处理一个请求的对象集合应被动态指定。

        *

        * 参与者:

           1.[处理程序] --> 定义一个处理请求的接口。

           2.[具体的处理者] --> 处理它所负责的请求。 可访问它的后继者。

        */

       Player jiaMu = new JiaMu(new JiaBa(new JiaBaoYu(null)));

       jiaMu.handle();

    }

}

/* ----------------处理程序---------------------- */

abstract class Player {

    /** 下一位处理者  */

    protected Player successor;

    /** 每个处理者的处理方法 */

    abstract public void handle();

    /** 设置下一个处理者 */

    protected void setSuccessor(Player aSuccessor) {

       successor = aSuccessor;

    }

    /** 传给下一个处理者，这个方法本不应该出现在这，因为每个处理者中都有这个方法，所以就放到父类中来了 */

    public void next() {

       if (successor != null) {

           successor.handle();

       } else {

           System.out.println("Program terminated.");

       }

    }

}

/* ----------------具体的处理者---------------------- */

class JiaMu extends Player {

    public JiaMu(Player aSuccessor) {

       this.setSuccessor(aSuccessor);

    }

    public void handle() {

       System.out.println("Jia Mu passed!");

       next();//传给下一个处理者

    }

}

class JiaBa extends Player {

    public JiaBa(Player aSuccessor) {

       this.setSuccessor(aSuccessor);

    }

    public void handle() {

       System.out.println("Jia Ba passed!");

       next();//传给下一个处理者

    }

}

class JiaBaoYu extends Player {

    public JiaBaoYu(Player aSuccessor) {

       this.setSuccessor(aSuccessor);

    }

    public void handle() {

       System.out.println("Jia BaoYu passed!");

       next();//传给下一个处理者

    }

}

7、适配器模式

/**

 * @Theme 适配器模式

 * @author j.LONG

 * 概述: 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

 */

public class Adapter {

      public static void main(String[] args) {

           /*

            * 适用性:

               1.你想使用一个已经存在的类，而它的接口不符合你的需求。

               2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

               3.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。

            *

            * 参与者:

               1.[目标] --> 定义Client使用的与特定领域相关的接口。

               2.[客户] --> 与符合Target接口的对象协同。

               3.[适配者] --> 定义一个已经存在的接口，这个接口需要适配。

               4.[适配器] --> 对Adaptee的接口与Target接口进行适配

            */

            Target target = new AdapterPattern(new Adaptee());

            target.adapteeMethod();

           

            target.adapterMethod();

        }

}

/* ----------------目标---------------------- */

interface Target {

    void adapteeMethod();

    void adapterMethod();

}

/* -----------------适配者--------------------- */

class Adaptee {

    public void adapteeMethod() {

        System.out.println("Adaptee method!");

    }

}

/* -----------------适配器--------------------- */

class AdapterPattern implements Target {

    private Adaptee adaptee;

    public AdapterPattern(Adaptee adaptee) {

        this.adaptee = adaptee;

    }

    public void adapteeMethod() {

       adaptee.adapteeMethod();

    }

    public void adapterMethod() {

       System.out.println("Adapter method!");

    }

}

8、抽象工厂

/**

 * @Theme 抽象工厂

 * @author j.LONG

 * 概述: 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

 */

public class AbstractFactory {

    public static void main(String[] args) {

       /*

        * 适用性:

           1.一个系统要独立于它的产品的创建、组合和表示时。

           2.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

           3.当你提供一个产品类库，而只想显示它们的接口而不是实现时。

        *

        * 参与者:

           1.[抽象的工厂] --> 声明一个创建抽象产品对象的操作接口。

           2.[具体的工厂] --> 实现创建具体产品对象的操作。

           3.[抽象的产品] --> 为一类产品对象声明一个接口。

           4.[具体的产品] --> 定义一个将被相应的具体工厂创建的产品对象。

           5.Client

        */

       IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();

       ICat blackCat = blackAnimalFactory.createCat();

       blackCat.eat();

       IDog blackDog = blackAnimalFactory.createDog();

       blackDog.eat();

       IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();

       ICat whiteCat = whiteAnimalFactory.createCat();

       whiteCat.eat();

       IDog whiteDog = whiteAnimalFactory.createDog();

       whiteDog.eat();

    }

}

/* ------------------抽象的工厂-------------------- */

interface IAnimalFactory {

    ICat createCat();

    IDog createDog();

}

/* -----------------具体的工厂--------------------- */

class BlackAnimalFactory implements IAnimalFactory {

    public ICat createCat() {

       return new BlackCat();

    }

    public IDog createDog() {

       return new BlackDog();

    }

}

class WhiteAnimalFactory implements IAnimalFactory {

    public ICat createCat() {

       return new WhiteCat();

    }

    public IDog createDog() {

       return new WhiteDog();

    }

}

/* -----------------抽象的产品--------------------- */

interface ICat {

    void eat();

}

interface IDog {

    void eat();

}

/* ------------------具体的产品-------------------- */

class BlackCat implements ICat {

    public void eat() {

       System.out.println("The black cat is eating!");

    }

}

class WhiteCat implements ICat {

    public void eat() {

       System.out.println("The white cat is eating!");

    }

}

class BlackDog implements IDog {

    public void eat() {

       System.out.println("The black dog is eating");

    }

}

class WhiteDog implements IDog {

    public void eat() {

       System.out.println("The white dog is eating!");

    }

}