从另一个类中获取已经存在的对象

Question

我对编程很陌生，想知道我是否可以以某种方式从我已经使用new MyClass(); 的类中获取对象，以便在另一个类中使用它，并且我不需要再次使用new MyClass();。希望你明白这一点。

一些非常简单的例子：

class MyFirstClass
{
    Something st = new Something();
}

class Something()
{
    // some code
}

class MySecondClass
{
    // This is where I want to use the object from class Something()
    // like
    getObjectFromClass()
}

Answer 1

由于您刚刚开始编码，因此不会给您提供诸如反射之类的术语。这里有一个简单的方法是拥有一个公共 getter() 方法。

考虑这个简单的例子

class Something {

    private int a=10;

    public int getA() {
        return a;
    }


}

这是第一个，它有一个公共方法，它返回我在这个类中为Something类创建的对象

class MyFirstClass {

    private Something st;

    public MyFirstClass() {
        this.st = new Something();
    }

    public Something getSt() {
        return st;
    }




}

从另一个类访问它

class MySecondClass {

    public static void main(String...strings ){
        MyFirstClass my =new MyFirstClass();
        System.out.println(my.getSt().getA());
    }


}

输出：10

如果你不想验证

在MyFirstClass中注入这个函数

public void printHashcode(){
        System.out.println(st);
    }

然后在MySecondClass中打印两种方法的哈希码

类 MySecondClass {

public static void main(String...strings ){
    MyFirstClass my =new MyFirstClass();
    System.out.println(my.getSt());
    my.printHashcode();

}

}

您会看到您确实在使用MyFirstClass 中创建的对象MySecondClass。

因为这将为您提供相同的哈希码输出。

在我的机器上输出。

Something@2677622b
Something@2677622b

Answer 2

你可以使用Singleton pattern来实现这个

这是此类对象的启动示例。它有一个private constructor 和public class method getInstance：

静态方法，在其声明中具有 static 修饰符， 应该用类名调用，而不需要创建 类的一个实例

当我们调用 getInstance 时，它会检查一个对象是否已经被创建，并返回一个已经创建的对象的实例，如果它没有被创建，它将创建一个新对象并返回它。

public class SingletonObject {

private static int instantiationCounter = 0;    //we use this class variable to count how many times this object was instantiated

private static volatile SingletonObject instance;
private SingletonObject() { 
    instantiationCounter++;
}

public static SingletonObject getInstance() {
    if (instance == null ) {
       instance = new SingletonObject();
    }

    return instance;
}

public int getInstantiationCounter(){
    return instantiationCounter;
}
}

要检查它是如何工作的，您可以使用以下代码：

public static void main(String[] args)  {
        SingletonObject object = SingletonObject.getInstance();

        System.out.println("Object was instantiated: " + object.getInstantiationCounter() + " times.");

        object = SingletonObject.getInstance();

        System.out.println("Object was instantiated: " + object.getInstantiationCounter() + " times.");

        object = SingletonObject.getInstance();

        System.out.println("Object was instantiated: " + object.getInstantiationCounter() + " times.");

    }

Answer 3

单例模式让您拥有可由其他类“全局”访问的单个实例。这种模式将“保证”您在内存中只有一个实例。一个实例的好处有例外，例如从文件反序列化时，除非小心并实现readResolve。

请注意，Something 类现在没有状态（字段），只有行为，因此在多个线程之间共享是安全的。如果Something有状态，则需要在多线程环境中提供某种同步机制。

鉴于这样的无状态 Singleton，最好将其替换为仅包含静态方法的类。也就是说，除非您正在实现诸如 Strategy 之类需要接口实现的模式，否则最好使用 Singleton 模式缓存实例。

你应该像这样重写你的Something类来实现单例：

public class Something {

    private static final Something INSTANCE = new Something ();

    private Something () {

        // exists to defeat instantiation
    }

    public Something getInstance() {
        return INSTANCE;
    }


    public void service() {
        //...
    }

    public void anotherService() {
        //..
    }
}

Answer 4

除了使用单例模式，更好的模式是依赖注入。本质上，您实例化您想要共享的类，并将它传递给每个需要它的类的构造函数。

public class MainClass {
    public static void main(String[] args) {
        SharedClass sharedClass = new SharedClass();
        ClassA classA = new ClassA(sharedClass);
        ClassB classB = new ClassB(sharedClass);
    }
}

public class ClassA {
    private SharedClass sharedClass;

    public ClassA(SharedClass sharedClass) {
        this.sharedClass = sharedClass;
    }
}

public class ClassB {
    private SharedClass sharedClass;

    public ClassB(SharedClass sharedClass) {
        this.sharedClass = sharedClass;
    }
}

Answer 5

如果 FirstClass 和 SecondClass 在某种程度上相关，您可以将您正在使用的公共对象提取到超类中，这是您计划使用此对象的唯一范围。

    public class SuperClass{
        Something st = new Something();

        public Something getObjectFromClass(){
           return st;
        }
    }

    public class MyFirstClass extends SuperClass{
       getObjectFromClass();
    }

    public class MySecondClass extends SuperClass{
       getObjectFromClass();
    }

否则，如果您打算在其他地方使用该实例，则应使用 单例对象。最简单的方法是：

enum Singleton
{
    INSTANCE;

    private final Something obj;

    Singleton()
    {
        obj = new Something();
    }

    public Something getObject()
    {
        return obj;
    }
}

你用它：

Singleton.INSTANCE.getObject();

Answer 6

好的，首先你可以使用继承，例如

class MyFirstClass

{

Something st = new Something();

}

class Something()
{
// some code
}

class MySecondClass extends myFirstClass
{
// This is where I want to use the object from class Something()
// like
MySecondClass obj = new MySecondClass();
obj.method();  //Method from myfirstclass accessible from second class object

}

或者，如果您不想要任何对象而只想要您可以实现接口的方法，例如

public interface MyFirstClass
{

//example method
 public abstract void saying();    //no body required

Something st = new Something();
}

class Something()
{
// some code
}

class MySecondClass implements MyFirstClass //Have to implement methods
{

   public void saying(){         //Method implemented from firstClass no obj
   System.out.println("Hello World");
 }
 getObjectFromClass()
}