- 页 数
- 227页
- 作 者
- 耿祥义、张跃平
- 定 价
- 29.00元
- 装 帧
- 平装
- 书 名
- Java设计模式
- 出版时间
- 2009年
- 开 本
- 16开
- 出版社
- 清华大学出版社
- ISBN
- 9787302198048
-
JAVA设计模式之单例模式
2014-04-16 06:51:34java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。 单例模式有以下特点: 1、单例类只能有一个实例。 2、单例类必须自己创建自己的...本文继续介绍23种设计模式系列之单例模式。
概念:
java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。
单例模式有以下特点:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态,避免政出多头。
一、懒汉式单例//懒汉式单例类.在第一次调用的时候实例化自己 public class Singleton { private Singleton() {} private static Singleton single=null; //静态工厂方法 public static Singleton getInstance() { if (single == null) { single = new Singleton(); } return single; } }
Singleton通过将构造方法限定为private避免了类在外部被实例化,在同一个虚拟机范围内,Singleton的唯一实例只能通过getInstance()方法访问。
(事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)
但是以上懒汉式单例的实现没有考虑线程安全问题,它是线程不安全的,并发环境下很可能出现多个Singleton实例,要实现线程安全,有以下三种方式,都是对getInstance这个方法改造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面这三小条,去看饿汉式单例,等看完后面再回头考虑线程安全的问题:
1、在getInstance方法上加同步
public static synchronized Singleton getInstance() { if (single == null) { single = new Singleton(); } return single; }
2、双重检查锁定
public static Singleton getInstance() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; }
3、静态内部类
public class Singleton { private static class LazyHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton (){} public static final Singleton getInstance() { return LazyHolder.INSTANCE; } }
这种比上面1、2都好一些,既实现了线程安全,又避免了同步带来的性能影响。
二、饿汉式单例
//饿汉式单例类.在类初始化时,已经自行实例化 public class Singleton1 { private Singleton1() {} private static final Singleton1 single = new Singleton1(); //静态工厂方法 public static Singleton1 getInstance() { return single; } }
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。
三、登记式单例(可忽略)
//类似Spring里面的方法,将类名注册,下次从里面直接获取。 public class Singleton3 { private static Map<String,Singleton3> map = new HashMap<String,Singleton3>(); static{ Singleton3 single = new Singleton3(); map.put(single.getClass().getName(), single); } //保护的默认构造子 protected Singleton3(){} //静态工厂方法,返还此类惟一的实例 public static Singleton3 getInstance(String name) { if(name == null) { name = Singleton3.class.getName(); System.out.println("name == null"+"--->name="+name); } if(map.get(name) == null) { try { map.put(name, (Singleton3) Class.forName(name).newInstance()); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } return map.get(name); } //一个示意性的商业方法 public String about() { return "Hello, I am RegSingleton."; } public static void main(String[] args) { Singleton3 single3 = Singleton3.getInstance(null); System.out.println(single3.about()); } }
登记式单例实际上维护了一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从Map直接返回,对于没有登记的,则先登记,然后返回。
这里我对登记式单例标记了可忽略,我的理解来说,首先它用的比较少,另外其实内部实现还是用的饿汉式单例,因为其中的static方法块,它的单例在类被装载的时候就被实例化了。
饿汉式和懒汉式区别
从名字上来说,饿汉和懒汉,
饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,
而懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。
另外从以下两点再区分以下这两种方式:
1、线程安全:
饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,
懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。
2、资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,
而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。
至于1、2、3这三种实现又有些区别,
第1种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟99%的情况下是不需要同步的,
第2种,在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗
第3种,利用了classloader的机制来保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗,所以一般我倾向于使用这一种。
什么是线程安全?
如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作,或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题,那就是线程安全的。
应用
以下是一个单例类使用的例子,以懒汉式为例,这里为了保证线程安全,使用了双重检查锁定的方式:
public class TestSingleton { String name = null; private TestSingleton() { } private static volatile TestSingleton instance = null; public static TestSingleton getInstance() { if (instance == null) { synchronized (TestSingleton.class) { if (instance == null) { instance = new TestSingleton(); } } } return instance; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void printInfo() { System.out.println("the name is " + name); } }
可以看到里面加了volatile关键字来声明单例对象,既然synchronized已经起到了多线程下原子性、有序性、可见性的作用,为什么还要加volatile呢,原因已经在下面评论中提到,
还有疑问可参考http://www.iteye.com/topic/652440
和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.htmlpublic class TMain { public static void main(String[] args){ TestStream ts1 = TestSingleton.getInstance(); ts1.setName("jason"); TestStream ts2 = TestSingleton.getInstance(); ts2.setName("0539"); ts1.printInfo(); ts2.printInfo(); if(ts1 == ts2){ System.out.println("创建的是同一个实例"); }else{ System.out.println("创建的不是同一个实例"); } } }
运行结果:
结论:由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点,不管它实现何种功能,整个应用程序都会同享一个实例对象。
对于单例模式的几种实现方式,知道饿汉式和懒汉式的区别,线程安全,资源加载的时机,还有懒汉式为了实现线程安全的3种方式的细微差别。
更多设计模式:23种设计模式系列
作者:jason0539
博客:http://blog.csdn.net/jason0539(转载请说明出处)
-
Java设计模式
2007-02-07 09:15:12Java设计模式 -
JAVA设计模式
2017-12-21 21:40:49JAVA设计模式什么是设计模式
在软件工程中,设计模式是对软件设计中普遍存在的各种问题,所提出的 解决方案。 换句话说,设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计的 经验的总结。使用设计模式是为了可重用代码,让代码更容易被他人理解,保证代码可靠性。
设计模式原则
1、开闭原则(Open Close Principle)
开闭原则的意思是:对扩展开放,对修改封闭。在程序需要进行扩展的时候,不能去修改或影响原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性更好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类。
2、里氏代换原则(Liskov Substitution Principle)
里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。里氏代换原则是继承复用的基石,只有当子类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而且子类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则(Dependence Inversion Principle)
这个原则是开闭原则的基础,核心内容:针对接口编程,高层模块不应该依赖底层模块,二者都应该依赖抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
这个原则的意思是:使用多个隔离的接口,比使用单个庞大的接口要好。其目的在于降低耦合度。由此可见,其实设计模式就是从大型软件架构出发,便于升级和维护软件的设计思想。它强调低依赖、低耦合。
5、单一职责原则(Single Responsibility Principle)
类的职责要单一,不能将太多的职责放在一个类中。 可能有的人会觉得单一职责原则和前面的接口隔离原则很相似,其实不然。其一,单一职责原则注重的是职责;而接口隔离原则注重对接口依赖的隔离。其二,单一职责原则主要约束的是类,其次才是接口和方法,它针对的是程序中的实现和细节;而接口隔离原则主要约束接口,主要针对抽象,针对程序整体框架的构建。
6、最少知道原则(Demeter Principle)
最少知道原则也叫迪米特法则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。 一个对象应该对其他对象保持最少的了解。类与类之间的关系越密切,耦合度越大,当一个类发生改变时,对另一个类的影响也越大。如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。所以在类的设计上,每一个类都应当尽量降低成员的访问权限。
7、合成复用原则(Composite Reuse Principle)
合成复用原则就是在一个新的对象里通过关联关系(组合关系、聚合关系)来使用一些已有的对象,使之成为新对象的一部分;新对象通过委派调用已有对象的方法达到复用功能的目的。简而言之,尽量多使用 组合/聚合 的方式,尽量少使用甚至不使用继承关系。
设计模式分类
通常来说设计模式分为三大类:
创建型模式,共5种:工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共7种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式,共11种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
下面用图片来整体描述一下设计模式之间的关系:
-
java设计模式
2018-07-12 13:49:41一、工厂模式创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。1、创建一个接口:Shape.javapublic interface Shape { void draw();}2、创建实现接口的实体类。Rectangle.java...一、工厂模式
创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。
1、创建一个接口:
Shape.java
public interface Shape { void draw();}
2、创建实现接口的实体类。
Rectangle.java
public class Rectangle implements Shape { @Override public void draw() { System.out.println("Inside Rectangle::draw() method."); }}
Square.java
public class Square implements Shape { @Override public void draw() { System.out.println("Inside Square::draw() method.");}}Circle.java
public class Circle implements Shape { @Override public void draw() { System.out.println("Inside Circle::draw() method."); }}2、创建一个工厂,生成基于给定信息的实体类的对象。
ShapeFactory.java
public class ShapeFactory { //使用 getShape 方法获取形状类型的对象 public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; }}
4、使用该工厂,通过传递类型信息来获取实体类的对象。
FactoryPatternDemo.java
public class FactoryPatternDemo { public static void main(String[] args) { ShapeFactory shapeFactory = new ShapeFactory(); //获取 Circle 的对象,并调用它的 draw 方法 Shape shape1 = shapeFactory.getShape("CIRCLE"); //调用 Circle 的 draw 方法 shape1.draw(); //获取 Rectangle 的对象,并调用它的 draw 方法 Shape shape2 = shapeFactory.getShape("RECTANGLE"); //调用 Rectangle 的 draw 方法 shape2.draw(); //获取 Square 的对象,并调用它的 draw 方法 Shape shape3 = shapeFactory.getShape("SQUARE"); //调用 Square 的 draw 方法 shape3.draw(); }}
二、单例模式
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。
注意:
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。
SingleObject 类提供了一个静态方法,供外界获取它的静态实例。SingletonPatternDemo,我们的演示类使用 SingleObject 类来获取 SingleObject对象。
1、创建一个 Singleton 类public class SingleObject { //创建 SingleObject 的一个对象 private static SingleObject instance = new SingleObject(); //让构造函数为 private,这样该类就不会被实例化 private SingleObject(){} //获取唯一可用的对象 public static SingleObject getInstance(){ return instance; } public void showMessage(){ System.out.println("Hello World!"); }}
2、从 singleton 类获取唯一的对象
public class SingletonPatternDemo { public static void main(String[] args) { //不合法的构造函数 //编译时错误:构造函数 SingleObject() 是不可见的 //SingleObject object = new SingleObject(); //获取唯一可用的对象 SingleObject object = SingleObject.getInstance(); //显示消息 object.showMessage(); }}
三、适配器模式
1、为媒体播放器和更高级的媒体播放器创建接口。
MediaPlayer.java
public interface MediaPlayer { public void play(String audioType, String fileName);}AdvancedMediaPlayer.java
public interface AdvancedMediaPlayer { public void playVlc(String fileName); public void playMp4(String fileName);}2、创建实现了 AdvancedMediaPlayer 接口的实体类。
VlcPlayer.java
public class VlcPlayer implements AdvancedMediaPlayer{ @Override public void playVlc(String fileName) { System.out.println("Playing vlc file. Name: "+ fileName); } @Override public void playMp4(String fileName) { //什么也不做 }}Mp4Player.java
public class Mp4Player implements AdvancedMediaPlayer{ @Override public void playVlc(String fileName) { //什么也不做 } @Override public void playMp4(String fileName) { System.out.println("Playing mp4 file. Name: "+ fileName); }}3、创建实现了 MediaPlayer 接口的适配器类。
MediaAdapter.java
public class MediaAdapter implements MediaPlayer { AdvancedMediaPlayer advancedMusicPlayer; public MediaAdapter(String audioType){ if(audioType.equalsIgnoreCase("vlc") ){ advancedMusicPlayer = new VlcPlayer(); } else if (audioType.equalsIgnoreCase("mp4")){ advancedMusicPlayer = new Mp4Player(); } } @Override public void play(String audioType, String fileName) { if(audioType.equalsIgnoreCase("vlc")){ advancedMusicPlayer.playVlc(fileName); }else if(audioType.equalsIgnoreCase("mp4")){ advancedMusicPlayer.playMp4(fileName); } }}4、创建实现了 MediaPlayer 接口的实体类。
AudioPlayer.java
public class AudioPlayer implements MediaPlayer { MediaAdapter mediaAdapter; @Override public void play(String audioType, String fileName) { //播放 mp3 音乐文件的内置支持 if(audioType.equalsIgnoreCase("mp3")){ System.out.println("Playing mp3 file. Name: "+ fileName); } //mediaAdapter 提供了播放其他文件格式的支持 else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){ mediaAdapter = new MediaAdapter(audioType); mediaAdapter.play(audioType, fileName); } else{ System.out.println("Invalid media. "+ audioType + " format not supported"); } } }5、使用 AudioPlayer 来播放不同类型的音频格式。
AdapterPatternDemo.java
public class AdapterPatternDemo { public static void main(String[] args) { AudioPlayer audioPlayer = new AudioPlayer(); audioPlayer.play("mp3", "beyond the horizon.mp3"); audioPlayer.play("mp4", "alone.mp4"); audioPlayer.play("vlc", "far far away.vlc"); audioPlayer.play("avi", "mind me.avi"); }} -
【JAVA设计模式】
2019-04-28 15:30:33【JAVA设计模式】序章 可以直接去这里,感觉讲解更到位:软件设计模式概述 传送门 【JAVA设计模式】设计六大原则 【JAVA设计模式】简单工厂模式 【JAVA设计模式】策略模式 【JAVA设计模式】装饰模式 【JAVA...【JAVA设计模式】序章
可以直接去这里,感觉讲解更到位:软件设计模式概述
- 传送门
- 【JAVA设计模式】设计六大原则
- 【JAVA设计模式】简单工厂模式
- 【JAVA设计模式】策略模式
- 【JAVA设计模式】装饰模式
- 【JAVA设计模式】代理模式
- 【JAVA设计模式】工厂方法模式
- 【JAVA设计模式】原型模式
- 【JAVA设计模式】模板方法模式
- 【JAVA设计模式】外观模式
- 【JAVA设计模式】建造者模式
- 【JAVA设计模式】观察者模式
- 【JAVA设计模式】抽象工厂模式
- 【JAVA设计模式】状态模式
- 【JAVA设计模式】适配器模式
- 【JAVA设计模式】备忘录模式
- 【JAVA设计模式】组合模式
- 【JAVA设计模式】迭代器模式
- 【JAVA设计模式】单例模式
- 【JAVA设计模式】桥接模式
- 【JAVA设计模式】命令模式
- 【JAVA设计模式】职责链模式
- 【JAVA设计模式】中介者模式
- 【JAVA设计模式】享元模式
- 【JAVA设计模式】解释器模式
- 【JAVA设计模式】访问者模式
注:感谢博主的精彩分享,转载自:https://blog.csdn.net/haobao528/article/details/85317014
-
JAVA设计模式初探之装饰者模式
2014-04-01 09:07:37设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态... -
Java设计模式PDF中文版
2009-11-11 11:00:03PDF中文版Java设计模式 Java 提供了丰富的API,同时又有强大的数据库系统作底层支持,那么我们的编程似乎 变成了类似积木的简单"拼凑"和调用,甚至有人提倡"蓝领程序员",这些都是对现代编 程技术的不了解所至. 在... -
java 设计模式 单例模式Singleton
2019-09-20 15:59:34java 设计模式 单例模式Singleton public class EagerSingleton { private static final EagerSingleton instance = new EagerSingleton(); private EagerSingleton() { } public static EagerSingleton... -
Java设计模式 —— 单例模式
2020-05-31 10:50:19本文主要讲解Java设计模式中,最最基础的单例模式。 -
java 设计模式 免费 视频课程
2019-04-07 21:38:53java 设计模式 免费 视频课程 更详细课程大纲入口:https://edu.csdn.net/course/detail/23462 详细课程直接播放地址:https://edu.csdn.net/course/play/23462 -
【Java】Java设计模式
2020-03-28 13:01:14设计模式:设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式,Java设计模式有23种 【1】单例设计模式 //单例设计模式-饿汉式 线程安全 class Singleton { // 1.私有化... -
Java设计模式pdf
2020-06-26 14:52:00Java设计模式PDF下载PDF简述下载链接PDF图片 PDF简述 全PDF共分27章,内容包括统一建模语言基础知识、面向对象设计原则、设计模式概述、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式... -
Java 设计模式——状态模式
2016-06-06 16:46:00你可以阅读《Java设计模式——策略模式》这篇博客,并与本文对比,以找到蛛丝马迹。 他们最根本的差异在于策略模式是在求解同一个问题的多种解法,这些不同解法之间毫无关联;状态模式则不同,状态模式要求各个状态... -
【JAVA设计模式】序章
2018-12-28 09:36:29【JAVA设计模式】设计六大原则 【JAVA设计模式】简单工厂模式 【JAVA设计模式】策略模式 【JAVA设计模式】装饰模式 【JAVA设计模式】代理模式 【JAVA设计模式】工厂方法模式 【JAVA设计模式】原型模式 【JAVA... -
【Java设计模式】总结
2019-07-12 16:56:26【Java设计模式】UML 2.2 UML基础 UML类图 UML类关系 UML时序图 七个软件设计原则 【Java设计模式】软件设计七大原则 开闭原则 迪米特原则 依赖倒置原则 里氏替换原则 单一职责原则 合成复用原则 接口隔离原则 二十... -
Java设计模式之单例模式
2019-11-06 20:51:55单例模式是常用的23种设计模式中最简单也是最常用的模式。“隐藏构造方法并提供获得类的实例的方法来达到整个系统中只有此类的唯一的实现对象”是单例的核心。饿汉式一开始就创建了资源,而懒汉式虽然一开始节约了... -
代理模式(java设计模式)
2019-01-24 10:40:29代理模式的定义:给某一个对象提供一个代理,并由代理对象控制对原对象的引用。 代理模式包含如下角色: ISubject:抽象主题角色,是一个接口。该接口是对象和它的代理共用的接口。 RealSubject:真实主题角色,... -
JAVA设计模式一一 Proxy
2019-05-08 17:28:34JAVA设计模式一一 Proxy -
Java 设计模式-简单工厂模式
2020-07-05 17:00:19Java 设计模式-简单工厂模式 文章目录Java 设计模式-简单工厂模式介绍简单工厂模式的结构与实现**简单工厂模式的优缺点和适用环境** 介绍 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method... -
Java设计模式之原型模式
2019-11-10 17:29:55在有些系统中,存在大量相同或相似对象的创建的工作,如果用传统的构造函数来创建对象,会比较复杂且耗时耗资源,用原型模式生成对象就很高效。原型模式属于对象的创建模式通过给出一个原型对象来指明所有创建的对象... -
【Java设计模式】软件设计七大原则
2019-08-31 13:44:31文章目录软件设计原则的分类开闭原则依赖倒置原则单一职责原则接口隔离原则迪米特法则(最少知道原则...在设计模式中会有这7中软件设计原则的体现,但是值得注意的是这7钟设计原则在设计模式中的使用是有取舍的,有... -
Java设计模式——命令模式
2019-01-07 10:40:51命令模式 命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都... -
Java设计模式之单例模式的实现
2018-12-12 10:44:11Java23种设计模式(参考JAVA设计模式总结之23种设计模式) 单例模式: Java限制了类的实例,保证了JVM中只能存在一个某个类的一个实例 单实例类必须提供一个访问该实例的全局方法(其实就是public static) ... -
Java设计模式——观察者模式
2015-11-25 00:35:51本文通过两个实例(分别是“气象观测站”和“计时器应用”),对Java设计模式中的观察者模式做一个详细的说明。 -
Java设计模式-开闭原则
2019-03-01 16:25:17Java设计模式学习 -
Java设计模式---原型模式
2020-06-02 12:04:32你好我是辰兮,很高兴你能来阅读,本篇给你介绍Java设计模式之原型模式,通过简单的案例给你讲解,分享给初学者,大家一起进步。 文章目录一、序言二、原型模式的定义与特点三、原型模式的结构与实现 一、序言 在... -
java设计模式--单例模式推理过程
2020-03-13 21:26:56java 设计模式 设计模式(全名:软件设计模式),是一套反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式是为了可重用代码,让代码更容易被他人理解,保证代码可靠性,程序的重用性。 1....