一:单例模式分为懒汉模式、饥汉模式、双重校验锁、静态内部类、枚举
1.懒汉模式:
/** * @author hz * @version 1.0 */ public class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance(){ //如果还没有被实例化过,就实例化一个,然后返回 if(instance == null){ instance = new Singleton(); } return instance; } }
2.饿汉模式:
/** * @author hz * @version 1.0 */ public class Singleton { //类加载的时候instance就已经指向了一个实例 private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return instance; } }
3.双重校验锁:
/** * @author hz * @version 1.0 */ public class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance(){ if(instance == null){ synchronized (Singleton.class){ if(instance == null){ instance = new Singleton(); } } } return instance; } }
4.枚举:
/** * @author hz * @version 1.0 */ public enum Singleton { INSTANCE; }
3.单例模式的优缺点:
以上我们具体的对比了几种单例模式的实现方式,那么单例模式有哪些优缺点呢?
优点:
单例模式可以保证内存里只有一个实例,减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点,可以优化和共享资源的访问。
缺点:
单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则。
在并发测试中,单例模式不利于代码调试。在调试过程中,如果单例中的代码没有执行完,也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则。
二.工厂模式
- 简单工厂(SimpleFactory):是简单工厂模式的核心,负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。
- 抽象产品(Product):是简单工厂创建的所有对象的父类,负责描述所有实例共有的公共接口。
- 具体产品(ConcreteProduct):是简单工厂模式的创建目标。
/** * @author hz * @version 1.0 */ public class Client { //抽象产品 public interface Product { void show(); } //具体产品:ProductA static class ConcreteProduct1 implements Product { public void show() { System.out.println("具体产品1显示..."); } } //具体产品:ProductB static class ConcreteProduct2 implements Product { public void show() { System.out.println("具体产品2显示..."); } } final class Const { static final int PRODUCT_A = 0; static final int PRODUCT_B = 1; static final int PRODUCT_C = 2; } static class SimpleFactory { public static Product makeProduct(int kind) { switch (kind) { case Const.PRODUCT_A: return new ConcreteProduct1(); case Const.PRODUCT_B: return new ConcreteProduct2(); } return null; } } }
对于产品种类相对较少的情况,考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数,不需要关心如何创建对象的逻辑,可以很方便地创建所需产品。
对于某个产品,调用者清楚地知道应该使用哪个具体工厂服务,实例化该具体工厂,生产出具体的产品来,那么我们可以采用工厂方法模式,如JAVA中的Colletion中的iterator() 方法;
2.抽象工厂模式
/** * @author hz * @version 1.0 */ public class FarmTest { public static void main(String[] args) { try { Farm f; Animal a; Plant p; //读取相应的配置信息,用于生产工厂 f = (Farm) ReadXML.getObject(); a = f.newAnimal(); p = f.newPlant(); a.show(); p.show(); } catch (Exception e) { System.out.println(e.getMessage()); } } } //抽象产品:动物类 interface Animal { public void show(); } //具体产品:马类 class Horse implements Animal { public Horse() { System.out.println("具体马类的生成"); } public void show() { System.out.println("执行马类的相应操作"); } } //具体产品:牛类 class Cattle implements Animal { public Cattle() { //具体牛类的生成 System.out.println("具体牛类的生成"); } public void show() { System.out.println("执行马类的相应操作"); } } //抽象产品:植物类 interface Plant { public void show(); } //具体产品:水果类 class Fruitage implements Plant { public Fruitage() { System.out.println("具体水果类生成"); } public void show() { System.out.println("执行水果类的相应操作"); } } //具体产品:蔬菜类 class Vegetables implements Plant { public Vegetables() { System.out.println("具体蔬菜类生成"); } public void show() { System.out.println("执行蔬菜类的相应操作"); } } //抽象工厂:农场类 interface Farm { public Animal newAnimal(); public Plant newPlant(); } //具体工厂:农场类1 class SGfarm implements Farm { public Animal newAnimal() { System.out.println("新牛出生!"); return new Cattle(); } public Plant newPlant() { System.out.println("蔬菜长成!"); return new Vegetables(); } } //具体工厂:农场类2 class SRfarm implements Farm { public Animal newAnimal() { System.out.println("新马出生!"); return new Horse(); } public Plant newPlant() { System.out.println("水果长成!"); return new Fruitage(); } }
import org.w3c.dom.*; import javax.xml.parsers.*; import java.io.File; /** * @author hz * @version 1.0 */ public class ReadXML2 { public static Object getObject() { try { DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = dFactory.newDocumentBuilder(); Document doc; doc = builder.parse(new File("src/AbstractFactory/config.xml")); NodeList nl = doc.getElementsByTagName("className"); Node classNode = nl.item(0).getFirstChild(); String cName = "AbstractFactory." + classNode.getNodeValue(); System.out.println("新类名:" + cName); Class<?> c = Class.forName(cName); Object obj = c.newInstance(); return obj; } catch (Exception e) { e.printStackTrace(); return null; } } }
- 1.可以在类的内部对产品族中相关联的多等级产品共同管理,而不必专门引入多个新的类来进行管理。
- 2.当需要产品族时,抽象工厂可以保证客户端始终只使用同一个产品的产品组。
- 3.抽象工厂增强了程序的可扩展性,当增加一个新的产品族时,不需要修改原代码,满足开闭原则。
-
缺点:
当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。
根据以上对抽象工厂模式的分析,我们可以知道抽象工厂模式通常适用于以下场景:
- 当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
- 系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
- 系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。