Eigene Java Klasse für allgemeine Grafikelemente

[MJannek]

Hallo Zusammen,
ich möchte mir eine eigene Klasse für allgemeine Grafikelemente in Java erstellen. Ich habe mir derzeit folgendes Interface erstellt.

public interface SwingUtilsX {
    void setColor(Component comp);
    void setColor(Color f, Color b);
    void invertColors();
    void setFont(Component comp);
    void clear();
    void centerText();
    void toUpper();
    void toLower();
    void toNormalText();
    void setStats(Font font, Color f, Color b) ;
    void setStats(Component comp);
    void setStats(Component comp, Font font);
    void setStats(Font font);
    void setStats(Component comp, Color f, Color b);
    void addToFrame(JFrame frame);
    void addToPanel(JPanel panel);
    void enabled();
    void notEnabled();
    void LEFT();
    void RIGHT();
    void CENTER();
    int getXW();
    int getYH();
    void setBounds(int x, int y, Component comp);
    void setBounds(int x, int y, int size);
    void setBounds(Bounds b);
    void setBounds(Component comp);
    void setBounds(int x);
    void setBounds(int x, int y);
}

Dieses rufe ich derzeit in jeder meiner gewünschten Klassen über implements auf und schreibe überall den identischen Code rein. Eigentlich möchte ich mir eine eigene Klasse dafür erstellen. ich weiß jedoch nicht, von welcher Klasse ich erben muss um die Standardmethoden setBounds, setBackground, setOpaque, etc außerdem nutzen zu können. Ich möchte den weiterführend meine eigenen Klassen FrameX, LabelX, ButttonX, PanelX, ComboBoxX<E> erstellen, die von dieser neuerstellten Klasse erben sollen.

LG Markus

k

 

[Robert Zenz]

Ohje, da hast du was vor.

Es gibt in Java keine multiple Vererbung, also eine Klasse kann immer nur von einer Klasse erben. Also wenn du jetzt gerne das JLabel erweitern willst mit deiner Schnittstelle zu einem LabelX, dann kannst du nicht noch eine AbstractSwingX Klasse haben von dem die Sache erbt. Also musst du Code duplizieren. Da gibt es jetzt ein paar Moeglichkeiten. Entweder du hast du entsprechenden Funktionen in einer externen Klassen:

public class LabelX extends JLabel implements SwingX {
    @Override
    public void toNormalText() {
        setText(StaticSwingUtilityX.toNormalText(getText()));
    }
}

Oder in einer Klasse die eine beliebige Component uebernimmt und dann auf der arbeitet:

public class LabelX extends JLabel implements SwingX {
    protected SwingUtilityX swingUtilityX = new SwingUtilityX(this);

    @Override
    public void toNormalText() {
        swingUtilityX.toNormalText();
    }
}

Letzteres wird vermutlich das beste werden.

 

[MJannek]

Ohje, da hast du was vor.

Es gibt in Java keine multiple Vererbung, also eine Klasse kann immer nur von einer Klasse erben. Also wenn du jetzt gerne das JLabel erweitern willst mit deiner Schnittstelle zu einem LabelX, dann kannst du nicht noch eine AbstractSwingX Klasse haben von dem die Sache erbt. Also musst du Code duplizieren. Da gibt es jetzt ein paar Moeglichkeiten. Entweder du hast du entsprechenden Funktionen in einer externen Klassen:

public class LabelX extends JLabel implements SwingX {
    @Override
    public void toNormalText() {
        setText(StaticSwingUtilityX.toNormalText(getText()));
    }
}

Oder in einer Klasse die eine beliebige Component uebernimmt und dann auf der arbeitet:

public class LabelX extends JLabel implements SwingX {
    protected SwingUtilityX swingUtilityX = new SwingUtilityX(this);

    @Override
    public void toNormalText() {
        swingUtilityX.toNormalText();
    }
}

Letzteres wird vermutlich das beste werden.

Ich weiß, das es keine Mehrfachvererbung gibt.
Ich möchte es wie folgt darstellen

public class ComponentX extends KlasseNochUnkannt{
    public void myMethod1(){
        
    }
    public void myMethod2(){
        
    }
}

public class LabelX extends ComponentX{
    
}
public class ButtonX extends ComponentX{
    
}
usw

Aus KlasseNochUnkannt möchte ich mir die obigen Standardmethoden holen

 

[Robert Zenz]

Dann mach' dir eine abstrakte Klasse:

public abstract class AbstractSwingX implements SwingX {
    @Override
    public void toNormalText() {
        // Logic goes here.
    }
}

public class LabelX extends AbstractSwingX {
}

Oder alternativ sowas:

public abstract class SwingX extends Component implements SwingX {
    // Abstract implementation.
}

 

[M.L.]

Mehrfachvererbung

Das liesse sich über (mehrere) Interfaces simulieren. Generell gibt es bei den SOLID-Prinzipien z.B. die Empfehlung "Avoid inheritance, favor composition instead" (Interface-Segregation-Prinzip). Ist bei den potentiellen Vor- und Nachteilen aber auch eine Abwägungssache.

 

[mihe7]

