Zdobądź już istniejący obiekt z innej klasy

Question

Jestem bardzo nowy w programowaniu i chcę wiedzieć, czy mogę w jakiś sposób pobrać obiekt z klasy, w której już użyłem new MyClass();, aby użyć go w innej klasie i którego nie potrzebuję używać new MyClass(); ponownie. Mam nadzieję, że masz rację.

Niektóre bardzo prosty przykład:

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

Singleton pattern można użyć, aby osiągnąć ten

to KickOff przykładem takiego obiektu. Ma private constructor i public class methodgetInstance:

metody statyczne, które mają statyczny modyfikator w swoich deklaracjach, powinna być wywołana z nazwą klasy, bez konieczności tworzenia instancję klasy

Kiedy wykonujemy połączenie z getInstance sprawdza, czy obiekt został już utworzony i zwróci wystąpienie już utworzone, jeśli nie zostało utworzone, utworzy nowy obiekt i zwróci go.

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

Aby sprawdzić jak to działa można użyć następującego kodu:

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 pozwala mieć pojedynczą instancję, która jest „globalnie” dostępny przez innych klas. Ten wzór "zagwarantuje", że masz tylko jedną instancję w pamięci. Istnieją wyjątki od korzyści dla jednej instancji, na przykład podczas deserializacji z pliku, o ile nie zostanie podjęta troska i zaimplementowano readResolve.

Zauważ, że klasa Coś teraz nie ma stanu (pola), tylko zachowanie, więc bezpiecznie jest dzielić się między wieloma wątkami. Jeśli coś miało stan, musielibyśmy zapewnić pewien mechanizm synchronizacji w środowisku wielowątkowym.

Biorąc pod uwagę taki bezpaństwowiec Singleton, lepiej zastąpić go klasą zawierającą tylko metody statyczne. Oznacza to, że jeśli nie wdrażasz wzorca takiego jak strategia, która wymaga implementacji interfejsu, dobrym pomysłem byłoby buforowanie instancji takiej jak poniżej z wzorcem Singleton.

Należy przerobienie klasa Coś jak to osiągnąć pojedyncza:

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

Zamiast wzorzec Singleton, lepszy wzór do wykorzystania jest zależność wtrysku. Zasadniczo tworzysz instancję klasy, którą chcesz udostępnić, i przekazujesz ją do konstruktora każdej klasy, która tego potrzebuje.

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

Jeśli FirstClass i secondClass są jakoś powiązane, że można wyodrębnić wspólny przedmiot, którego używasz do super klasy, a to jedyny zakres, w którym masz zamiar korzystać z tego obiektu.

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

     public Something getObjectFromClass(){ 
      return st; 
     } 
    } 

    public class MyFirstClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

    public class MySecondClass extends SuperClass{ 
     getObjectFromClass(); 
    } 

W przeciwnym razie, jeśli masz zamiar używać tego wystąpienia gdzieś indziej należy użyć Singleton obiekt.Najprostszym sposobem na to jest:

enum Singleton 
{ 
    INSTANCE; 

    private final Something obj; 

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

    public Something getObject() 
    { 
     return obj; 
    } 
} 

go używać:

Singleton.INSTANCE.getObject(); 

Answer 5

Ponieważ właśnie rozpoczęły kodowania nie daje pojęcia jak refleksji i wszystko .. tutaj jest jednym z prosty sposób ma publiczną metodę getter().

Rozważmy Ten prosty przykład

class Something { 

    private int a=10; 

    public int getA() { 
     return a; 
    } 


} 

Oto pierwsza który ma metodę publiczną które zwracają obiekt, który stworzyłem w tej klasie dla Something klasy

class MyFirstClass { 

    private Something st; 

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

    public Something getSt() { 
     return st; 
    } 




} 

dostępu do niego z innej klasy

class MySecondClass { 

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


} 

Wyjście: 10

Jeśli wan't zweryfikować

wstrzyknąć tę funkcję w MyFirstClass

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

a następnie wydrukować kody hash z obu metod w MySecondClass

klasy MySecondClass {

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

} 

}

Zobaczysz, że rzeczywiście używasz obiektu utworzonego w MyFirstClass w MySecondClass.

Ponieważ to daje ten sam wynik hashcode.

Wyjście na moim komputerze.

Something@2677622b 
Something@2677622b 

Answer 6

Po pierwsze możesz użyć dziedziczenia np.

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 

} 

Lub jeśli nie chcesz żadnych obiektów i tylko metody można wdrożyć interfejsy np.

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