【读书笔记】HeadFirst设计模式——单件不简单：详述实现Singleton模式需要考虑的方方面面

最新推荐文章于 2021-07-20 15:13:04 发布
最新推荐文章于 2021-07-20 15:13:04 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： java 模式 读书笔记 设计 文章标签： 设计模式 读书 exception class string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhmhappy2006/article/details/7371447
版权
读书笔记 同时被 3 个专栏收录
43 篇文章 0 订阅
订阅专栏
java
33 篇文章 0 订阅
订阅专栏
设计
15 篇文章 0 订阅
订阅专栏

(参考：

深入浅出单实例Singleton设计模式

)

什么是单件？

单件就是保证一个类仅有一个实例，并提供一个访问它的全局访问点。——GOF

单件模式简单吗？

简单，的确简单，因为只有一个类。

单件不简单！

其实单件并不见得简单，而且还有点小复杂。其复杂度正是为了保证单件所要达到“仅有一个实例”的宏伟目标而引起的。

当然在一般情况下，单件是简单的。但是在考虑了懒加载、并发、反射、序列化、子类化等诸多因素后，为了保证只有一个实例，复杂度就大大提高了。

下面就从这些方面一一来看如何保证单件只有一个实例，然后看看是不是并不像想象的简单。


1.So easy!饿汉

很简单，直接访问静态域，为防修改，定义成final的。当然构造函数必须是私有的。

/**
 * 最简单的单件实现,直接访问静态域
 * 
 * @author nathan
 * 
 */
public class SimpleSingleton {
	public final static SimpleSingleton INSTANCE = new SimpleSingleton();

	private SimpleSingleton() {

	}

	public void doSomething() {
		System.out.println("SimpleSingleton.doSomething");
	}
}

2.1的变体

通过静态方法访问

/**
 * 最简单的单件实现,访问静态方法
 * 
 * @author nathan
 * 
 */
public class SimpleSingleton2 {
	private final static SimpleSingleton2 INSTANCE = new SimpleSingleton2();

	private SimpleSingleton2() {

	}

	public void doSomething() {
		System.out.println("SimpleSingleton2.doSomething");
	}

	public static SimpleSingleton2 getInstance() {
		return INSTANCE;
	}
}

3.复杂度+1：反反射调用私有构造函数创建实例。

实现方式，在构造函数中判断是否为空，否则抛出异常

/**
 * 反反射调用构造函数的单件实现
 * 
 * @author nathan
 * 
 */
public class AntiRefSingleton {

	public static AntiRefSingleton instance = new AntiRefSingleton();

	private AntiRefSingleton() {
		if (instance != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use AntiRefSingleton.instance to get the Object!");
		}
	}

	public void doSomething() {
		System.out.println("SimpleSingleton.doSomething");
	}

}


3.复杂度+2：懒汉

为防止加载没用的加载比较耗时的单件

/**
 * 懒加载的单件实现，但有并发问题
 * 
 * @author nathan
 * 
 */
public class LazySingleton {
	private static LazySingleton instance = null;

	private LazySingleton() {
		if (instance != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use the getInstance function to get the Object!");
		}
	}

	public void doSomething() {
		System.out.println("LazySingleton.doSomething");
	}

	public static LazySingleton getInstance() {
		if (instance == null) {
			instance = new LazySingleton();
		}
		return instance;
	}
}

4.复杂度+3：并发控制

懒汉做事总是不靠谱，必须要有额外的机制保证线程安全——DCL（双重检查加锁）

/**
 * 使用DCL技术实现的并发安全的懒加载单件实现
 * 
 * @author nathan
 * 
 */
public class ConcurrentSingleton {
	/**
	 * 必须声明为volatile的
	 */
	private static volatile ConcurrentSingleton instance = null;

	private ConcurrentSingleton() {
		if (instance != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use the getInstance function to get the Object!");
		}
	}

	public void doSomething() {
		System.out.println("ConcurrentSingleton.doSomething");
	}

	public static ConcurrentSingleton getInstance() {
		if (instance == null) {// 使用双重检查锁定技术
			synchronized (ConcurrentSingleton.class) {
				if (instance == null) {
					instance = new ConcurrentSingleton();
				}
			}
		}
		return instance;
	}
}

5.懒汉变体

使用静态内部类，也是线程安全的

