Ottieni un oggetto già esistente da un'altra classe

Question

Im molto nuovo alla programmazione e voglio sapere se posso in qualche modo ottenere l'oggetto da una classe in cui ho già utilizzato new MyClass(); per usarlo in un'altra classe e che non ho bisogno di usare new MyClass(); di nuovo. Spero che tu capisca il punto.

Qualche esempio molto semplice:

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

È possibile utilizzare Singleton pattern per raggiungere questo esempio

Questo è calcio d'inizio di tale oggetto. Ha un private constructor e public class methodgetInstance:

metodi statici, che hanno il modificatore static nelle loro dichiarazioni, dovrebbe essere invocata con il nome della classe, senza la necessità di creare un'istanza della classe

Quando effettuiamo una chiamata allo getInstance controlla se un oggetto è già stato creato e restituirà un'istanza di oggetto già creato, se non è stato creato creerà un nuovo oggetto e lo restituirà.

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

Per controllare come fa questo lavoro è possibile utilizzare il seguente codice:

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 modello ti permette di avere un'unica istanza che è 'globalmente' raggiungibile con altre classi. Questo modello garantirà che hai una sola istanza in memoria. Esistono eccezioni a un vantaggio dell'istanza, ad esempio quando si deserializza da file, a meno che non si prenda cura e sia implementato lo standard readResolve.

Si noti che classe Qualcosa in questo momento non ha stato (campi), solo il comportamento, quindi è sicuro condividere tra più thread. Se Qualcosa avesse stato, avresti bisogno di fornire un qualche tipo di meccanismo di sincronizzazione nell'ambiente multi-thread.

Dato questo Singleton stateless, sarebbe meglio sostituirlo con una classe che contiene solo metodi statici. Cioè, a meno che non stiate implementando pattern come Strategy che richiede l'implementazione dell'interfaccia, allora sarebbe una buona idea memorizzare nella cache l'istanza come muggito con il pattern Singleton.

Si dovrebbe rielaborare la classe qualcosa di simile per ottenere 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() { 
     //.. 
    } 
} 

Answer 3

Invece di utilizzare il pattern Singleton, un modello migliore da usare è l'iniezione di dipendenza. In sostanza, istanziate la classe che volete condividere e passatela nel costruttore di ogni classe che ne ha bisogno.

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

Se FirstClass e secondClass sono in qualche modo correlati, è possibile estrarre l'oggetto comune si sta utilizzando per una classe di super, e questo è l'unico ambito in cui si ha intenzione di utilizzare questo oggetto.

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

     public Something getObjectFromClass(){ 
      return st; 
     } 
    } 

    public class MyFirstClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

    public class MySecondClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

In caso contrario, se si prevede di utilizzare tale istanza da qualche altra parte è necessario utilizzare un Singleton oggetto .Il modo più semplice per farlo è:

enum Singleton 
{ 
    INSTANCE; 

    private final Something obj; 

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

    public Something getObject() 
    { 
     return obj; 
    } 
} 

L'usate:

Singleton.INSTANCE.getObject(); 

Answer 5

Dal momento che avete appena iniziato codifica non vi darà un termine come riflessione e di tutti .. qui è uno dei modo semplice è un metodo pubblico getter().

Considerate questo semplice esempio

class Something { 

    private int a=10; 

    public int getA() { 
     return a; 
    } 


} 

Ecco la prima che ha un metodo pubblico, che restituisce l'oggetto che ho creato in questa classe per la Qualcosa Classe

class MyFirstClass { 

    private Something st; 

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

    public Something getSt() { 
     return st; 
    } 




} 

accedervi da un'altra classe

class MySecondClass { 

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


} 

Uscita: 10

Se wan't per verificare

Iniettare questa funzione in MyFirstClass

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

e quindi stampare i codici hash di entrambi i metodi MySecondClass

class MySecondClass {

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

} 

}

Si vedrà che in effetti si sta utilizzando l'oggetto creato in MyFirstClass in MySecondClass.

Perché questo darà lo stesso output di hashcode.

Uscita sulla mia macchina.

Something@2677622b 
Something@2677622b 

Answer 6

Ok, in primo luogo è possibile utilizzare l'ereditarietà ad es.

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 

} 

Oppure se non si desidera alcun oggetto e solo il metodo è possibile implementare interfacce ad es.

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