单例模式

单例模式是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

• 只有一个实例的意思是，在整个应用程序中，只存在该类的一个实例对象，而不是创建多个相同类型的对象。

• 全局访问点的意思是，为了让其他类能够获取到这个唯一实例，该类提供了一个全局访问点（通常是一个静态方法），通过这个方法就能获得实例。

单例模式结构

• 私有的构造函数：防止外部代码直接创建类的实例

• 私有的静态实例变量：保存该类的唯一实例

• 公有的静态方法：通过公有的静态方法来获取类的实例

单例模式通用代码

单例模式的实现方式有多种，包括懒汉式、饿汉式等。

• 饿汉式指的是在类加载时就已经完成了实例的创建，不管后面创建的实例有没有使用，先创建再说，所以叫做 “饿汉”。

• 而懒汉式指的是只有在请求实例时才会创建，如果在首次请求时还没有创建，就创建一个新的实例，如果已经创建，就返回已有的实例，意思就是需要使用了再创建，所以称为“懒汉”。

饿汉模式

//单例类通过'getSingleton(获取实例)'方法进行定义，让客户端全局获得该对象实例
public class Singleton{

// 保存单例实例成员变量必须被声明为静态类型
private static final Singleton singleton=new Singleton（）；

// 单例的构造函数必须永远是私有类型，以防止使用`new`运算符直接调用构造方法。限制产生多个对象
private Singleton（）{
	}
	
//通过该方法获得实例对象
public static Singleton getSingleton（）{
return singleton；
	}
//类中其他方法，尽量是static
public static void doSomething（）{
	}
}

懒汉模式

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // 私有构造方法，防止外部实例化
    }
    // 使用了同步关键字来确保线程安全, 可能会影响性能
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在懒汉模式的基础上，可以使用双重检查锁来提高性能。