/**
 * 使用静态内部类实现懒汉单例，而且是线程安全的
 * 
 * @author nathan
 * 
 */
public class HolderSingleton {
	private static class SingletonHolder {
		private static final HolderSingleton INSTANCE = new HolderSingleton();
	}

	public static HolderSingleton getInstance() {
		return SingletonHolder.INSTANCE;
	}
}

6.复杂度+4：接下来考虑序列化

《Effective Java》中作者已经给出了方案，即添加readResolve方法。如下：

/**
 * 可序列化的单件实现（同时是并发安全的懒加载的），但只能在同一个jvm中使用，不能跨jvm
 * 
 * @author nathan
 * 
 */
public class SerializableSingleton implements Serializable {
	private static final long serialVersionUID = 5691590550973506283L;
	private transient String description;

	public void doSomething() {
		description = "SerializableSingleton";
	}

	@Override
	public String toString() {
		return super.toString() + " [description=" + description + "]";
	}

	/**
	 * 必须声明为volatile的
	 */
	private static volatile transient SerializableSingleton instance = null;

	private SerializableSingleton() {
		if (instance != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use the getInstance function to get the Object!");
		}
	}

	public static SerializableSingleton getInstance() {
		if (instance == null) {// 使用双重检查锁定技术
			synchronized (SerializableSingleton.class) {
				if (instance == null) {
					instance = new SerializableSingleton();
				}
			}
		}
		return instance;
	}

	private Object readResolve() {
		// 抛弃反序列化的实例，返回原实例
		return instance;
	}
}

7.复杂度+5：跨jvm序列化

第6中方案作者给出了解决问题的思路，但未真正解决序列化问题。因为它只能在同一个jvm中适应。但是在同一个jvm中序列化单例似乎意义不大。下面是kuajvm的单例实现方式。简单修改6中的readResolve方法即可。

/**
 * 能跨jvm使用的可序列化的单件实现（同时是并发安全、懒加载的）
 * 
 * @author nathan
 * 
 */
public class SerializableSingleton2 implements Serializable {
	private static final long serialVersionUID = 5691590550973506283L;
	private String description;
	private int count;

	public void doSomething() {
		description = "SerializableSingleton2";
		count = 100;
	}

	@Override
	public String toString() {
		return super.toString() + " [description=" + description + ",count="
				+ count + "]";
	}

	public void setCount(int count) {
		this.count = count;
	}

	public int getCount() {
		return count;
	}

	/**
	 * 必须声明为volatile的
	 */
	private static volatile SerializableSingleton2 instance = null;

	private SerializableSingleton2() {
		if (instance != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use the getInstance function to get the Object!");
		}
	}

	public static SerializableSingleton2 getInstance() {
		if (instance == null) {// 使用双重检查锁定技术
			synchronized (SerializableSingleton2.class) {
				if (instance == null) {
					instance = new SerializableSingleton2();
				}
			}
		}
		return instance;
	}

	private Object readResolve() {
		if (instance == null) {// 使用双重检查锁定技术
			synchronized (SerializableSingleton2.class) {
				if (instance == null) {
					instance = this;// 如果是第一次反序列化，则使用该实例，否则不管它
				}
			}
		}
		return instance;
	}

	public static void serialize(String file) throws Exception {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
				new File(file)));
		oos.writeObject(instance);
	}

	public static void antiSerialize(String file) throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
				new File(file)));
		instance = (SerializableSingleton2) ois.readObject();
	}
}

8.复杂度+6：考虑单件的继承

在GOF的《设计模式》中给出了方案，即采用register的方式。但按其书中描述，子类的构造函数必须是公有的，这就违背了单例的初衷。因此必须借助“反射”机制实现对子类的实例化。

9.复杂度+7：再考虑基于继承的单件体系的跨jvm的序列化

（8和9合后的并代码如下）

/**
 * 一个可子类化、可序列化的单件实现
 * 
 * @author nathan
 * 
 */
public class SubableSingleton implements Serializable {
	private String description;
	private int count;

	public void doSomething() {
		description = "SubableSingleton";
		count = 100;
	}

	@Override
	public String toString() {
		return super.toString() + " [description=" + description + ",count="
				+ count + "]";
	}

	public void setCount(int count) {
		this.count = count;
	}

	public int getCount() {
		return count;
	}

	// 以下代码实现单件支持

