Question

我希望在整个应用程序生命周期中只有5个类的实例。我怎样才能做到这一点？如果可能，请提供示例代码。

Answer 1

由于单身人士应使用枚举（参见“有效的Java”）：

public enum FiveInstance {

  INSTANCE1, INSTANCE2, INSTANCE3, INSTANCE4, INSTANCE5;

  public void anyMethod() {}

}

Greetz GHad

Answer 2

工厂模式可能是你的朋友。一个（虚构的，不是线程安全的，因此非常简单）的例子来说明这种方法：

public static MartiniFactory {

   private static int olives = 100;  // you asked for '5' but 100 is more realistic
                                     // for this example.

   public static Drink createMartini() throws OutOfOlivesException {
     if (olives > 0) {
       olives--;
       return new Martini(new Gin(4), new Vermouth(1), new Olive());
     else {
       throw new OutOfOlivesException();
     }
   }

   // forgot to mention, only the factory (=bar) is able to create Martinis, so:
   private class Martini {
      Martini(Ingredient... ingredients) {
        // ...
      }
      // ....
   }

}

修改

许可证示例并不太好 - 所以我将其移动到了一个域，该域期望工厂创建的对象不会在不注意工厂的情况下返回和销毁。当没有剩下的橄榄时，酒吧不能创造马提尼酒，并且在消费后它肯定不希望饮料回来; - ）

编辑2 当然，只有工厂可以创建Instances（= Drinks）。（不保证，增加的内部私人课程符合这一要求，没有手头的IDE可以快速测试..随意评论或编辑）

Answer 3

查看static关键字。

Answer 4

class Sample
{
   private static int i = 0;

   private Sample()
   {
   } 

  public static Sample CreateInstance()
   {
      if(i <5)
      {
          i++;
          return new Sample();
      } 

      else
        throw new Exception("Can not create more then 5 instance of this class");  
   }

}

Answer 5

创建一个名为howMany的静态字段，每次调用构造函数时都会递增。

howMany = =时5，拒绝创建对象。

Answer 6

public class FiveInstance {
    private static int instanceCount = 0;
    private FiveInstance(){
    }
    public static FiveInstance getNewInstance() throws InstanceExceededException{
        if(instanceCount < 5){
            instanceCount++;
            return new FiveInstance();
        }else{
            throw new InstanceExceededException();
        }
    }
}

Answer 7

创建私人static成员以计算class的实例。然后，确保您的类的每个构造函数都递增此static变量并测试溢出。如果你有多个构造函数，我建议你让一个构造函数实现这个行为，其他的应该调用它。尝试创建第六个实例时构造函数的行为取决于您。也许你想抛出一个Exception。

Answer 8

您可以尝试使用C＃编写代码，但您可以基本了解如何完成。

public  class MultiTone
    {
        private static MultiTone _cache;
        private static int _counter=5;
        MultiTone()
        {

        }
        public static MultiTone GetInstance()
        {
           if(_counter==0)
           {
              return _cache ?? (_cache = new MultiTone());
           }
            _counter--;
            return new MultiTone();
        }
    }

请注意，此类不适用于多线程环境。

Answer 9

我想你不能。如果有人想要创建或销毁实例，你可以强制使用这些静态方法：

import java.util.*;

public class Fiveton {

    public final static int MAX_INSTANCES = 5;

    private static List<Fiveton> instances = new ArrayList<Fiveton>();


    private Fiveton() { }


    public static Fiveton getInstance() {
        if (instances.size()>=MAX_INSTANCES) throw new RuntimeException("Hey! You've reached the maximum of instances: " + MAX_INSTANCES);
        Fiveton instance = new Fiveton();
        instances.add(instance);
        return instance;
    }

    public static void destroy(Fiveton instance) {
        instances.remove(instance);
    }

}

问题是方法破坏。您无法确定某人是否仍在引用已销毁的对象。

Answer 10

作为Singleton的扩展，有一种称为Multiton的模式可以解决这个问题。似乎没有人知道它本身就是一种模式，或者是Singleton的一种变体。查看链接，其中包含示例代码。

Answer 11

看看Object pool pattern。它的java实现在Grand Patterns in Java V1中有很好的描述。

书籍概述中的简短描述：

对象池

管理类型对象的重用   对象来说，创建起来很昂贵   或者只是有限数量的一种   可以创建对象。

只有5个类的实例

11 个答案: