23种常用设计模式的UML类图

策略模式 --行为型

UML

基本代码

package code.chapter2.strategy0;

import java.util.Scanner;

public class Test {

   public static void main(String[] args){

      System.out.println("**********************************************");     
      System.out.println("《大话设计模式》代码样例");
      System.out.println();     

      Context context;

      //由于实例化不同的策略，所以最终在调用
      //context.contextInterface()时,所
      //获得的结果就不尽相同
       context = new Context(new ConcreteStrategyA());
       context.contextInterface();

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

       context = new Context(new ConcreteStrategyC());
       context.contextInterface();       

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

   }
}

//抽象算法类
abstract class Strategy{
   //算法方法
   public abstract void algorithmInterface();

}

//具体算法A
class ConcreteStrategyA extends Strategy {
    //算法A实现方法
    public void algorithmInterface() {
        System.out.println("算法A实现");
    }
}

//具体算法B
class ConcreteStrategyB extends Strategy {
    //算法B实现方法
    public void algorithmInterface() {
        System.out.println("算法B实现");
    }
}

//具体算法C
class ConcreteStrategyC extends Strategy {
    //算法C实现方法
    public void algorithmInterface() {
        System.out.println("算法C实现");
    }
}

//上下文
class Context {
    Strategy strategy;
    //初始化时，传入具体的策略对象
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    //上下文接口
    public void contextInterface() {
       //根据具体的策略对象，调用其算法的方法
        strategy.algorithmInterface();
    }
}

模板模式--行为型

基本代码

package code.chapter10.templatemethod0;

public class Test {

   public static void main(String[] args){

      System.out.println("**********************************************");     
      System.out.println("《大话设计模式》代码样例");
      System.out.println();     

      AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();
        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();


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

   }
}

//模板方法抽象类
abstract class AbstractClass {
    //模板方法
    public void templateMethod() {
        
        //写一些可以被子类共享的代码

        this.primitiveOperation1();
        this.primitiveOperation2();
    }
    
    public abstract void primitiveOperation1(); //子类个性的行为，放到子类去实现
    public abstract void primitiveOperation2(); //子类个性的行为，放到子类去实现

}

//模板方法具体类A
class ConcreteClassA extends AbstractClass {
    public void primitiveOperation1(){
        System.out.println("具体类A方法1实现");
    }
    public void primitiveOperation2(){
        System.out.println("具体类A方法2实现");
    }
}

//模板方法具体类B
class ConcreteClassB extends AbstractClass {
    public void primitiveOperation1(){
        System.out.println("具体类B方法1实现");
    }
    public void primitiveOperation2(){
        System.out.println("具体类B方法2实现");
    }
}

观察者模式--行为型

基本代码

package code.chapter14.observer0;

import java.util.ArrayList;

public class Test {

   public static void main(String[] args){

      System.out.println("**********************************************");     
      System.out.println("《大话设计模式》代码样例");
      System.out.println();     

        Subject subject = new ConcreteSubject();
        subject.attach(new ConcreteObserver("NameX",subject));
        subject.attach(new ConcreteObserver("NameY",subject));
        subject.attach(new ConcreteObserver("NameZ",subject));
        subject.setSubjectState("ABC");

        subject.notifyObserver();

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

   }
}

//通知者抽象类
abstract class Subject{
    private ArrayList<Observer> list = new ArrayList<Observer>();//针对抽象的Observer编程
    
    //增加观察者
    public void attach(Observer observer){
        list.add(observer);
    }
    //减少观察者
    public void detach(Observer observer){
        list.remove(observer);
    }
    //通知观察者
    public void notifyObserver(){
        for(Observer item : list){
            item.update();
        }
    }
    protected String subjectState;
    public String getSubjectState(){
        return this.subjectState;
    }
    public void setSubjectState(String value){
        this.subjectState = value;
    }
}

//具体通知者
class ConcreteSubject extends Subject{
    //具体通知者的方法
}

//抽象观察者
abstract class Observer{
    public abstract void update();
}

