OOP Warum gleiche Instanz der Klasse? (Factory-Muster)

[stockhausen]

Hallo Zusammen,

ich habe eine Factory-Klasse erstellt, der mir die Instanz einer Klasse zurück gibt.
In der main() Methode rufe ich die Factory-Klasse auf zwei verschiedene Weisen auf.

Frage

Warum wird in der nicht auskommentierte Variante immer die gleiche Instanz der Klasse MyFactory zurück gegeben?

Aufgrund der Tatsache, dass die Objekte der Factory-Klasse innerhalb der for-Schleife erstellt werden und die Objekte der MyClass innerhalb der Factory sollte eigentlich pro Schleifendurchlauf ein neues Objkt der Klasse MyClass erzeugt werden!

In der Auskommentierten Version rechne ich auf Grud der Tatsache, dass das Objekt der MyFactory-Klasse außerhalb der for-Schleife erzeugt wird mit dem gleichen Objekt der MyClass Klasse!

Ich hoffe, dass mein Anlieger halbwegs verständlich war!

Gruß,
Michael


Klasse MyFactory

public class MyFactory {

	private static MyClass INSTANCE = new MyClass();
	
	public MyClass getInstance() {
		return INSTANCE;
	}

}

Klasse MyClass

public class MyClass {

	public MyClass() {
		
	}
}

Klasse Start

public class Start {
	
	public static void main(String[] args) {
		for(int i=0; i<2; i++) {
			MyFactory factory = new MyFactory();
			MyClass myClass = factory.getInstance();
			System.out.println(myClass);
		}
		
//		MyFactory factory = new MyFactory();
//		for(int i=0; i<2; i++) {
//			MyClass myClass = factory.getInstance();
//			System.out.println(myClass);
//		}
		
	}
	
}

Ausgabe
-------

de.test.MyClass@addbf1
de.test.MyClass@addbf1

 

[maki]

public class MyFactory {
 
    private static MyClass INSTANCE = new MyClass();
    
    public MyClass getInstance() {
        return INSTANCE;
    }
 
}

Das ist ein Singleton und erstmal keine Factory

 

[HoaX]

Maki sagte es ja, genau dort liegt der Hund begraben.

Das Feld ist als static deklariert, d.h. es gilt nicht fürs Objekt sondern für die Klasse, es ist also egal wie oft du ein Objekt davon erstellst. Mach das static weg und fertig.

Btw würde ich bei einer Factory die Methode dann zu createMyClass umbenennen, getInstance gibts ehr beim Singleton.

 

[stockhausen]

Hallo Zusammen,

@HoaX: das Proeblem ist gelöst. Jedoch habe ich dir Erklärung noch nicht verstanden

Was meinst du mit "d.h. es gilt nicht fürs Objekt sondern für die Klasse" ?



Das Objekt der Klasse MyClass ist in meinem Beispiel als static deklariert.
Da es zusätzlich private ist, kann ich nur innerhalb der MyFactory Klasse darauf zugreifen.

Wenn ich ein Objekt der Klasse MyFactory in der Schleife erzeuge, wird pro Schleifendurchlauf

private static MyClass INSTANCE = new MyClass();

aufgerufen.


Warum wird bei der Verwendung von Static immer die gleiche Referenz zurück gegeben? Es ist ja KEIN Singelton konstrukt!

Kannst du bitte deine Aussage noch einmal "idiotensicher" erklären

Gruß,
Michael

 

[Gast2]

static = Klassenvariable

Sie wird einmal pro Klasse erzeugt.

Was du willst wäre so etwas:

public class MyFactory {
  
    public static MyClass newMyClassInstance() {
        return new MyClass();
    }
 
}

Was man z.b. machen kann ist die Factory als Singleton anlegen:

public class MyFactory {
   
    private static final MyFactory instance = new MyFactory();

    public static MyFactory getInstance(){
        return instance;
    }

    public MyClass newMyClassInstance() {
        return new MyClass();
    }
 
}

Dann kannst du machen [c]MyClass c = MyFactory.getInstance().newMyClassInstance();[/c]

 

[maki]

Es ist ja KEIN Singelton konstrukt!

Doch doch

Wenn ich ein Objekt der Klasse MyFactory in der Schleife erzeuge, wird pro Schleifendurchlauf

