Java的设计模式

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();
}

原文地址：https://www.cnblogs.com/SteveDZC/p/9726295.html

时间： 2024-11-05 21:45:24

Java的设计模式的相关文章

java/android 设计模式学习笔记（14）---外观模式

这篇博客来介绍外观模式(Facade Pattern),外观模式也称为门面模式,它在开发过程中运用频率非常高,尤其是第三方 SDK 基本很大概率都会使用外观模式.通过一个外观类使得整个子系统只有一个统一的高层的接口,这样能够降低用户的使用成本,也对用户屏蔽了很多实现细节.当然,在我们的开发过程中,外观模式也是我们封装 API 的常用手段,例如网络模块.ImageLoader 模块等.其实我们在开发过程中可能已经使用过很多次外观模式,只是没有从理论层面去了解它. 转载请注明出处:http://bl

java/android 设计模式学习笔记（10）---建造者模式

这篇博客我们来介绍一下建造者模式(Builder Pattern),建造者模式又被称为生成器模式,是创造性模式之一,与工厂方法模式和抽象工厂模式不同,后两者的目的是为了实现多态性,而 Builder 模式的目的则是为了将对象的构建与展示分离.Builder 模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细地控制对象的构造流程.一个复杂的对象有大量的组成部分,比如汽车它有车轮.方向盘.发动机.以及各种各样的小零件,要将这些部件装配成一辆汽车,这个装配过

java/android 设计模式学习笔记（一）---单例模式

前段时间公司一些同事在讨论单例模式(我是最渣的一个,都插不上嘴 T__T ),这个模式使用的频率很高,也可能是很多人最熟悉的设计模式,当然单例模式也算是最简单的设计模式之一吧,简单归简单,但是在实际使用的时候也会有一些坑. PS:对技术感兴趣的同鞋加群544645972一起交流 设计模式总目录 java/android 设计模式学习笔记目录 特点 确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例. 单例模式的使用很广泛,比如:线程池(threadpool).缓存(cache).对

java/android 设计模式学习笔记（7）---装饰者模式

这篇将会介绍装饰者模式(Decorator Pattern),装饰者模式也称为包装模式(Wrapper Pattern),结构型模式之一,其使用一种对客户端透明的方式来动态的扩展对象的功能,同时它也是继承关系的一种替代方案之一,但比继承更加灵活.在现实生活中也可以看到很多装饰者模式的例子,或者可以大胆的说装饰者模式无处不在,就拿一件东西来说,可以给它披上无数层不一样的外壳,但是这件东西还是这件东西,外壳不过是用来扩展这个东西的功能而已,这就是装饰者模式,装饰者的这个角色也许各不相同但是被装饰的对

(转)Java经典设计模式（3）：十一种行为型模式（附实例和详解）

原文出处: 小宝鸽 Java经典设计模式共有21中,分为三大类:创建型模式(5种).结构型模式(7种)和行为型模式(11种). 本文主要讲行为型模式,创建型模式和结构型模式可以看博主的另外两篇文章:Java经典设计模式之五大创建型模式(附实例和详解).Java经典设计模式之七大结构型模式(附实例和详解). 行为型模式细分为如下11种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 接下来对11种行为型模式逐个进行介

java/android 设计模式学习笔记（13）---享元模式

这篇我们来介绍一下享元模式(Flyweight Pattern),Flyweight 代表轻量级的意思,享元模式是对象池的一种实现.享元模式用来尽可能减少内存使用量,它适合用于可能存在大量重复对象的场景,缓存可共享的对象,来达到对象共享和避免创建过多对象的效果,这样一来就可以提升性能,避免内存移除和频繁 GC 等. 享元模式的一个经典使用案例是文本系统中图形显示所用的数据结构,一个文本系统能够显示的字符种类就是那么几十上百个,那么就定义这么些基础字符对象,存储每个字符的显示外形和其他的格式化数据

Java Web 设计模式之开闭原则

1.开闭原则(OCP) 遵循开闭原则设计出的模块具有两个主要特征: (1)对于扩展是开放的(Open for extension).这意味着模块的行为是可以扩展的.当应用的需求改变时,我们可以对模块进行扩展,使其具有满足那些改变的新行为.也就是说,我们可以改变模块的功能. (2)对于修改是关闭的(Closed for modification).对模块行为进行扩展时,不必改动模块的源代码或者二进制代码.模块的二进制可执行版本,无论是可链接的库.DLL或者.EXE文件,都无需改动. 2.通过UML

Java软件设计模式------装饰设计模式

Java软件设计模式一共分为23种; 一般常用的有: 单例设计模式 装饰设计模式 工厂设计模式 装饰设计模式 定义:英文叫Decorator Pattern,又叫装饰者模式.装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象. 在生活中我们用程序员和项目经理的例子来比喻,项目经理是从程序员开始的,经过不断地积累工作经验.不断的学习新的知识,才有可能升职. 在装饰设计模式中项目经理就是程序员的增强. 程序猿: 写程序 项目

(转)Java经典设计模式（2）：七大结构型模式（附实例和详解）

原文出处: 小宝鸽 总体来说设计模式分为三大类:创建型模式.结构型模式和行为型模式. 博主的上一篇文章已经提到过创建型模式,此外该文章还有设计模式概况和设计模式的六大原则.设计模式的六大原则是设计模式的核心思想,详情请看博主的另外一篇文章:Java经典设计模式之五大创建模式(附实例和详解). 接下来我们看看结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式.其中适配器模式主要分为三类:类的适配器模式.对象的适配器模式.接口的适配器模式.其中的对象的适配器

java/android 设计模式学习笔记（12）---组合模式

这篇我们来介绍一下组合模式(Composite Pattern),它也称为部分整体模式(Part-Whole Pattern),结构型模式之一.组合模式比较简单,它将一组相似的对象看作一个对象处理,并根据一个树状结构来组合对象,然后提供一个统一的方法去访问相应的对象,以此忽略掉对象与对象集合之间的差别.这个最典型的例子就是数据结构中的树了,如果一个节点有子节点,那么它就是枝干节点,如果没有子节点,那么它就是叶子节点,那么怎么把枝干节点和叶子节点统一当作一种对象处理呢?这就需要用到组合模式了. 转