//具体观察者类
class ConcreteObserver extends Observer{
    private String name;
    private Subject sub;
    public ConcreteObserver(String name,Subject sub){
        this.name = name;
        this.sub = sub;
    }
    public void update(){
        System.out.println("观察者"+this.name+"的新状态是"+this.sub.getSubjectState());
    }
}

//interface Observer{
//    public void update();
//}

访问者模式--行为型

基本代码

package code.chapter28.visitor0;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 

        ObjectStructure o = new ObjectStructure();
        o.attach(new ConcreteElementA());
        o.attach(new ConcreteElementB());

        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();

        o.accept(v1);
        o.accept(v2);


        System.out.println();
        System.out.println("**********************************************");
    }
}

abstract class Visitor {
    public abstract void visitConcreteElementA(ConcreteElementA concreteElementA);

    public abstract void visitConcreteElementB(ConcreteElementB concreteElementB);
}

class ConcreteVisitor1 extends Visitor {
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName()+"被"+this.getClass().getSimpleName()+"访问");
    }

    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
        System.out.println(concreteElementB.getClass().getSimpleName()+"被"+this.getClass().getSimpleName()+"访问");
    }
}

class ConcreteVisitor2 extends Visitor {
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName()+"被"+this.getClass().getSimpleName()+"访问");
    }

    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
        System.out.println(concreteElementB.getClass().getSimpleName()+"被"+this.getClass().getSimpleName()+"访问");
    }
}

abstract class Element {
    public abstract void accept(Visitor visitor);
}

class ConcreteElementA extends Element {
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementA(this);
    }

    public void operationA(){ 
    }
}

class ConcreteElementB extends Element {
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementB(this);
    }

    public void operationB(){ 
    }
}

class ObjectStructure {
    private ArrayList<Element> elements = new ArrayList<Element>();

    public void attach(Element element) {
        elements.add(element);
    }
    public void detach(Element element) {
        elements.remove(element);
    }
    public void accept(Visitor visitor) {
        for(Element e : elements) {
            e.accept(visitor);
        }
    }
}

责任链模式--行为型

基本代码

package code.chapter24.chainofresponsibility0;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 

        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.setSuccessor(h2);
        h2.setSuccessor(h3);

        int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };

        for(int request : requests) {
            h1.handleRequest(request);
        }
 
        System.out.println();
        System.out.println("**********************************************");
    }
}

abstract class Handler{
    protected Handler successor;

    //设置继任者
    public void setSuccessor(Handler successor){
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

class ConcreteHandler1 extends Handler{
    public void handleRequest(int request){
        if (request >=0 && request < 10){
            System.out.println(this.getClass().getSimpleName()+" 处理请求 "+request);
        }
        else if (successor != null){
            successor.handleRequest(request);
        }
    }
}

class ConcreteHandler2 extends Handler{
    public void handleRequest(int request){
        if (request >=10 && request < 20){
            System.out.println(this.getClass().getSimpleName()+" 处理请求 "+request);
        }
        else if (successor != null){
            successor.handleRequest(request);
        }
    }
}

class ConcreteHandler3 extends Handler{
    public void handleRequest(int request){
        if (request >=20 && request < 30){
            System.out.println(this.getClass().getSimpleName()+" 处理请求 "+request);
        }
        else if (successor != null){
            successor.handleRequest(request);
        }
    }
}

命令模式--行为型

基本代码

package code.chapter23.command0;

import java.util.ArrayList;
import java.util.Date;
import java.text.SimpleDateFormat;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 

        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();

        invoker.setCommand(command);
        invoker.executeCommand();

        
        System.out.println();
        System.out.println("**********************************************");
    }
}

//抽象命令类
abstract class Command {
    protected Receiver receiver;

    public Command(Receiver receiver){
        this.receiver = receiver;
    }
    //执行命令
    public abstract void excuteCommand();
}

//具体命令类
class ConcreteCommand extends Command{
    public ConcreteCommand(Receiver receiver){
        super(receiver);
    }

    public void excuteCommand(){
        receiver.action();
    }
}

class Invoker{

    private Command command;

    public void setCommand(Command command){
        this.command = command;
    }

