Java的设计模式

Posted 2021-01-09 stevedzc

Java设计模式

介绍

GOF是Gang of four（四人帮）的简称，是由四位java业界的专家编写的针对特定场景下问题的专家级解决方案。大概包含23中设计模式，设计模式本身与技术没有太大关系，主要是设计思想的运用，比较著名的像单例模式、工厂模式等。本文不打算给出所有设计模式的说明，主要给出实际应用较普遍的几种且比较经典的设计

高内聚和低耦合

内聚 ：事物内部的联系程度，高内聚。 
耦合 ：事物之间的联系程度，低耦合。

1.单例模式

• 懒汉模式
  1.singleton

     单例  : 类有且只有一个实例。 
     package com.oldboy.java.gof.singleton;
     /**
      * 回收站
      */
     public class Trash {
        //静态执行自身的引用
        private static Trash instance ;
        //懒汉式
        public static Trash getInstance(){
            if(instance != null){
                return instance ;
            }
            //安全性控制
            synchronized (Trash.class){
                //需要增强该项控制
                if(instance == null){
                    instance = new Trash() ;
                }
            }
            return instance ;
        }
         //构造私有
        private Trash(){
        }

        public static void main(String[] args) {
            //多线程场景实现
            new Thread() {
                public void run() {
                    Trash t = Trash.getInstance();
                    System.out.println(t);
                }
            }.start();
            new Thread() {
                public void run() {
                    Trash t = Trash.getInstance();
                    System.out.println(t);
                }
            }.start();
        }
     }

• 饿汉模式
• 饿汉模式比较简单，相比较懒汉模式更加具有安全性，因为数组类加载时进行对象的创建，不会设计并发问题。
  

     - package com.oldboy.java.gof.singleton;
       /**
         回收站
       */
       public class Trash {
         //静态指向自身的引用
         private static Trash instance = new Trash();
         //
         public static Trash getInstance(){
         return instance ;
         }

       private Trash(){

       }

       public static void main(String[] args) {
        //多线程场景实现
           new Thread() {
     public void run() {
         Trash t = Trash.getInstance();
         System.out.println(t);
     }
     }.start();

     new Thread() {
     public void run() {
         Trash t = Trash.getInstance();
         System.out.println(t);
     }
     - [ ] }.start();
       }
     }

2.工厂模式

< 工厂模式也是使用较多的设计模式之一，有静态工厂和非静态工厂的分别

工厂模式

静态工厂

        public class Factory1 {
            /**
             * 静态工厂
             */
            public static TVSet newTVSet(){
                TVSet tv = new TVSet();
                tv.setBrand("songxia");
                tv.setColor("red");
                tv.setSize(120);
                return tv ;
            }
        }

非静态工厂

     public class Factory2 {
        /**
         * 非静态工厂
         */
        public TVSet newTVSet(){
            TVSet tv = new TVSet();
            tv.setBrand("songxia");
            tv.setColor("red");
            tv.setSize(120);
            return tv ;
        }
     }

3.装饰模式

    class A{
    }
    
    class WrappedA extends A{
        private A a ;
        public WrappedA(A a){
            this.a = a ;
        }
    
        public void aa(){
            ...
            //增强A的能力
            a.aa() ;
            ...
        }
    }
    
    java中FilterInputStream的装饰流的根类。

4.Builder模式

builder模式我 们称为构建器模式，通过方法方式编程，本质上是突破了标志的javabean规范。
package com.oldboy.java.gof.builder;

    /**
     * 电脑
     */
    public class Computer {
        private String cpu;
        private String memory ;
        private String hardDisk ;
    
        public String getCpu() {
            return cpu;
        }
    
        public void setCpu(String cpu) {
            this.cpu = cpu;
        }
    
        public String getMemory() {
            return memory;
        }
    
        public void setMemory(String memory) {
            this.memory = memory;
        }
    
        public String getHardDisk() {
            return hardDisk;
        }
    
        public void setHardDisk(String hardDisk) {
            this.hardDisk = hardDisk;
        }
        /**
         * 内部构建器
         */
        public static class Builder{
            private Computer computer = new Computer() ;
    
            public Builder setCpu(String cpu){
                computer.setCpu(cpu);
                return this ;
            }
            public Builder setMemory(String mem){
                computer.setMemory(mem);
                return this ;
            }
            public Builder setHardDisk(String disk){
                computer.setHardDisk(disk);
                return this ;
            }
    
            public Computer build(){
                return computer ;
            }
        }
    }
    class App{
      public static void main(String[] args){
        //链式编程
        Computer c=new Computer.Builder()
                         .setCpu("intel")
                         .setMemory("sanxing")
                         .setHardDisk("xishu")
                         .build();
      }
    }

5.适配器模式

适配器模式主要针对接口的情况下，进行预实现，具体使用时就不需要对所有方法将那些实现了。比较典型的swing中的WindowAdpator.

   5.适配
    GUI : graphic user interface,图形用户接口。
    适配器模式就是预实现（空实现）。
    /**
    窗口适配器
    */
    package java.awt.event;
    public abstract class WindowAdapter
        implements WindowListener, WindowStateListener, WindowFocusListener
    {
        public void windowOpened(WindowEvent e) {}
        public void windowClosing(WindowEvent e) {}
        public void windowClosed(WindowEvent e) {}
        public void windowIconified(WindowEvent e) {}
        public void windowDeiconified(WindowEvent e) {}
        public void windowActivated(WindowEvent e) {}
        public void windowDeactivated(WindowEvent e) {}
        ...
    }
