Instanz auslesen?

[minzel]

Hey !

Habe zu dem Thema irgendwie noch nichts gefunden. Habe folgendes Problem:

Ich habe ein JDesktopPane , darauf eine Klasse A die von JInternalFrame erbt. Möchte nun von meiner Hauptklasse oder einer anderen Klasse vom gleichen Programm die Objekte über die Instanz der Klasse A auslesen. (Mal was neues) Ich weiß es geht einfacher aber ist diese Variante denn möglich?

 

[André Uhres]

Du brauchst nur die entsprechenden Referenzen, dann kannst du alles angreifen wozu du Lust hast. Eventuell musst du nur die Zugriffsberechtigung von private auf protected umändern.

 

[minzel]

Könntest du das genauer erklären mit den Referenzen? Hängt das ganze mit dieser serialID zusammen?

 

[André Uhres]

Eine Referenz auf ein Objekt enthält als Wert die Adresse des
Objektes, auf das die Referenz zeigt. Die Adresse gibt an, an
welcher Stelle das Objekt im Arbeitsspeicher liegt.

package test;
public class A {
   protected String str = "Hallo";
   public A(){
      new B(this);
   }
}

package test;
public class B {
   pubic B(A refA){
      if(refA.str.equals("Hallo")){
         ...
      }
   }
}

Im Beispiel bekommt B die Referenz auf A über den Konstruktor geliefert.
B hat jetzt Zugriff auf den String der in A ist (refA.str).

 

[minzel]

Habe auf die schnell mal folgendes erstellt, was schon fast alles das macht was ich wollte:

package maintain;

import java.util.Vector;

import internalFrame.MaterialCalc;

public class InstanzHandler {

	private static Vector<MaterialCalc> vec = new Vector<MaterialCalc>();
	
	public InstanzHandler(MaterialCalc calc) {
		vec.add(calc);
	}

	public static Vector<MaterialCalc> getVec() {
		return vec;
	}
}

Kann jetzt verschiedene Instanzen der Klasse erstellen und alle mit getVec() abrufen. Das ist schon mal super. danke dafür. Muß jetzt nur mal schauen ... wenn eine Instanz geschlossen wird (terminiert) muss sie ja aus dem Handler wieder raus. Ging mit dem Dekonstruktor oder? Hab den aber bei Java noch nie anwenden müssen.

PS:
*klick* Mit einem WindowListener beim schließen des InternalFrame kann man ja die Instanz raussuchen und löschen. *GEIL *g

 

[Murray]

Destruktoren gibt es in Java nicht. Es gibt lediglich Finalizer, aber die werden aufgerufen, bevor das entsprechende Objekt vom Garbage-Collector entsorgt wird - und wenn Du noch eine Referenz auf das Objekt hast, passiert das nicht. Die Referenz im Vector musst Du also explizit löschen.

 

[minzel]

Achso, okay ... habe im letzten Beitrag eben schon ein PS geschrieben mir ist schon der erleuchtende Weg in meinen Tagträumen erschienen

 

[Wildcard]

noch was generelles:
Du solltest niemals einen Vector als return Wert haben. Gib nicht mehr bekannt als notwendig, aber eben auch nicht weniger :wink:
Beispiel:

  //schlecht
   public static Vector<MaterialCalc> getVec() {
      return vec;
   } 
   //besser
   public static List<MaterialCalc> getVec() {
      return vec;
   } 
   //am besten (wenn du die zusätzlichen Methoden von List nicht brauchst
   public static Collection<MaterialCalc> getVec() {
      return vec;
   }

 

[minzel]

mensch danke. Ja, tatsächlich brauch ich die Funktionen der Liste (Vektors) nicht. Jedeglich die Instanzen sind wichtig.
Werde dies gleich so anpassen.

Und was ich noch sagen wollte. Kein WindowListener sonder:

this.addInternalFrameListener(new InternalFrameAdapter() {
			public void internalFrameClosing(InternalFrameEvent e) {
				
			}
		});

nur so zur komplettierung
Immer her mit mehr brauchbaren tipps *g
<- Javajunkie

 

[minzel]

hm, da kommt aber schon das erste Problem mit dem Auslesen:

Collection<MaterialCalc> collect = InstanzHandler.getVec();
collect.get(...); // Gibt es nicht

PS:
Ich denke mal mit einem Iterator aber den Verweis auf die eigentliche Klasse (Instanz) ist mir gerade ein Rätsel.

 

[Wildcard]

Wenn du nur über die Collection iterieren willst ist Collection ausreichend (siehe Iterator).
Wenn du Zugriff über einen Index brauchst musst du List nehmen.

 

[minzel]

ah, kk ...

Collection<MaterialCalc> collect = InstanceHandler.getVec();
Iterator i = collect.iterator();
while(i.hasNext()) {
	MaterialCalc m = (MaterialCalc) i.next();
}

mal wieder zu früh gepostet. Fettes THX

 

[Wildcard]

