von Unterunterklasse auf Haputklasse zugreifen

[Antoras]

Hallo,

ich hab mal wieder ein Problem:
Ich würde gern von einer Unterunterklasse auf die Hauptklasse zugreifen; in meinem Fall wollte ich einfach einem Label einen anderen Text geben.

Ich bekomme bei dieser Aktion nur immer einen NullPointer - die gute Nachricht ist, dass ich weiß warum er verursacht wird (Es gibt Probleme bei der Wertübergabe. Habe ich bei der Unterklasse über den Konstruktor geregelt. Das geht nur irgendwie nicht bei der Unterunterklasse... kann es nicht richtig erklären.); die Schlechte, dass ich nicht weiß wie ich ihn beheben kann.

Ich würde es gerne vermeiden von der Hauptklasse auf die Unterunterklasse direkt zuzugreifen. Des weitern wollte ich nicht erst auf die Unterklasse und von dieser dann auf die Hauptklasse zugreifen.

Ich hoffe, mein Problem kam verständlich rüber: hier mal ein Minimalbeispiel:

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;


public class Hauptklasse extends JFrame {
    
    public JLabel label = null;
    private JButton button = null;
    
    private Unterklasse unterklasse = null;
    
    public static void main(final String[] args) {
        new Hauptklasse();
    }
    
    public Hauptklasse() {
        super("LabelÄndern");
        this.setPreferredSize(new Dimension(300, 80));
        this.setLocation(100, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(new FlowLayout());
        
        unterklasse = new Unterklasse(this);
        
        label = new JLabel();
        label.setText("Hallo Welt");
        getContentPane().add(label);
        
        button = new JButton("Ändere Label");
        button.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                unterklasse.actionButton();
            }
        });
        getContentPane().add(button);
        
        this.pack();
        this.setVisible(true);
    }

}

public class Unterklasse {
    
    private Hauptklasse hauptklasse = null;
    private Unterunterklasse unterunterklasse = null;
    
    public Unterklasse(Hauptklasse hauptklasse) {
        unterunterklasse = new Unterunterklasse();
        this.hauptklasse = hauptklasse;
    }
    
    public void actionButton() {
        unterunterklasse.changeLabel();
    }

}

public class Unterunterklasse {
    
    private Hauptklasse hauptklasse;
    
    public void changeLabel() {
        hauptklasse.label.setText("Hallo geänderte Welt");
    }

}

 

[diggaa1984]

im zweifelsfall musst du der Unterunterklasse ja noch die Hauptklasse bekannt machen, die stehen ja alle in keiner Beziehung zueinander.

Hauptklassen, Unterklasse, Unterunterklasse .. bist du sicher das du nicht nach etwas wie Vererbung suchst und protected deklarierten Variablen!?

 

[Antoras]

Wenn ich die Hauptklasse der Unterunterklasse über deren Konstruktor bekannt mache, dann bekomme ich Probleme mit meiner Unterklasse.

Ob ich dafür lieber auf Vererbung zurückgreifen sollte weiß ich nicht so richtig. Sinn des ganzen soll halt sein, dass ich ein in der Hauptklasse ein GUI hab, in der Unterklasse meine Logik und in den Unterunterklassen Teile der Logik, auf die die Unterklasse zurückgreifen kann (zur besseren Übersicht).

 

[diggaa1984]

naja aber da hast doch schon die hierarchie gegeben:

Hauptklasse wird ein wenig durch Unterklasse beeinflusst (Logik führt zu Änderungen in der Anzeige der Hauptklasse). Da die Unterunterklasse nun Teillogiken auslagert, würde ich hier gar kein Zugriff auf die Hauptklasse vornehmen, sondern dabei über die Unterklasse gehen (Eventuell müsstest du mal ein Beispiel geben was in etwa in er Unterklasse passiert und was in der Unterunterklasse).

Somit hast ne Kopplung:
Hauptklasse - Unterklasse und
Unterklasse - Unterunterklasse

Und Vererbung wäre hier in der Tat verkehrt, das stimmt.

Du könntest auch das JLable aus der Unterklasse heraus an die Unterunterklasse als Parameter übergeben, aber auch das finde ich nicht wirklich schön gelöst, da du ja dann wieder indirekte Kopplung zur GUI hast

Denkbar wäre es ja durch die Unterunterklasse an Daten heranzukommen und in der Unterklasse diese nur noch auf der GUI zu verteilen oder dergleichen.

 

[Antoras]

Ich glaube, es ist am besten einfach von der Unterunterklasse aus auf die Unterklasse und von dort aus auf die Oberklasse aus zuzugreifen. Ich erstelle dafür einfach eine neue Methode, die dann die Label-Beschriftung ändert:

public class Unterklasse {
    
    private Hauptklasse hauptklasse = null;
    private Unterunterklasse unterunterklasse = null;
    
    public Unterklasse(Hauptklasse hauptklasse) {
        unterunterklasse = new Unterunterklasse(this);
        this.hauptklasse = hauptklasse;
    }
    