Ich verstehe zwar den Sinn dahinter nicht, aber für meine Begriffe ist das einfach ein Adapter.

Skizze:

Ein allgemeines Element möglichst unabhängig vom Framework

interface Element {
    void setColor(Element elem); // hier ohne Component
    void setColor(Color f, Color b); // Color muss nicht zwangsweise dei AWT-Color sein, nehme ich aber einfach mal an
    // ...
}

Element, abhängig von AWT:

interface AWTElement extends Element {
    Component getComponent(); // jetzt mit AWT

    default void setColor(Element elem) {
        if (!(elem instanceof AWTElement)) return; // oder Exception
        Component comp = ((AWTElement) elem).getComponent();
        setColor(comp.getForeground(), comp.getBackground());        
    }

    default void setColor(Color f, Color b) { 
        getComponent().setForeground(f);
        getComponent().setBackground(b);   
    }
}

Eine Standardimplementierung.

public class DefaultAWTElement implements AWTElement {
    private final Component component;

    public DefaultAWTElement(Component component) { this.component = component; }

    public Component getComponent() { return component; }

    // ...
}

Es kann weitere Implementierungen geben, z. B. um Texte zu formatieren. Dann kann man sich eine Factory basteln, die je nach Komponente die richtige Implementierung wählt. In Verwendung könnte dann das etwa so aussehen:

AWTElementFactory factory = new AWTElementFactory();

Element label = factory.createElement(new JLabel("X"));
Element textField = factory.createElement(new JTextField(20));

label.setColor(Color.RED, Color.WHITE);
textField.setColor(label);

 

[MJannek]

Ich verstehe zwar den Sinn dahinter nicht, aber für meine Begriffe ist das einfach ein Adapter.

Skizze:

Ein allgemeines Element möglichst unabhängig vom Framework

interface Element {
    void setColor(Element elem); // hier ohne Component
    void setColor(Color f, Color b); // Color muss nicht zwangsweise dei AWT-Color sein, nehme ich aber einfach mal an
    // ...
}

Element, abhängig von AWT:

interface AWTElement extends Element {
    Component getComponent(); // jetzt mit AWT

    default void setColor(Element elem) {
        if (!(elem instanceof AWTElement)) return; // oder Exception
        Component comp = ((AWTElement) elem).getComponent();
        setColor(comp.getForeground(), comp.getBackground());       
    }

    default void setColor(Color f, Color b) {
        getComponent().setForeground(f);
        getComponent().setBackground(b);  
    }
}

Eine Standardimplementierung.

public class DefaultAWTElement implements AWTElement {
    private final Component component;

    public DefaultAWTElement(Component component) { this.component = component; }

    public Component getComponent() { return component; }

    // ...
}

Es kann weitere Implementierungen geben, z. B. um Texte zu formatieren. Dann kann man sich eine Factory basteln, die je nach Komponente die richtige Implementierung wählt. In Verwendung könnte dann das etwa so aussehen:

AWTElementFactory factory = new AWTElementFactory();

Element label = factory.createElement(new JLabel("X"));
Element textField = factory.createElement(new JTextField(20));

label.setColor(Color.RED, Color.WHITE);
textField.setColor(label);

Ich möchte in Java in meine erweiterten Klassen überall die gleichen Methoten hinzufügen (indentische Methodensignator und identischer Methodenrumpf. In eine, Interface kann ich jedoch nur die Methodenköpfe(Signaturen) definiern. Ich möchte mir die ganzen Methoden nur einmal definieren, in irgendeiner Klasse, von der ich dann erbe

 

[KonradN]

Ich möchte in Java in meine erweiterten Klassen überall die gleichen Methoten hinzufügen (indentische Methodensignator und identischer Methodenrumpf. In eine, Interface kann ich jedoch nur die Methodenköpfe(Signaturen) definiern. Ich möchte mir die ganzen Methoden nur einmal definieren, in irgendeiner Klasse, von der ich dann erbe

Da ist dann die Frage, was genau diese Methoden machen / brauchen.

Denkbar sind z.B. in einem Interface default Methoden. Alles, worauf diese zugreifen, erfolgt dann z.B. über Getter, die ggf. abstrakt deklariert sind.

Aber generell solltest Du über #6 (Adapter) und #5 (FCoI: Favour Composition over Inheritance) nachdenken. Denn der rein objektorientierte Ansatz über Vererbung ist oft nicht das, was wirklich zielführend ist. Also selbst, wenn ich zuvor eine technische Möglichkeit genannt habe, ist das aus meiner Sicht nicht das, was ich machen würde.

 

[mihe7]

Ich möchte in Java in meine erweiterten Klassen überall die gleichen Methoten hinzufügen (indentische Methodensignator und identischer Methodenrumpf. In eine, Interface kann ich jedoch nur die Methodenköpfe(Signaturen) definiern. Ich möchte mir die ganzen Methoden nur einmal definieren, in irgendeiner Klasse, von der ich dann erbe

Das macht der Code ja auch weitgehend - allerdings wirst Du nicht überall die gleiche Implementierung haben können, weil z. B. nicht jede Komponente eine Methode "setText" hat.