Nein, nur bei der Initialisierung der Klasse.

 

[stockhausen]

danke für die Zahlreichen Antworten

Folgendes habe ich gelernt:

Wenn ich in eine Klasse ein Objekt (A) als static deklariere, wird das Objekt (A) "nur ein einziges mal" bei der Initialisierung der Klasse erzeugt. Wenn ein Objekt (A) innerhalb einer Klasse mit static deklariert wurde, erhalte ich auch wenn ich 100 Instanzen der Klasse erzeuge, immer das gleiche Objekt (A).

Gruß,
Michael

 

[maki]

Wenn ein Objekt (A) innerhalb einer Klasse mit static deklariert wurde, erhalte ich auch wenn ich 100 Instanzen der Klasse erzeuge, immer das gleiche Objekt (A).

Naja, nicht wirklich, denn du erzeugst gar keine 100 Instanzen der Klassen, sondern nur eine einzige, Singleton eben

 

[stockhausen]

Hallo maki,

ich meinte 100 Instanzen der Klassen MyFactory .
Darin wird immer die gleiche Instanz (singleton) der Klasse MyClass erzeugt.


Die Aussage:

Wenn ich in eine Klasse ein Objekt (A) als static deklariere, wird das Objekt (A) "nur ein einziges mal" bei der Initialisierung der Klasse erzeugt. Wenn ein Objekt (A) innerhalb der Klasse MyFactory mit static deklariert wurde, erhalte ich auch wenn ich 100 Instanzen der Klasse MyFactory erzeuge, immer das gleiche Objekt (A) bzw. Instanz der der Klasse MyClass.


Gruß,
Michael

 

[maki]

Hallo maki,

ich meinte 100 Instanzen der Klassen MyFactory .
Darin wird immer die gleiche Instanz (singleton) der Klasse MyClass erzeugt.

Auch falsch, nicht böse sein

Instanzen, also Objekte, erzeugt nur mit dem Schlüsselwort new, davon hast du nur ein einziges, welches nur ein einziges mal bei der Initialisierung der Klasse ausgeführt wird.

 

[eRaaaa]

Ich glaube er meint die Instanz der Factory, da erstellt er ja mehrere von innerhalb der Schleife !

        for(int i=0; i<2; i++) {
            MyFactory factory = new MyFactory();

aber das ist egal ja, du hast dann zwar verschiedene Factory-Objekte, aber die kennen alle nur die eine Instanz von MyClass (da das ja nicht an ein Objekt, sondern eben an die Klasse gebunden ist) . Was hier verwirrt, ist, dass der Klassenname(MyFactory) != der Klasse ist, welche dann intanziiiert und zurückgegeben wird(MyClass), was ja bei einem echten Singleton eher nicht der Fall ist?!

 

[stockhausen]

Bin dir überhaupt nicht böse. ich möchte das Ganze ja richtig verstehen

In dem obigen Beispiel habe ich folgendes geschrieben. Die Zahl 2 habe ich durch 100 ausgetauscht.

Beispiel 1

for(int i=0; i<100; i++) {
	MyFactory factory = new MyFactory();
	MyClass myClass = factory.getInstance();
	System.out.println(myClass);
}

Ich erzeuge bei Beispiel 1 100 Objekte der Klasse MyFactory. In MyFactory wird ein Objekt der Klasse MyClass erzeugt (weil static!).

Beispiel 2

MyFactory factory = new MyFactory();
for(int i=0; i<100; i++) {
	MyClass myClass = factory.getInstance();
	System.out.println(myClass);
}

Hier erzeuge ich ein Objekt der Klasse MyFactory und ein Objekt der Klasse MyClass (weil static!).

 

[maki]

Ok, hast Recht, alle Instanzen der "MyFactory" Klasse haben natürlich das gleiche Feld "instance".

 

[stockhausen]

Was hier verwirrt, ist, dass der Klassenname(MyFactory) != der Klasse ist, welche dann intanziiiert und zurückgegeben wird(MyClass), was ja bei einem echten Singleton eher nicht der Fall ist?!

Jep, bei "echten Singleton" würde ich keine Factory-Klasse erstellen und den Konstruktor der MyClass als private deklarieren. Die getMyClassInstance() Methode würde sich auch in der MyClass Klasse befinden.