工厂模式+单例模式

工厂的三种模式：目的都是解耦

简单工厂

工厂是一个类：生产各种各样产品；不同类实现接口；业务全部在fractory中，违反了开闭原则。

 使用在业务简单的情况下。

工厂方法（如果工厂的产品全部属于同一个等级结构，则属于工厂方法。）

定义一个创建对象的工厂接口，让子类决定实例化哪一个类，将实际工作交给子类

例子：

工厂是一个接口，produceTrunk()  ，实现创建不同卡车类

卡车也是一个接口，实现不同卡车类

将不同卡车的业务逻辑抽离出fractory

优点

符合开闭原则，每增加一种产品，只需要增加相应具体的产品类和工厂子类。

符合单一职责原则，每个具体工厂类只负责创建对应的产品。

缺点

在增加一个新产品时，需要增加一个产品类和一个具体的子工厂,每个工厂生产一种产品，太过单一。

 

抽象工厂（如果工厂的产品来自多个等级结构，则属于抽象工厂模式）

抽象工厂角色：具体工厂必须时间的接口。

具体工厂角色：和具体业务逻辑相关的代码，创建对应的具体产品的对象。

抽象工厂：producetrunk();  producesedan();

具体工厂:宝马工厂（宝马轿车、宝马卡车）奥迪工厂（奥迪轿车、奥迪卡车）

抽象产品：卡车、轿车

具体产品：宝马卡车，宝马轿车，奥迪卡车，奥迪轿车

单例模式

概念：包含一个被称为单例的特殊类。

特点：单例类只能有一个实例；单例类必须自己创建自己的唯一实例；单例类必须给所有其他对象提供这一实例。

实现：private 构造类避免了外部类对此类进行实例化

场景需求：

1.计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

2.创建的一个对象需要消耗的资源过多，比如IO与数据库的连接等。

如何选择：

饿汉式是线程安全的，但是类加载就创建对象。如果在一个工厂模式下，缓存了很多实例，就得考虑效率问题，因为这个类一加载就把所有实例一起创建了（不管用不用）；懒汉式优点是延时加载，缺点是需要用同步。看实际需求选择。

优点：在内存中只有一个实例，减少了内存开销，尤其是频繁创建和销毁实例（工具类）；避免对资源的多重占用（比如写文件操作）

缺点：扩展很困难（private修饰的方法无法继承，不能再扩展）

饿汉式单例

在类加载初始化时就创建好一个静态的对象供外部使用，除非系统重启，这个对象不会改变，本身是线程安全的。

package single;
public class singlethon {
    //构造方法私有化
    singlethon() {}
    private static singlethon single=new singlethon();
    //对外提供调用
    public static singlethon getinstance() {
        return single;
    }
}

懒汉式单例

类加载的时候不创建对象，只有在使用的时候才创建，但是在多线程条件下，是线程不安全的。

package single;

import javax.sql.rowset.spi.SyncFactory;

public class single2 {
    private single2() {}
    private static single2 single=null;
    //同步锁，一个线程执行时，其他线程处于等待
    synchronized public static single2 getinstance() {
        if(single==null) {
            //线程不安全
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            single=new single2();
        }
        return single;
    }
}
//多线程，CPU 交替执行有先后

可以用同步锁解决线程不安全问题，但是加锁会降低效率；为提高效率，减小代码同步范围。

package single;

import javax.sql.rowset.spi.SyncFactory;

public class single2 {
    private single2() {}
    private static single2 single=null;
    //同步锁，一个线程执行时，其他线程处于等待
     public static single2 getinstance() {
        //双重检索
             if(single==null) {
                    //线程不安全
                 synchronized(single2.class) {
                     if(single==null) {
                         single=new single2();
                     }
                } 
             }
        return single;
    }
}
//多线程，CPU 交替执行有先后

静态内部类

package single;
public class single3 {
    private single3() {}
    //外部类被加载，内部类没有被加载，除非主动使用
    private static class insideclass {
        private static single3 single=new single3();
    }
    
    public static single3 getinstance() {
        return insideclass.single;
    }
}

 

转载于:https://www.cnblogs.com/NeverGiveUp0/p/11113029.html