Auch der Iterator kann(sollte) typisiert werden :wink:

 

[minzel]

lol, okay, mache ich
Eclipse zeigt sowas halt nicht als Warning an. *hm

 

[Wildcard]

Doch tut es. Hängt nur von den Einstellungen ab.

 

[minzel]

hm, wenn wir schon dabei sind, habe es jetzt hinbekommen wie gewollt. allerdings denke ich nicht das folgende methode elegant gelöst ist. Gibt es da noch verbesserungswürdiges?

	public static boolean disposeInstance(int id) {

		int instanceCounter = 0;
		Iterator<MaterialCalc> i = vec.iterator();
		while(i.hasNext()) {
			MaterialCalc m = (MaterialCalc) i.next();
			if ( id == m.instanceID ) {
				vec.remove(instanceCounter);
				return true;
			}
			instanceCounter++;
		}
		return false;
	}

Insbesondere stört es mich das "return true;" nicht fehlen darf. Da er die schleife weiter durchläuft und dann ein Exception wirft wenn keine mehr vorhanden sind. (Also 0 Instanzen)
Zum zweiten ist es dieser "instanceCounter", er muß ja zunächst mitlaufen damit ich weiß welche Instanz aus dem Vector gelöscht werden soll.

Es läuft so. Aber seit meiner letzten Javaprüfung die schon ein kleiner genickschlag war, wurde mir angeraten, wenn ich so denke das es doch läuft solle ich besser nochmal nachfragen ^^

 

[Wildcard]

Gut das du nachgefragt hast. Wenn du einen Iterator verwendest, darfst du die Collection nicht gleichzeitig manipulieren.
Wenn die ID unabhängig von der Position im Vector ist (warum eigentlich Vector und keine ArrayList?)

   public static boolean disposeInstance(int id) {

      Iterator<MaterialCalc> i = vec.iterator<MaterialCalc>();
      while(i.hasNext()) {
         if(it.next().instanceID==id)
         {
              it.remove();
              return true; 
         }
      }
      return false;
   }

Wenn die ID der Position im Vector entspricht:

public static boolean disposeInstance(int id) {
     return vec.remove(id);
}

Ich verstehe den Sinn der Instanz-Verwaltung noch nicht ganz. Was genau willst du eigentlich machen?
Vieleicht gibt's da eine bessere Lösung...

 

[minzel]

danke dir, ersterer Vorschlag trifft zu, probier es nacher gleich aus, habe eben noch eine pause eingelegt.

Naja, will an dem Verfahren nicht viel mehr rütteln. Habe ein DesktopFrame auf dem man viele verschiedene Instanzen (JInternalFrame) erstellen kann. Jede Instanz die Offen ist möchte ich in einem, nennen wir es "Haupt"-InternalFrame, verwenden können. (Also auslesen). Darauf liegen je ein JLabel[] mit preisen und ein JTextField[] mit der eingegebenen Anzahl.
Es ist eine ungewöhnliche Steuerung, nicht alles starr auf einem JFrame zu haben, aber dafür ist ja die Programmierung glaube ich da. Neue Verfahren zu erfinden, umzusetzen und zu nutzen.

 

[Wildcard]

Direkter Zugriff auf diese InternalFrames ist nicht zu empfehlen. Stattdessen solltest du ein Daten-Modell befüllen das an mehreren Stellen deiner Anwendung zum Einsatz kommen kann.
Wenn du aus anderen Gründen wirklich eine Referenz auf die InternalFrames haben musst, dann solltest du das eher über einen getter in der Desktop Pane realisieren.
In jedem Fall solltest du von deinem static Ansatz weg kommen.

 

[minzel]

Es soll ja nur eine Instanz von InstanceHandler erstellt werden. Oder so gibt es einen einfachen zugriff von überall.
Getter-Setter Methoden werd ich sicher noch machen.

 

[Wildcard]

Du bekommst aber probleme sobald du mehr als eine DesktopPane verwenden willst.
static ist nicht OOP und immer eine (meist unnötige) Einschränkung der Flexibilität.
Aber mach deine eigenen Erfahrungen :wink:

 

[minzel]

ja, ne, so ein DatenHandler statt InstanzHandler reicht glaube auch zu. das statische würde dann auch verschwinden *hm, an sich kann ich aber die letzten stunden als umsonst betrachten :/

PS:
Hab mir das nochmal durch den Kopf gehen lassen. Die Statische InstanceHandler-Klasse ist ne , für mich, gute Lösung. Von der Klasse soll es ja nur eine Instance geben und behält mir die Möglichkeit vor noch auf andere Attribute zu zugreifen.

 

[clemson]

Muß jetzt nur mal schauen ... wenn eine Instanz geschlossen wird (terminiert) muss sie ja aus dem Handler wieder raus.

Vielleicht hilft dir eine WeakReference bzw. eine WeakHashMap bei deinem Problem mit den ungenützten bzw. terminierten Instanzen weiter...

erklärender Blog Eintrag