Erhalten Sie ein bereits vorhandenes Objekt aus einer anderen Klasse

Question

Im sehr neu in der Programmierung und möchte wissen, ob ich irgendwie das Objekt aus einer Klasse bekommen, wo ich bereits verwendet new MyClass(); es in einer anderen Klasse zu verwenden, und dass ich nicht verwenden new MyClass(); wieder. Ich hoffe, Sie verstehen es.

Einige sehr einfaches Beispiel: Dies ist Kickoff Beispiel für ein solches Objekt

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

können Sie Singleton pattern verwenden diese

zu erreichen. Es hat eine private constructor und public class methodgetInstance:

statische Methoden, die den statischen Modifikator in ihren Erklärungen haben, sollte mit dem Klassennamen aufgerufen werden, ohne die Notwendigkeit für die Schaffung eine Instanz der Klasse

wenn wir einen Aufruf an getInstance machen überprüft es, ob ein Objekt bereits erstellt wurde und wird eine Instanz bereits erstellt widersprochen zurückgeben, wenn es nicht erstellt wurde, wird es ein neues Objekt erstellen und es zurück.

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

Um zu überprüfen, wie funktioniert diese Arbeit, die Sie den folgenden Code verwenden:

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 2

Singleton-Muster können Sie einzelne Instanz haben, die ‚global‘ zugänglich von anderen Klassen ist. Dieses Muster garantiert, dass Sie nur eine Instanz im Speicher haben. Es gibt Ausnahmen von einem Fall profitieren, wie wenn deserializaing aus der Datei, es sei denn darauf geachtet wird, und readResolve umgesetzt wird.

Beachten Sie, dass Klasse Etwas jetzt keine staatlichen (Felder) hat, nur das Verhalten, so dass es sicher ist, zwischen mehreren Threads zu teilen. Wenn Something Status hatte, müssten Sie in einer Multi-Thread-Umgebung eine Art von Synchronisationsmechanismus bereitstellen.

Bei einer solchen staatenlos Singleton, wäre es besser, es mit Klasse zu ersetzen, die nur statische Methoden enthält. Das heißt, es sei denn, Sie implementieren ein Muster wie die Strategie, die eine Schnittstellenimplementierung erfordert, dann wäre es eine gute Idee, Instanz wie Balg mit dem Singleton-Muster zwischenzuspeichern.

Sie sollen Ihre Etwas Klasse wie folgt überarbeiten Singleton zu erreichen:

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 3

Anstatt das Singleton-Muster zu verwenden, ein besseres Muster ist Dependency Injection zu verwenden. Im Wesentlichen instanziieren Sie die Klasse, die Sie freigeben möchten, und übergeben sie im Konstruktor jeder Klasse, die sie benötigt.

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 4

Wenn Firstclass und Second irgendwie verwandt sind, können Sie das gemeinsame Objekt extrahieren Sie zu einer Superklasse verwenden, und das ist der einzige Bereich, in dem Sie planen dieses Objekt zu verwenden.

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

     public Something getObjectFromClass(){ 
      return st; 
     } 
    } 

    public class MyFirstClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

    public class MySecondClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

Andernfalls, wenn Sie planen, irgendwo diese Instanz zu verwenden, sollten Sie sonst noch ein Singleton-Objekt verwenden.Der einfachste Weg, dies zu tun ist:

enum Singleton 
{ 
    INSTANCE; 

    private final Something obj; 

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

    public Something getObject() 
    { 
     return obj; 
    } 
} 

Sie es verwenden:

Singleton.INSTANCE.getObject(); 

Answer 5

Da Sie gerade begonnen haben, Codierung werden Sie nicht einen Begriff wie Reflexion geben und alle .. hier ist eine der einfacher Weg ist eine öffentliche getter() Methode.

Betrachten Sie dieses einfache Beispiel

class Something { 

    private int a=10; 

    public int getA() { 
     return a; 
    } 


} 

Hier ist die erste, die eine öffentliche Methode hat, die das Objekt zurück, das ich für die etwas Klasse in dieser Klasse erstellt

class MyFirstClass { 

    private Something st; 

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

    public Something getSt() { 
     return st; 
    } 




} 

es aus einer anderen Klasse zugreifen

class MySecondClass { 

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


} 

Ausgang: 10

Wenn Sie wan't in MyFirstClass

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

Injizieren Sie diese Funktion, um zu überprüfen und dann von beiden Methoden in MySecondClass

Klasse MySecondClass die Hash-Codes drucken {

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

} 

}

Sie werden sehen, dass Sie tatsächlich das Objekt verwenden, das in MyFirstClass in MySecondClass erstellt wurde.

Da dies Ihnen die gleiche Hashcode-Ausgabe geben wird.

Ausgabe Auf meinem Computer.

Something@2677622b 
Something@2677622b 

Answer 6

Okay, zuerst können Sie Vererbung z.

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 

} 

Oder wenn Sie keine Objekte und nur die Methode möchten, können Sie Schnittstellen implementieren, z.

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