public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {
        // 私有构造方法，防止外部实例化
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

有上限的多例模式，它是单例模式的一种扩展，采用有上限的多例模式，我们可以在设计时决定在内存中有多少个实例，方便系统进行扩展，修正单例可能存在的性能问题，提供系统的响应速度。

public class Singleton{
	
	private static int maxNum=3;//最多产生3个实例数量
	
	private static ArrayList<Singleton> List=new ArrayList<Singleton>();
	
	private static int count=0;//当前皇帝序列号
	
	static{
	for（int i=0;i<maxNum;i++）{
		List.add(new Singleton());
		}
	}
	
	private Singleton(){
	
	}
	
	private static Singleton getInstance(){
	Random random=new Random();
	count=random.nextInt(maxNum);
	return List.get(count);
	}
	

}

单例模式适用场景

1. 如果程序中的某个类对于所有客户端只有一个可用的实例， 可以使用单例模式。

   单例模式禁止通过除特殊构建方法以外的任何方式来创建自身类的对象。 该方法可以创建一个新对象， 但如果该对象已经被创建， 则返回已有的对象。

2. 如果你需要更加严格地控制全局变量， 可以使用单例模式。

   单例模式与全局变量不同， 它保证类只存在一个实例。 除了单例类自己以外， 无法通过任何方式替换缓存的实例。

识别方法： 单例可以通过返回相同缓存对象的静态构建方法来识别。

单例模式优缺点

单例模式优点：

• 你可以保证一个类只有一个实例。

• 你获得了一个指向该实例的全局访问节点。

• 仅在首次请求单例对象时对其进行初始化。

单例模式缺点：

• 违反了单一职责原则。 该模式同时解决了两个问题。

• 单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。

• 单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。

• 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。

• 单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。

练手题目

题目描述

小明去了一家大型商场，拿到了一个购物车，并开始购物。请你设计一个购物车管理器，记录商品添加到购物车的信息（商品名称和购买数量），并在购买结束后打印出商品清单。（在整个购物过程中，小明只有一个购物车实例存在）。

输入描述

输入包含若干行，每行包含两部分信息，分别是商品名称和购买数量。商品名称和购买数量之间用空格隔开。

输出描述

输出包含小明购物车中的所有商品及其购买数量。每行输出一种商品的信息，格式为 “商品名称 购买数量”。

输入示例

Apple 3 Banana 2 Orange 5

输出示例

Apple 3 Banana 2 Orange 5

提示信息

本道题目请使用单例设计模式, 使用私有静态变量来保存购物车实例。 使用私有构造函数防止外部直接实例化。

题解

1.简单单例模式实现。

import java.util.Scanner;
import java.util.ArrayList;

class ShoppingCart {
    
    private static ShoppingCart instance = new ShoppingCart();
    private static ArrayList<String> productNames = new ArrayList<>();
    private static ArrayList<Integer> productQuantities = new ArrayList<>();
    
    private ShoppingCart() {
        
    }
    
    public static ShoppingCart getInstance() {
		    
        return instance;
    }
    
    public void Add(String name, int quantity) {
        productNames.add(name);
        productQuantities.add(quantity);
        System.out.println(name + " " + quantity);
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = ShoppingCart.getInstance();
        Scanner scanner = new Scanner(System.in);
        
        String inputLine;
        while (scanner.hasNextLine()) {
            inputLine = scanner.nextLine();
            
            if ("exit".equalsIgnoreCase(inputLine)) {
                break;
            }

            String[] parts = inputLine.split(" ");
            
            if (parts.length == 2) {
                String name = parts[0];
                int quantity;
                
                try {
                    quantity = Integer.parseInt(parts[1]);
                    cart.Add(name, quantity);
                } catch (NumberFormatException e) {
                    System.out.println("输入错误，请重新输入");
                }
            } else {
                System.out.println("输入错误，请重新输入");
            }
        }
        
        scanner.close();
    }
}

2.在懒汉模式的基础上，可以使用双重检查锁来提高性能。

import java.util.Scanner;  
import java.util.ArrayList;  

class ShoppingCart {
    // 购物车类的单例实例变量，使用volatile关键字确保线程安全
    private static volatile ShoppingCart instance;
    // 存储商品名称
    private static ArrayList<String> productNames = new ArrayList<>();
    // 存储商品数量
    private static ArrayList<Integer> productQuantities = new ArrayList<>();
    
    // 私有构造函数，防止外部直接创建ShoppingCart对象
    private ShoppingCart() {
        
    }
    
    // 获取购物车单例实例的方法，确保线程安全
    public static ShoppingCart getInstance() {
        if (instance == null) {
            synchronized (ShoppingCart.class) {
                if (instance == null) {
                    instance = new ShoppingCart();
                }
            }
        }
        return instance;
    }
    
    // 添加商品到购物车的方法
    public void Add(String name, int quantity) {
        productNames.add(name); 
        productQuantities.add(quantity); 
        System.out.println(name + " " + quantity);
    }
}

public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = ShoppingCart.getInstance(); 
        Scanner scanner = new Scanner(System.in);  
        
        String inputLine;
        // 循环读取用户输入，直到用户输入"exit"
        while (scanner.hasNextLine()) {
            inputLine = scanner.nextLine();
            
            if ("exit".equalsIgnoreCase(inputLine)) {
                break;
            }
            
            // 使用空格分割输入的字符串，获取商品名称和数量
            String[] parts = inputLine.split(" ");
            
            // 确保输入格式正确，即包含两个部分：商品名称和数量
            if (parts.length == 2) {
                // 商品名称
                String name = parts[0];  
                // 商品数量
                int quantity; 
                
                try {
                    // 将第二部分转换为整数
                    quantity = Integer.parseInt(parts[1]);
                    cart.Add(name, quantity);  
                } catch (NumberFormatException e) {
                    // 如果转换失败，输出错误信息
                    System.out.println("转换失败，请重新输入");
                }
            } else {
                // 如果输入格式不正确，输出错误信息
                System.out.println("如果输入格式不正确，请重新输入");
            }
        }
        
        scanner.close();
    }
}