public class App {
    public static void main(String[] args) {
    JFrame f = new JFrame() ;
    f.setBounds(0 ,0 , 1366 , 768);
    f.setTitle("标题栏");
    //适配器模式应用
    f.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
            System.exit(-1);
        }
    });
    f.setVisible(true);
}
}

6.装饰模式

装饰模式比较典型的是java中的IO流，缓冲区流、压缩流都是装饰模式的体现。即在原有组件的功能基础上，增加或增强部分功能。java IO中装饰模式的根类是FilterInputStream。装饰模式的设计原则是：

    class A{
      public void aa(){
       ..
      }
    }

    class WrappedA extends A{
      private A a ;
      public WrappedA(A a){
      this.a = a ;
      }

      public void aa(){
      ..
       a.aa() ;
        ..
      }
    }
    FilterInputStream的类如下：
public
  class FilterInputStream extends InputStream {
    protected volatile InputStream in;
    protected FilterInputStream(InputStream in) {
      this.in = in;
    }

    public int read() throws IOException {
      return in.read();
    }
    ...
  }

7、观察者模式

观察者模式jdk给出的固定编程场景，当某个事物发生时，对其进行观察的主体就会做出响应的工作。但要注意观察者模式也成为等待通知模式，不过和多线程中的等待通知模型没有任何关系。警察与小偷的这个行为关系可以比较典型用观察者模式来实现。这里警察是观察者，观察小偷的行为，小偷是被观察者，小偷一旦进行偷窃行为，所有的警察都一拥而上，完成个自己的任务。因此设计的类如下：

/**
 * 小偷，可被观察，因此集成java.util.Observable类。
 */
class Thief extends Observable{
  public void stealOneThing(String thing){
    //
    System.out.println("偷了一个东西 : " + thing);
    //设置改变标记
    setChanged();
    //通知所有观察者
    notifyObservers();
  }
}

/*
 * 警察1-观察者
 */
class Police1 implements Observer{
  public void update(Observable o, Object arg) {
    System.out.println("行动1");
  }
}

/**
 * 警察2-观察者
 */
class Police2 implements Observer {
  public void update(Observable o, Object arg) {
    System.out.println("行动2");
  }
}

class App{
  public static void main(String[] args) {
    //创建被观察者，
    Thief a = new Thief();
    //添加观察者
    a.addObserver(new Police1());
    a.addObserver(new Police2());
    //让小偷开始行动
    a.stealOneThing("iphone 6 plus");
  }
}

8、责任链模式

责任链模式可以理解为流水线上的工人，每个工作做完自己的工作后交给下一个工作继续处理。因此类似于java中链表数据结构的概念。比如生产一辆汽车需要上轮胎、安装发动机、方向盘安装、座椅、喷漆等一序列工作，均有不同的工人完成，就可以采用责任链编程模式。代码如下：

/**
 * 工人抽象类
 */
public abstract class Worker {
  //下一个工人
  private Worker nextWorker ;

  public Worker(){
  }
  public Worker(Worker nextWorker){
    this.nextWorker = nextWorker ;
  }

  public void setNextWorker(Worker nextWorker) {
    this.nextWorker = nextWorker;
  }
  public void work(){
    doWork();
    if(nextWorker != null){
      nextWorker.work();
    }
  }

  public abstract void doWork()  ;
}

/**
 * 轮胎工
 */
public class TireWorker extends Worker{
  public void doWork() {
    System.out.println("上轮胎");
  }
}

/**
 * 上发动机
 */
public class EngineWorker extends Worker{
  public void doWork() {
    System.out.println("上发动机");
  }
}

/**
 * 喷漆工
 */
public class PaintWorker extends Worker{
  public void doWork() {
    System.out.println("喷漆");
  }
}
/**
 * 汽车类
 */
public class Car {
  public void handledBy(Worker worker){
    worker.work();
  }
}

/**
 * App访问方式
 */
class App {
  public static void main(String[] args) {
    TireWorker w1 = new TireWorker();
    EngineWorker w2 = new EngineWorker();
    PaintWorker w3 = new PaintWorker();
    w1.setNextWorker(w2);
    w2.setNextWorker(w3);

    Car car = new Car();
    car.handledBy(w1);
  }
}

9、代理模式

代理模式是通过jdk提供的Proxy类实现的，其能类似于装饰模式，不同之处是可以将装饰模式理解为静态的增强实现，通常是对某些特定功能或某方面固定需求进行的实现，比如缓冲区、压缩等等。代理是一种动态的机制，在内存中动态产生对象对并对其方法进行增强，具有更加强大的功能。例如对方法执行时间进行计时统计，就可以通过代理模式来时先：

/**
 * 接口
 */
static interface WelcomeService{
  public void sayHello() ;
}
/**
 * 实习类
 */
class WelcomeServiceImpl implements WelcomeService{
  public void sayHello() {
    System.out.println("hello world");
  }
}

//主函数
public static void main(String[] args) {
  final WelcomeService ws = new WelcomeServiceImpl() ;
  //处理器
  InvocationHandler h = new InvocationHandler() {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      long start = System.nanoTime() ;
      Object obj = method.invoke(ws , args) ;
      System.out.println("执行耗时 ： " + (System.nanoTime() - start));
      return obj;
    }
  } ;
  ClassLoader loader = ClassLoader.getSystemClassLoader() ;
  //创建代理对象
  WelcomeService proxy = (WelcomeService) Proxy.newProxyInstance(loader ,new Class[]{WelcomeService.class} , h);
  proxy.sayHello();
}