    public void actionButton() {
        unterunterklasse.doSomething();
    }
    
    public void changeLabel() {
        hauptklasse.label.setText("Label geändert");
    }

}

public class Unterunterklasse {
    
    private Unterklasse unterklasse;
    
    public Unterunterklasse(Unterklasse unterklasse) {
        this.unterklasse = unterklasse;
    }
    
    public void doSomething() {
        unterklasse.changeLabel();
    }

}

Die Hauptklasse ist gleich geblieben.

Sinn des ganzen war ein Adressbuch, dessen Hauptklasse das GUI beinhaltet. Mit der Unterklasse hole ich die auf dem GUI eingegebene Daten und leite sie an die Unterunterklasse weiter, die wiederum die Daten in eine Datei speichert. Das gleiche trifft auch auf das Laden der Daten zu: Eine weitere Unterunterklasse lädt die Daten aus der Datei, gibt die an die Unterklasse weiter, welche sie dann auf dem GUI ausgibt.
Mit dem Label wollte ich dem Anwender Rückmeldung geben ob irgendwas und was passiert ist.
Das wollte ich aber erst dann machen wenn die Daten wirklich gespeichert wurden - deshalb der Aufruf über die Unterunterklasse.

So wie es jetzt ist ist es wohl am besten. Die Unterklasse verwaltet alle Daten und die Unterunterklassen machen damit irgendwas.

 

[diggaa1984]

du kannst doch mit Rückgabewerten oder Exception-Weiterleitung in der Unterunterklasse arbeiten und je nachdem was Eintritt hat die jeweilige Verarbeitung geklappt oder nicht .. ich würde diese Analyse der Entscheidung nicht in der Unterunterklasse lassen. Sie arbeitet nur mit irgendlwelchen Daten und kann Aufschluss darüber geben ob das erfolgreich war oder nicht. Was bei jeweiliger Situation passiert, ob was in der GUI angezeigt wird oder nicht ist in der Unterklasse besser aufgehoben. Und auch besser für dich wartbar, wenn das Programm komplexer wird.

 

[Antoras]

Stimmt, so könnte ich es machen. Was wäre da die beste Vorgehensweise? Einfach in der Unterunterklasse ein Attribut mit einem bestimmten Wert zurückgeben und in der Unterklasse dann dieses Attribut mit ner Mehrfachverzweigung überprüfen? Oder gibt es da einen bestimmten Befehl, mit dem man den Rückgabewert einer Methode direkt auslesen kann?

 

[diggaa1984]

hm wie du es machst is dir überlassen, den rückgabewert der methode bekommst ja beim aufruf der methode zurück also ...

[COLOR="DarkRed"][B]public void[/B][/COLOR] foo() {
    //impliziert boolean als Rückgabewert
    [COLOR="#8b0000"][B]if[/B][/COLOR] ([COLOR="RoyalBlue"]unterunterklasse[/COLOR].bar()) {
        <hat geklappt>
    } [COLOR="#8b0000"][B]else[/B][/COLOR] {
        <hat nich geklappt>
    }
}

//in unterunterklasse dann
[COLOR="#8b0000"][B]public boolean[/B][/COLOR] bar() {
     <bearbeitung der daten und [COLOR="DarkRed"]return true[/COLOR] oder [COLOR="#8b0000"]return false[/COLOR] nutzen>
}
-------------------------

[COLOR="#8b0000"][B]public void[/B][/COLOR] fooo() {
    [COLOR="#8b0000"][B]try[/B][/COLOR] {
        [COLOR="#4169e1"]unterunterklasse[/COLOR].barr();
    } [COLOR="#8b0000"][B]catch[/B][/COLOR] (Exception e) { //eventuell speziellere Exception angeben
        <Fehler bei Bearbeitung>
    }
}

//in unterunterklasse dann
[COLOR="#8b0000"][B]public void[/B][/COLOR] barr() [COLOR="#8b0000"][B]throws[/B][/COLOR] Exception {
    <bearbeitung von daten und weiterleitung einer exception oder werfen einer neuen>
}

kannst selbstverständlich alles mögliche als Rückgabewert verwenden

 

[Antoras]

Ich hab statt if-else lieber switch-case genommen, da ich mehr als zwei Rückgabewerte habe. Aber das ist ja nebensächlich...

Hast mir auf jeden Fall sehr geholfen. Danke dir

Ach ja: Wie hast den Code-Block farbig bekommen?

 

[diggaa1984]

markieren und Schriftfarben/-stil aendern ^^

 

[Antoras]

pöh, da bin ich dann ja ne halbe Stunde beschäftigt bis ich mal einen Beitrag posten kann.
Vielleicht ist aber ja jemand hier, der JavaScript beherrscht. Der könnte ja ein Addon für Firefox schreiben, das auf Knopfdruck die Codes einfärbt. Würde es selber machen, aber von JS hab ich keine Ahnung...

Aber vielleicht haben wir ja Glück und das Forum hier erfährt bald ein Update. Schwarz-weiß-Beiträge sehen so trostlos aus.