java单列如何取多个实例

Java单例模式是设计模式中的一种，它提供了一种最好的方式来创建一个对象的单个实例，同时确保这个对象能被系统中的所有线程访问。 但是，如果你需要在Java中从单例类获取多个实例，那么你需要改变你的设计方法或者使用其他的设计模式，如工厂模式或原型模式。在某些情况下，你可能需要创建一个"多例"类，这是一个可以创建固定数量实例的类，而不是单一实例。

让我们详细讨论一下这些方法。

一、工厂模式

工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪个类。工厂方法让类的实例化推迟到子类。在这种情况下，如果你需要多个不同的实例，你可以使用工厂方法来生成它们。

首先，你需要创建一个接口：

public interface Shape {
   void draw();
}

然后，创建实现接口的实体类：

public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Circle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

最后，创建一个工厂，基于给定的信息，生成实体类的对象。

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();
      }
      return null;
   }
}

这样，你就可以使用这个工厂来获取你需要的任何实例。

二、原型模式

原型模式是创建型设计模式之一，它通过复制现有的实例来创建新的实例，而不是新建实例。这种方法在Java中很常见，因为Java提供了clone()方法，可以在运行时动态地复制对象。

首先，定义一个实现Cloneable接口的抽象类：

public abstract class Shape implements Cloneable {
   private String id;
   protected String type;
   abstract void draw();
   public String getType(){
      return type;
   }
   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public Object clone() {
      Object clone = null;
      try {
         clone = super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return clone;
   }
}

然后，创建具体的类扩展上述抽象类：

public class Rectangle extends Shape {
   public Rectangle(){
     type = "Rectangle";
   }
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Circle extends Shape {
   public Circle(){
     type = "Circle";
   }
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

最后，创建一个类，从数据库中获取实体类，并把它们存储在一个Hashtable中。

public class ShapeCache {
   private static Hashtable<String, Shape> shapeMap 
      = new Hashtable<String, Shape>();
   public static Shape getShape(String shapeId) {
      Shape cachedShape = shapeMap.get(shapeId);
      return (Shape) cachedShape.clone();
   }
   // 对每种形状都运行数据库查询，并创建该形状
   // shapeMap.put(shapeKey, shape);
   // 例如，我们要添加三种形状
   public static void loadCache() {
      Circle circle = new Circle();
      circle.setId("1");
      shapeMap.put(circle.getId(),circle);
      Rectangle rectangle = new Rectangle();
      rectangle.setId("2");
      shapeMap.put(rectangle.getId(), rectangle);
   }
}

这样，你就可以使用ShapeCache类从数据库中获取信息，并更新表格。

三、多例模式

多例模式（Multiton Pattern）是一种设计模式，它提供了一种方式，可以在系统中创建一个类的多个实例，但是这些实例的数量是有限制的。

这个模式其实是单例模式的一个更一般化的版本。在多例模式中，你可以定义一个最大实例数量，当请求超过这个数量时，会抛出一个异常。

首先，定义一个包含静态的实例的类：

public class Multiton {
   private static final HashMap<String,Multiton> instances = new HashMap<>();
   private Multiton() {
   }
   public static synchronized Multiton getInstance(String key) {
      if(instances.size() > MAX_INSTANCES){
         throw new RuntimeException("Too many instances");
      }
      if (!instances.containsKey(key)) {
         instances.put(key, new Multiton());
      }
      return instances.get(key);
   }
}

这样，你就可以根据需要创建多个实例，但是当你试图创建更多的实例时，会抛出一个异常。

总结：

在Java中，单例模式是一种非常有用的设计模式，但是当你需要多个实例时，你需要转向其他的设计模式，如工厂模式、原型模式或多例模式。理解和选择合适的设计模式是一个重要的编程技能。

java单列如何取多个实例

相关问答FAQs：