Question

在Java中，我创建了一个单例类，如下所示：

public class Singleton 
{   
    private Singleton() { print("Singleton Constructor"); }
    private static Singleton pointer = new Singleton();//static here so only one object 
    public static Singleton makeSingleton()
    {
        return pointer;
    }

    public static void main (String args[]) 
    {
        Singleton nuReference = Singleton.makeSingleton();
        if(nuReference == pointer)
        {
            print("Both are references for same object.");
        }
    }
}

此处，仅返回对已创建的Singleton类对象的引用。如何创建一个类，以便只允许创建该类的四个对象？我可以使用这个Singleton类吗？还是我必须从头开始制作它？

哦，print（）是我的自定义方法。与System.out.println()的工作方式相同，只需更少的击键次数：）

Answer 1

这应该有效：

public class Singleton
{
      private Singleton()
      {
            print("Constructor");
      }

      private static Singleton instances[] = new Singleton[4];

      private static Boolean initiated = false;

      public static Singleton getInstance(int index)
      {
          tryInitiate();

          if(instances[index] == null)
          {
              instances[index] = new Singleton();
          }

          return instances[index];
      }

      private static Boolean tryInitiate()
      {
          if(initiated) return false;

          for (int i = 0; i < instances.length; i++)
          {
              instances[i] == null;
          }

          initiated = true;

          return true;
      }
}

您可以在启动期间实例化对象，而不是使用“null”启动对象。但这样只会实例化所需的对象。

Answer 2

添加静态int count = numyouwant;对于你的代码，每次调用静态创建方法时，将计数减少1.更重要的是，在创建方法中调用私有构造函数之前检查count是否为0

Answer 3

根据定义，单身人士只有一个自己的实例。你的建议听起来好像你会更好地使用Factory类型的范例，以及一个计数器/限制器（内置于该类中）。

创建一个包含计数器的Factory类（或用于存储已创建对象的列表，如果您愿意）和createObject方法。在该方法中，使用您的逻辑来确定是否有太多对象，因此您可以限制对象的创建。

以下是Factory的示例，其中包含已创建对象的最大限制。为简单起见，有问题的对象是一个内部类。

public class Factory {
private final int maxObj = 4;

public class MyObject {
    MyObject() { print("Constructor"); }
}

private List<MyObject> objects = new List<Object>();

// Returns new MyObject if total MyObject 
// count is under maxObj, null otherwise
public MyObject makeObject() {
    if (objects.length() >= maxObj)
        return null;
    MyObject obj = new MyObject();
    objects.add(obj);
    return obj;
}
}

Answer 4

创建变量x

每次调用makeSingleton时都会增加其值

如果x <4则返回指针

否则返回null

Answer 5

创建一个List<Singleton> mySingletons;字段和一个字段int singletonCounter=0;

在makeSingleton（）方法中，如果它等于4，则将1加到计数器返回null或返回4的单例。如果计数器小于4，则创建一个单例。

Answer 6

我的问题是如何创建一个类，以便只允许创建该类的4个对象。任何帮助？我可以使用这个Singleton类吗？还是我必须从头开始制作它？

我相信你想要保留一个类的对象池。你不能通过 Singleton 类来完成它，根据定义它应该返回它唯一的实例。

建议阅读：

Answer 7

您可以添加同一对象的4个实例的队列，并管理队列/出列操作。

注意：听起来您应该为这些操作应用线程安全。

Answer 8

我用Thread Safty创建了一个

import java.util.ArrayList;
import java.util.List;

public class SingletonLimit{
    
    private List<SingletonLimit> inst_Obj= new ArrayList<>();
    private static final int maxLimit=4;
    
    private SingletonLimit(){
    }
    
    public SingletonLimit getInstance(){
        if(inst_Obj.size()>=maxLimit)
                return null;
        SingletonLimit singleLimit=null;        
        synchronized(SingletonLimit.class){
            singleLimit= new SingletonLimit();
            inst_Obj.add(singleLimit);
        }
        return singleLimit;
    }   
    
}

如何扩展单例类以处理特定数量的对象

8 个答案: