Question

我非常喜欢编程，想知道我是否能以某种方式从我已经使用new MyClass();的类中获取对象，以便在另一个类中使用它而我不需要使用{{1}再次。希望你明白这一点。

一些非常简单的例子：

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 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

Singleton模式允许您拥有其他类可以“全局”访问的单个实例。此模式将“保证”您在内存中只有一个实例。一个实例的好处有例外，例如从文件中反序列化时除非小心并且实现了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();
    }

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

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

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

6 个答案: