我是 java 编程新手，我有一个类，对于这个类，我创建了两个对象（obj1，obj2）。我不想创建这些对象以外的对象，如果有任何人想为这个类创建一个对象应该只引用第一个或第二个对象（而不是再创建一个对象）。如何做到这一点？请参考下面的代码
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
}
}
谢谢阿扎姆
查看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;
}
}
从 Java 6 开始，您可以使用单元素枚举类型进行单例化。根据 Joshua Bloch 的《Effective Java》一书，这种方式是目前在 Java 1.6 或更高版本中实现单例的最佳方式。
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
}
是的，单身人士似乎是考虑您在此处提供的信息的正确方法。
默认的单例实现如下：
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;
}
干杯
一般来说，您需要一个单例模式。您需要使构造函数成为私有方法。然后创建一个方法来实例化 B 类，因此 B 类只能由该方法实例化。看看单例模式。这是你想要的，我相信。
您可以使用单例。你有 2 种可能性。
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();
}
}
创建单例类，例如
public Class A {
private static Class a = new A();
public A getA() {
return a;
}
}
A 类的对象已经在 A 类本身中创建。您无需在外部创建它。只需使用 getA() 方法来检索类 A 的对象。喜欢 ：
A objA = A.getA();
这称为单例模式。
请注意，使用单例对您的代码来说是一个很大的限制。当无法实例化多个对象时，这可能会非常烦人。
尤其是当您无法访问源时....
我想人们还没有理解问题陈述。它说，不应创建超过 2 个对象。Singleton 创建单个对象并阻止任何进一步的实例化。
多线程应用程序中的有效方法，以下逻辑可能会有所帮助
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;
}
}