	private static final long serialVersionUID = 5713856529741473199L;
	private static SingletonHolder holder = null;
	private String name;

	protected SubableSingleton() {
		this(SubableSingleton.class);
	}

	protected SubableSingleton(Class<? extends SubableSingleton> clazz) {
		if (holder.lookup(clazz.getName()) != null) {
			throw new RuntimeException(
					"This is a Singleton Class, please use getInstance function to get the Object!");

		}
		name = clazz.getName();
	}

	/**
	 * 注意：使用synchronized代替DCL进行简单并发控制
	 * 
	 * @param clazz
	 * @return
	 */
	public static synchronized SubableSingleton getInstance(
			Class<? extends SubableSingleton> clazz) {
		if (holder == null) {
			holder = new SingletonHolder();
		}

		SubableSingleton instance = holder.lookup(clazz.getName());

		if (instance == null) {
			try {
				Constructor<? extends SubableSingleton> constructor = clazz
						.getDeclaredConstructor();
				constructor.setAccessible(true);
				instance = constructor.newInstance();
				holder.register(clazz.getName(), instance);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		return instance;
	}

	private synchronized Object readResolve() {
		System.out.println("SubableSingleton.readResolve");
		if (holder == null) {
			holder = new SingletonHolder();
			holder.register(this.name, this);
		}
		return holder.lookup(this.name);
	}

	public static void serialize(String file) throws Exception {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
				new File(file)));
		oos.writeObject(holder);
	}

	public static void antiSerialize(String file) throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
				new File(file)));
		holder = (SingletonHolder) ois.readObject();
	}

	/**
	 * 单例持有类，私有
	 * 
	 * @author nathan
	 * 
	 */
	private static class SingletonHolder implements Serializable {
		private static final long serialVersionUID = -4221190210772287103L;

		private Map<String, SubableSingleton> registry = new HashMap<String, SubableSingleton>();

		public void register(String name, SubableSingleton subableSingleton) {
			registry.put(name, subableSingleton);
		}

		public SubableSingleton lookup(String name) {
			return registry.get(name);
		}

		private synchronized Object readResolve() {
			System.out.println("SingletonHolder.readResolve");
			// 抛弃反序列化的实例，返回原实例
			if (holder == null) {
				holder = this;
			}
			return holder;
		}
	}
}

/**
 * 子类必须在构造函数中调用父类的带参构造函数，完成反反射控制
 * @author nathan
 *
 */
public class SubSingleton extends SubableSingleton {

	private static final long serialVersionUID = 2430773476223417288L;

	protected SubSingleton() {
		super(SubSingleton.class);
	}
}

那么，你还认为单件简单吗？欢迎交流！

参考：

GOF的《设计模式》

《Effective Java》

《单件模式的7种写法》http://www.360doc.com/content/10/1213/09/2703996_77599342.shtml


附：相关单元测试

public class SingletonTest {
	@Test
	public void testSimpleSingleton() {
		Assert.assertEquals(SimpleSingleton.INSTANCE, SimpleSingleton.INSTANCE);
	}

	@Test
	public void testSimpleSingleton2() {
		Assert.assertEquals(SimpleSingleton2.getInstance(),
				SimpleSingleton2.getInstance());
	}

