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

我对编程非常陌生，我想知道我是否可以从一个我已经使用过的类中获取对象

newmyclass（）

在另一个类中使用它，我不需要使用

newmyclass（）再次。希望你明白我的意思

一些非常简单的例子：

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

您可以使用来实现这一点

这是此类对象的启动示例。它有一个和
getInstance
：

静态方法，其声明中包含静态修饰符，
应使用类名调用，而无需创建
类的实例

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

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.");

    }

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

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

考虑到这种无状态单例，最好用只包含静态方法的类替换它。也就是说，除非您正在实现模式，比如需要接口实现的策略，否则最好使用单例模式来缓存像bellow这样的实例

您应该像这样修改您的Something类以实现singleton：

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() {
        //..
    }
}

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

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

如果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();

因为您刚刚开始编码，所以不会给您一个像反射之类的术语。。这里有一个简单的方法，就是使用一个公共的
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

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

类MySecondClass{

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

}

}

您将看到，实际上您正在使用在
MySecondClass
中的
MyFirstClass
中创建的对象

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

在我的机器上输出

Something@2677622b
Something@2677622b

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

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

使用继承
从
MyFirstClass
以及
MySecondClass
扩展
某物。然后你可以使用
Something
的属性表
MyFirstClass
和
MySecondClass
。我不太明白你的意思。是否要使用在
MySecondClass
中创建的对象（
st
）？如果是，请看Ankur的答案。请记住，仅链接答案是不够的。如果链接消失了，答案就过时了，其他人的网站就会变得杂乱无章。你可以提供一个自给自足的答案，而不是源代码的链接。你是对的，冗余很重要。我将举一个开始的例子。请投票给我，因为我只简单地解释了验证的
hashcode
比较。每个人都已经使用了
singleton
和
reflection
作为答案，所以我想用一种非常简单的方式给出答案，以便新的人能够理解（因为OP对编码来说是新的）谢谢你，安克尔。我在Java中的第一堂课是关于getter（）和setter（），所以我不是那么新的。不过，谢谢你！