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

Question

我是一个非常新的编程，想要知道我是否可以以某种方式从我已经使用过new MyClass();的类中获取对象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两个方法打印哈希码

class 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模式来实现此目的

这是这种对象的启动示例。 它有一个私有构造函数和公共类方法 getInstance ：

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

当我们调用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，最好用仅包含静态方法的类替换它。 也就是说，除非你正在实现需要接口实现的策略之类的模式，否则最好像使用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

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

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();
    }

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

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()
}