我是java编程的新手，我有一个类，对于这个类，我创建了两个对象（obj1，obj2）.i不想创建除这些对象之外的其他对象，如果有任何体想要再创建一个对象这个类应该引用第一个或第二个对象（而不是再创建一个对象）。如何做到这一点？请参考下面的代码
class B
{
void mymethod()
{
System.out.println("B class method");
}
}
class Myclass extends B
{
public static void main(String s[])
{
B obj1=new B();//this is obj1
B obj2=new B();//this is obj1
B obj3=new B();//don't allow to create this and refer this to obj1 or obj2
}
}
由于 阿扎姆
答案 0 :(得分：5)
查看Singleton设计模式。
答案 1 :(得分：3)
您需要的是Singleton设计模式。
Class B看起来应该是这样的：
class B
{
private static B instance = null;
private B()
{
//Do any other initialization here
}
public static B getInstance()
{
if (instance == null)
{
instance = new B();
}
return instance;
}
}
然后，在Myclass中，只需执行此操作：
B obj1 = B.getInstance();
B obj2 = B.getInstance();
注意：这是不线程安全。如果您正在寻找线程安全解决方案，请参阅Wiki页面。
编辑：你也可以有一个静态初始化器
class B
{
private static B instance = null;
static
{
instance = new B();
}
private B()
{
//Do any other initialization here
}
public static B getInstance()
{
return instance;
}
}
答案 2 :(得分：2)
从Java 6开始，您可以使用单元素枚举类型的单例。这种方式是目前在Java 1.6或更高版本中实现单例的最佳方式，根据书“”来自Joshua Bloch的有效Java。
package mypackage;
public enum MyEnumSingleton {
INSTANCE;
// other useful methods here
}
"This approach is functionally equivalent to the public field approach,
except that it is more concise, provides the serialization machinery for free,
and provides an ironclad guarantee against multiple instantiation, even in the
face of sophisticated serialization or reflection attacks. While this approach
has yet to be widely adopted, a single-element enum type is
the best way to implement a singleton."
在Java 1.6之前，应该是单例的类可以像下面这样定义。
public class Singleton {
private static Singleton uniqInstance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (uniqInstance == null) {
uniqInstance = new Singleton();
}
return uniqInstance;
}
// other useful methods here
}
答案 3 :(得分：1)
是的单身人士似乎正确的方式考虑你在这里提供的信息。
默认的单例实现如下：
public class Singleton {
//holds single instance reference
private static Singleton instance = null;
//private constructor to avoid clients to call new on it
private Singleton()
{}
public static Singleton getInstance()
{
if(null == instance)
{
instance = new Singleton();
}
return instance;
}
}
现在，您可以通过调用以获取对象的单个实例： Singleton instance = Singleton.getInstance（）;
请记住，如果您使用线程环境，默认情况下单例不是线程安全的。
您应该使getInstance方法同步以避免意外返回。
public synchronized static Singleton getInstance()
{
if(null == instance)
{
instance = new Singleton();
}
return instance;
}
干杯
答案 4 :(得分：0)
一般来说，你需要一个单身人士模式。您需要使构造函数成为私有方法。然后创建一个实例化B类的方法，因此B类只能通过此方法实例化。看看单身人士模式。这是你想要我相信的。
答案 5 :(得分：0)
您可以使用Singleton。你有两种可能性。
1。 懒惰创建（这里您在调用函数getInstance()时创建实例，并检查实例是否已存在）：
class B {
static private B instance;
private void mymethod() {
System.out.println("B class method");
}
static public B getInstance() {
if (instance == null) {
instance = new B();
}
return instance;
}
}
class Myclass extends B {
public static void main(String s[]) {
B obj1 = B.getInstance(); // this is obj1
B obj2 = B.getInstance();
}
}
2。 热切创作（这里是第一次调用Class时的实例）：
class B {
static private B instance = new B();
private void mymethod() {
System.out.println("B class method");
}
static public B getInstance() {
return instance;
}
}
class Myclass extends B {
public static void main(String s[]) {
B obj1 = B.getInstance(); // this is obj1
B obj2 = B.getInstance();
}
}
答案 6 :(得分：0)
创建单例类，如
public Class A {
private static Class a = new A();
public A getA() {
return a;
}
}
A类的对象已经在A类本身中创建。您无需在外部创建它。只需使用getA（）方法来解除A类的对象。 喜欢：
A objA = A.getA();
这叫做Singlton Pattern。
答案 7 :(得分：0)
请注意，使用单例是对代码的一个很大限制。当不可能实例多个对象时，它会非常烦人。
特别是当你没有访问源....
答案 8 :(得分：0)
多线程应用程序的有效方法，以下逻辑可能会有所帮助
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;
}
}
答案 9 :(得分：0)
我想人们不理解问题陈述。它说最多只能创建2个对象。 Singleton创建单个对象并阻止任何进一步的实例化。