	@Test
	public void testAntiRefSingleton() throws Exception {
		Assert.assertEquals(AntiRefSingleton.instance,
				AntiRefSingleton.instance);

		try {
			Constructor<AntiRefSingleton> constructor = AntiRefSingleton.class
					.getDeclaredConstructor();
			constructor.setAccessible(true);
			constructor.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testLazySingleton() {
		Assert.assertEquals(LazySingleton.getInstance(),
				LazySingleton.getInstance());
	}

	@Test
	public void testConcurrentSingleton() {
		Assert.assertEquals(ConcurrentSingleton.getInstance(),
				ConcurrentSingleton.getInstance());
	}

	@Test
	public void testSubableSingleton() {
		Assert.assertNotNull(SubableSingleton
				.getInstance(SubableSingleton.class));
		Assert.assertTrue(SubableSingleton.getInstance(SubableSingleton.class) instanceof SubableSingleton);
		Assert.assertEquals(
				SubableSingleton.getInstance(SubableSingleton.class),
				SubableSingleton.getInstance(SubableSingleton.class));

		Assert.assertNotNull(SubableSingleton.getInstance(SubSingleton.class));
		Assert.assertTrue(SubableSingleton.getInstance(SubSingleton.class) instanceof SubSingleton);
		Assert.assertEquals(SubableSingleton.getInstance(SubSingleton.class),
				SubableSingleton.getInstance(SubSingleton.class));
	}

	@Test
	public void testSubableSingletonSerialize() throws Exception {
		SubableSingleton instance = SubableSingleton
				.getInstance(SubableSingleton.class);
		SubableSingleton instance2 = SubableSingleton
				.getInstance(SubSingleton.class);
		instance.doSomething();
		instance2.doSomething();

		SubableSingleton.serialize("testSubableSingletonSerialize.jser");
		SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");

		Assert.assertEquals(instance,
				SubableSingleton.getInstance(SubableSingleton.class));
		Assert.assertEquals(instance2,
				SubableSingleton.getInstance(SubSingleton.class));
	}

	@Test
	public void testSubableSingletonSerialize2() throws Exception {

		SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");

		SubableSingleton instance = SubableSingleton
				.getInstance(SubableSingleton.class);
		SubableSingleton instance2 = SubableSingleton
				.getInstance(SubSingleton.class);
		Assert.assertEquals(100, instance.getCount());
		Assert.assertEquals(100, instance2.getCount());

		instance.setCount(20);

		SubableSingleton.antiSerialize("testSubableSingletonSerialize.jser");
		instance = SubableSingleton.getInstance(SubableSingleton.class);
		Assert.assertEquals(20, instance.getCount());
	}

	@Test
	public void testSubableSingletonSerialize3() throws Exception {
		SubableSingleton instance = SubableSingleton
				.getInstance(SubableSingleton.class);
		instance.doSomething();

		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
				new File("testSubableSingletonSerialize.jser")));
		oos.writeObject(instance);

		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
				new File("testSubableSingletonSerialize.jser")));
		SubableSingleton instance2 = (SubableSingleton) ois.readObject();

		Assert.assertEquals(instance, instance2);

	}

	@Test
	public void testSubableSingletonSerialize4() throws Exception {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
				new File("testSubableSingletonSerialize.jser")));
		SubableSingleton instance2 = (SubableSingleton) ois.readObject();

		Assert.assertEquals(100, instance2.getCount());
		instance2.setCount(20);

		ois = new ObjectInputStream(new FileInputStream(new File(
				"testSubableSingletonSerialize.jser")));
		instance2 = (SubableSingleton) ois.readObject();

		Assert.assertEquals(20, instance2.getCount());
	}

	@Test
	public void testSubableSingletonSerialize5() throws Exception {
		SubableSingleton instance = SubableSingleton
				.getInstance(SubSingleton.class);
		SubableSingleton instance2 = SubableSingleton
				.getInstance(SubSingleton.class);
		instance.doSomething();
		instance2.doSomething();

		SubableSingleton.serialize("testSubableSingletonSerialize5.jser");
		SubableSingleton.antiSerialize("testSubableSingletonSerialize5.jser");

		Assert.assertEquals(instance,
				SubableSingleton.getInstance(SubSingleton.class));
		Assert.assertEquals(instance2,
				SubableSingleton.getInstance(SubSingleton.class));

		Assert.assertEquals(100, instance2.getCount());
	}

	@Test
	public void testSerializableSingletonInOneJvm() throws IOException,
			ClassNotFoundException {
		Assert.assertEquals(SerializableSingleton.getInstance(),
				SerializableSingleton.getInstance());
		SerializableSingleton singleton = SerializableSingleton.getInstance();
		singleton.doSomething();
		System.out.println(singleton);

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(singleton);

		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bais);
		SerializableSingleton clone = (SerializableSingleton) ois.readObject();
		System.out.println(clone);
		Assert.assertEquals(singleton, clone);

		clone.doSomething();
	}

	/**
	 * 在同一个jvm中，序列化后再反序列化对单件来说是无效的，jvm中始终使用的是最初创建的那个单件实例
	 * 
	 * @throws Exception
	 */
	@Test
	public void testSerializableSingleton2InOneJvm() throws Exception {
		Assert.assertEquals(SerializableSingleton2.getInstance(),
				SerializableSingleton2.getInstance());
		SerializableSingleton2 singleton = SerializableSingleton2.getInstance();
		singleton.doSomething();
		Assert.assertEquals(SerializableSingleton2.getInstance().getCount(),
				100);

		SerializableSingleton2.serialize("SerializableSingleton2.jser");
		// 序列化后改变实例数据
		SerializableSingleton2.getInstance().setCount(30);
		// 反序列化,实际上并未使用反序列化出来的实例，而是继续使用原来的实例，因为在同一个Jvm中
		SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
		// 因此这里的值是30,不是序列化时候的100
		Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 30);

		// 改变实例数据
		SerializableSingleton2.getInstance().setCount(20);

		// 再反序列化
		SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
		Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 20);
	}

	/**
	 * 在另一个jvm中启动反序列化<br>
	 * 注意：请先执行测试testSerializableSingleton2InOneJvm，再执行该测试
	 * 
	 * @throws Exception
	 */
	@Test
	public void testSerializableSingleton2NotInOneJvmRead() throws Exception {
		// 反序列化,并创建单件实例，此后在该jvm中将一直使用该实例
		SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
		// 因此这里的值是序列化时候的100
		Assert.assertEquals(SerializableSingleton2.getInstance().getCount(),
				100);

		// 改变实例数据
		SerializableSingleton2.getInstance().setCount(20);

		// 再反序列化
		SerializableSingleton2.antiSerialize("SerializableSingleton2.jser");
		Assert.assertEquals(SerializableSingleton2.getInstance().getCount(), 20);
	}

}


塘外人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Head First 设计模式 （五） 单件模式（Singleton pattern） C++实现
04-10
Head First 设计模式 （五） 单件模式（Singleton pattern） C++实现
Head First 设计模式——chapter5 单件模式C++实现
雪招在等开花
04-14 707
单件模式： 有些类只应该存在一个实例。如线程池，缓存，注册表等对象。单件模式能确保一个类只有一个实例，并提供一个全局访问点。 全局变量？ 必须在程序刚开始就创建对象，而单件模式可以在需要时才创建对象。 实现： 1.构造函数声明为私有。 2.声明静态实例对象。 3.提供实例的全局访问点，当需要实例时，向类查询，它会返回静态实例对象。查询时可以采用延迟实例化的方式创建单件，这对于资源敏感的对象十分重要。 懒汉式：非线程安全。程序调...
C++设计模式——单件模式（singleton pattern）
净无邪博客
08-30 1470
一、原理讲解 由于单件模式也称为单例模式，分为懒汉式单例模式和饿汉式单例模式，两者主要区别是类对象的返回是在编译时创建？还是调用时才创建？其中，懒汉式单例模式是在程序调用时才创建，而饿汉式单例模式是在程序编译时期创建类实例。懒汉式是非线程安全的，而饿汉式是线程安全的。因为项目中用懒汉式比较多，所以本文主要总结的是懒汉式单例模式。饿汉式单例模式可以参考博主这篇文章：单例模式（饿汉式） 1.1意图 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 1.2应用场景 当一个类只有一个实例，而且客户端可以从一
Head First 设计模式——单件模式(Singleton Pattern)
ZJU_Sutton的专栏
05-17 1116
单件模式（Singleton Pattern) 确保一个类只有一个实例，并提供一个全局访问点 单件模式确保程序中一个类最多只有一个实例。我们在程序中会遇到这种情况如：线程池，缓存，对话框，打印机，显卡等设备驱动程序。这些类对象只能有一个实例，如果制造多个实例，就会导致许多问题产生。 经典的单件模式实现： #include using namespace std; class
简单理解-Head First 设计模式
走一段令人留恋的路，做一个不负自己的人
12-10 3281
我们知道四人组的《设计模式》共介绍了23种，并且将其分成3类，分别是：创建型、结构型、行为型，如下所示： - **创建型**：**5个**。工厂方法模式、抽象工厂模式、Builder模式（Retrofit）、单例模式（类初始化）、原型模式 - **结构型**：**7个**。适配器模式、装饰模式（File操作）、代理模式（静态代理——代理对象内部操作委托对象、动态代理——代理对象里面不指定特定的委托对象，更加灵活）、组合模式、桥接模式、外观模式、享元模式 - **行为型**：**11个**。观察者模式
【设计模式】《Head First 设计模式》读书笔记——单件模式
terry_sdy的博客
11-09 291
单件模式： 确保一个类只有一个实例，并提供一个全局访问点。 问题简单描述： 像线程池、缓存、对话框等的对象我们只需要一个，如果出现多个对象会出现许多问题。如果用全局变量，假如是一个非常耗费资源的对象，但是程序的一次执行中一直没有用到这个对象就形成了浪费。 解决思路： 提供一个私有构造器、一个静态方法和一个静态变量。私有构造器确保不被其他类构造，通过静态方法来实例化对象，静态变量用来判断类
软件设计模式——单件模式 Singleton Pattern
qq_36911138的博客
10-23 300
单件模式 （Singleton Pattern）——独一无二的对象 定义：确保一个类只有一个实例，并提供一个全局访问点。 类图： 在JAVA中，包含私有的构造器、一个静态方法、一个静态变量。 为了处理多线程带来的混乱：将getInstance()变成同步（synchronized）方法，即可避免多线程灾难。 public class Singleton{ privat...
《Head First 设计模式》（五）：单例模式
xueguchen的博客
07-20 8172
1. 定义 单例模式：确保一个类只有一个实例，并提供一个全局访问点 要素： 单例类只能有一个实例 单例类必须自行创建自己的实例 单例类必须自行向整个系统提供这个实例 单例模式的简单实现： package com.jbp.designpattern.singleton; /** * @ClassName: Singleton * @description: 单例 * @author: JiangBeiPing * @create: 2021-07-20 11:15 * @Version:
设计模式读书笔记：Singleton（单件模式）
panshiqu的专栏
06-26 716
意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点 注意： 1.静态成员变量及静态成员方法 2.使用惰性初始化，它的返回值直到被第一次访问时才创建和保存 3.构造器是受保护的，试图直接实例化Singleton将得到一个编译时的错误信息
Head First设计模式C++实现--第五章：单件（Singleton）模式
FightForProgrammer的专栏
06-28 885
单件（Singleton）模式
[创建型模式] head first 设计模式之单件模式(Singleton)
08-13
NULL 博文链接：https://jacky-dai.iteye.com/blog/1927936
Head First 设计模式（中文版）
03-02
《Head First设计模式》(中文版)共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、...
Head First设计模式.pdf (高清)
05-02
《Head First设计模式》(中文版)共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、...
Head First设计模式(中文,无水印,完整版)
06-26
第12章介绍如何将两个以上的设计模式结合起来成为新的设计模式（例如著名的MVC模式），作者称其为复合设计模式（这是作者自创的名称，并非四人组的标准名词），第13章介绍如何进一步学习设计模式，如何发觉新的设计...
Ubuntu11.10下解决 jmap等jdk工具attach pid错误
@塘外人
02-27 9696
1.错误案例 nathan@ubuntu:~/Downloads$ jmap -heap 3991 Attaching to process ID 3991, please wait... Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process
Build Number Maven Plugin的使用方法
@塘外人
08-23 7216
Build Number Maven Plugin的使用方法 1. Build Number Maven Plugin用于获取svn的版本及分支目录，可以将它们用于应用中 2.先在maven的setting.xml中添加仓库，用于下载该插件： codeh
【读书笔记】TiJava——泛型
@塘外人
08-20 5111
类型参数推断 •使用泛型类时，必须在创建对象时指定类型参数。 •使用泛型方法时，不需要指定类型参数。 •方法的泛型返回值（被认为是一个Object类型）作为参数传给另一个方法时，不会执行类型推断，不能编译，除非使用显示类型说明。 擦除 •ArrayList.class== ArrayList.class==ArrayList.class •在泛型代码内部，无法获得任何有
Java中WeakReference、WeakHashMap、SoftReference、ReferenceQueue的作用和使用场景
@塘外人
08-30 4948
详见以下测试代码及其注释： package test; import static junit.framework.Assert.assertFalse; import static junit.framework.Assert.assertNotNull; import static junit.framework.Assert.assertNull; import static jun
基于 Abstract Factory 模式与 Singleton 模式实现一个简单的邮件生成程序
最新发布
03-24
以下是一个基于 Abstract Factory 模式与 Singleton 模式实现的简单邮件生成程序的示例代码： ``` // 邮件接口 interface Mail { void send(); } // 邮件工厂接口 interface MailFactory { Mail createMail(); }...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值