    public void executeCommand(){
        command.excuteCommand();
    }

}

class Receiver{
    public void action(){
        System.out.println("执行请求！");
    }
}

桥接模式---结构型

基本代码

package code.chapter22.bridge0;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        Abstraction ab;
        ab = new RefinedAbstraction();

        ab.setImplementor(new ConcreteImplementorA());
        ab.operation();

        ab.setImplementor(new ConcreteImplementorB());
        ab.operation();

        System.out.println();
        System.out.println("**********************************************");
    }
}

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


class ConcreteImplementorA extends Implementor{
    public void operation(){
        System.out.println("具体实现A的方法执行");
    }
}

class ConcreteImplementorB extends Implementor{
    public void operation(){
        System.out.println("具体实现B的方法执行");
    }
}


abstract class Abstraction{
    protected Implementor implementor;

    public void setImplementor(Implementor implementor){
        this.implementor = implementor;
    }

    public abstract void operation();
}

class RefinedAbstraction extends Abstraction{
    public void operation(){
        System.out.print("具体的Abstraction");
        implementor.operation();
    }
}

装饰模式---结构型

基本代码

package code.chapter6.decorator0;

import java.util.Scanner;

public class Test {

   public static void main(String[] args){

      System.out.println("**********************************************");     
      System.out.println("《大话设计模式》代码样例");
      System.out.println();     

      ConcreteComponent c = new ConcreteComponent();
       ConcreteDecoratorA d1 = new ConcreteDecoratorA();
       ConcreteDecoratorB d2 = new ConcreteDecoratorB();

       d1.SetComponent(c);    //首先用d1来包装c
       d2.SetComponent(d1);//再用有来包装d1
       d2.Operation();    //最终执行d2的Operation()


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

   }
}

//Component类
abstract class Component {
    public abstract void Operation();
}


//ConcreteComponent类
class ConcreteComponent extends Component {
    
    public void Operation() {
        System.out.println("具体对象的实际操作");
    }

}

//Decorator类
abstract class Decorator extends Component {

    protected Component component;

    //装饰一个Component对象
    public void SetComponent(Component component) {
        this.component = component;
    }

    //重写Operation()，实际调用component的Operation方法
    public void Operation() {
        if (component != null) {
            component.Operation();
        }
    }
}

//ConcreteDecoratorA类
class ConcreteDecoratorA extends Decorator {
    
    private String addedState;//本类独有子段，以区别于ConcreteDecoratorB类

    public void Operation() {
        super.Operation();//首先运行了原有Component的Operation()

        this.addedState = "具体装饰对象A的独有操作";//再执行本类独有功能
        System.out.println(this.addedState);

    }
}

//ConcreteDecoratorB类
class ConcreteDecoratorB extends Decorator {

    public void Operation() {
        super.Operation();//首先运行了原有Component的Operation()
        this.AddedBehavior();//再执行本类独有功能
    }

    //本类独有方法，以区别于ConcreteDecoratorA类
    private void AddedBehavior() { 
       System.out.println("具体装饰对象B的独有操作");
    }
}

单例模式--创建型

基本代码--懒汉-双重锁定

package code.chapter21.singleton02;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        if (s1 == s2) {
            System.out.println("两个对象是相同的实例。");
        }

        System.out.println();
        System.out.println("**********************************************");
    }
}

//单例模式类
class Singleton {

    private volatile static Singleton instance;

    //构造方法private化
    private Singleton() {
    }

    //得到Singleton的实例（唯一途径）
    public static Singleton getInstance() {

        if (instance == null){

            synchronized(Singleton.class){

                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

基本代码-饿汉-静态初始化

package code.chapter21.singleton03;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println();       

        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        if (s1 == s2) {
            System.out.println("两个对象是相同的实例。");
        }

        System.out.println();
        System.out.println("**********************************************");
    }
}

//单例模式类
class Singleton {

    private static Singleton instance = new Singleton();

    //构造方法private化
    private Singleton() {
    }

    //得到Singleton的实例（唯一途径）
    public static Singleton getInstance() {
        return instance;
    }
}