✔ Oberklasse für gleiche JFrames

[-Tom-Tom-]

Hallo alle zusammen,

ich möchte mehrere JFrames erstellen deren Aussehen prinzipiell gleich ist. Alle besitzen eine TitelArea in der ein Icon sitzen soll und dazu noch ein wenig Text.
Nun wollte ich dafür eine Oberklasse bauen die mir einen JFrame erstellt der als grund gerüst dienen soll. Nun aber meine Frage. Wie kann ich den anderen JFrame Klassen klar machen das sie von der Oberklasse erben sollen. Bzw wie muss die Oberklasse aussehen. Mir fehlt wirklich jeder Ansatzpunkt.

danke schon mal für die Antworten ;o)

 

[hammet]

Das sollte dir vielleicht etwas helfen:
http://krum.rz.uni-mannheim.de/pk1-2002w/sess-39.html

Naja die Hauptklasse muss eben Methoden bereitstellen, die dir die gewünschten Objekte zurückliefert. Aus denen kannst du dann dein Grundgerüst bauen.

 

[-Tom-Tom-]

Ach na klar...
danke für den Tipp. Ich weiß jetzt wie ich es mache. Meine Oberklasse erbt wie extends JFrame und stellt via Getter und Settermethoden alle wichtigen Eigenschaften zu Verfügung. Dann lasse ich meine einzelnen JFrames wieder via extends Oberklasse von der Oberklasse erbenen und stelle dann mit setMethode() die Parameter ein....

Also das Thema hätte sich damit auch geklärt..

Danke noch mal ;o)

 

[Akeshihiro]

Also ich hätte es so gemacht:

Erstmal eine Art GrundFrame, wo schon alle gemeinsamen Elemente vorhanden sind. Das Fenster sollte also auch schon funktionsfähig sein, nur eben ohne Inhalt.
Dann würde ich davon nen neues Fenster ableiten und dort würden dann die fehlenden Inhalte reinkommen, und damit meine ich nicht unbedingt Text, sondern Elemente, die die anderen Frames eben nicht gemeinsam haben.

In meinem Beispiel habe ich als Grundlage eine Überschrift, eine Liste und eine Spielwiese eingefügt. In der Spielwiese können die "neuen" Frames sich austoben.

Hier die Codes:
Main.java

package main;

public class Main {
	public static void main(String[] args) {
		TemplateFrame wnd = new TemplateFrame();
		//TemplateFrame wnd = new FirstFrame();
		//TemplateFrame wnd = new SecondFrame();
		wnd.setVisible(true);
	}
}

TemplateFrame.java

package main;

import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;

import java.util.*;

public class TemplateFrame extends JFrame {
	public final static long serialVersionUID = 1L;
	
	protected JLabel ueberschriftLabel = null;
	protected JList auswahlList = null;
	protected Vector<String> liste = null;
	protected JPanel mainPanel = null;
	
	public TemplateFrame() {
		super();
		
		// Paar Einstellungen
		this.setLayout(null);
		this.setSize(500, 300);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocation((Toolkit.getDefaultToolkit().getScreenSize().width - this.getWidth()) / 2, 
						(Toolkit.getDefaultToolkit().getScreenSize().height - this.getHeight()) / 2);
		
		initialize();
	}
	
	private void initialize() {
		/*
		 * Grundelemente einfügen
		 */
		Container cp = this.getContentPane();
		
		// Ganz oben ein Label für die Überschrift
		ueberschriftLabel = new JLabel();
		ueberschriftLabel.setLocation(0, 0);
		ueberschriftLabel.setSize(490, 35);
		ueberschriftLabel.setHorizontalAlignment(JLabel.CENTER);
		ueberschriftLabel.setText("Überschrift");
		cp.add(ueberschriftLabel);
		
		// Auf der linken Seite noch eine Liste
		auswahlList = new JList();
		auswahlList.setLocation(0, 40);
		auswahlList.setSize(150, 225);
		liste = new Vector<String>();
		liste.add("Item1");
		liste.add("Item2");
		auswahlList.setListData(liste);
		auswahlList.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
		cp.add(auswahlList);
		
		// Jetzt kommt die Hauptarbeits-Fläche
		mainPanel = new JPanel();
		mainPanel.setLayout(null);
		mainPanel.setLocation(160, 40);
		mainPanel.setSize(325, 225);
		mainPanel.setBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED));
		cp.add(mainPanel);
	}
}

FirstFrame.java

package main;

import javax.swing.*;

public class FirstFrame extends TemplateFrame {
	public final static long serialVersionUID = 1L;
	
	public FirstFrame() {
		super();
		
		initialize();
	}
	
	private void initialize() {
		// Überschrift setzen
		ueberschriftLabel.setText("Das ist FirstFrame");
		
		// Ein Textfeld
		JTextField tf = new JTextField();
		tf.setLocation(5, 5);
		tf.setSize(150, 25);
		mainPanel.add(tf);
		
		// Und noch nen Button
		JButton bt = new JButton("Ich bin ein Button");
		bt.setLocation(5, 30);
		bt.setSize(150, 25);
		mainPanel.add(bt);
	}
}

SecondFrame.java

package main;

import java.awt.*;
import javax.swing.*;

public class SecondFrame extends TemplateFrame {
	public final static long serialVersionUID = 1L;
	
	public SecondFrame() {
		super();
		
		initialize();
	}
	
	private void initialize() {
		// Überschrift setzen
		ueberschriftLabel.setText("Das ist SecondFrame");
		
		// Nen dummes Label
		JLabel lb = new JLabel("Hallo und so");
		lb.setLocation(30, 30);
		lb.setSize(150, 25);
		lb.setOpaque(true);
		lb.setBackground(new Color(50, 150, 250));
		mainPanel.add(lb);
		
		// Listeneinträge etwas ändern
		liste.clear();
		liste.add("Oma");
		liste.add("Opa");
		liste.add("Mamma");
		liste.add("Papa");
		liste.add("Sohn");
		liste.add("Tochter");
		liste.add("Hund");
		liste.add("Katze");
	}
}

Screens sind als Anhänge angefügt...

 

[hungbao]

Eine Oberklasse ist nicht immer die beste Lösung. Du könntest dir auch einen Erzeuger schreiben, der die verschiedenen Frames parametergesteuert erstellt.

zB

public class FrameErzeuger_version1 {


public static JFrame gibFrame ( /*diverse parameter*/){

JFrame frame = new JFrame(){
/*
diverse Initialisierungen je nach den übergebenen
Parametern */
return frame;
}

oder wenn die Frames keine besonderen Parameter brauchen sondern Frames der gleichen Art auf die gleiche Weise erzeugt werden können und wenn nicht jede Art Frame die gleiche Art und Anzahl Parameter benötigt, dann kannst du den Aufruf auch etwas bequemer über einen enum-Parameter machen.



public class FrameErzeuger_version2 {


public enum frameType { FRAME_TYPE1, FRAME_TYPE2, FRAME_TYPE3
/* u.s.w. */ }

public static JFrame gibFrame ( frameType type ) {

JFrame frame ) = new Frame();

// Initialisierungen, die für alle Framearten
// gleich sind

switch (type) {
case FRAME_TYPE1 : iniFrameType1(frame); break;
case FRAME_TYPE2 : iniFrameType2(frame); break;
// u.s.w.
}

return frame;
}

private static void iniFrameType1( JFrame frame){
// initialisierungen
}

private static void iniFrameType2 ( JFrame frame) {
// initialisierungen
}

// u.s.w.


}

So vermeide ich, eine an sich schon mächtige Klasse wie Frame oder JFrame schon ist, noch weiter aufzublähen. Je tiefer abgeleitet wird, desto unhandlicher wird die Klasse. Ableitung ist deshalb nur in bestimmten Fällen die richtige Lösung.

Zu diesem Thema sollte man sich mal mit Entwurfsmustern oder Design Patterns beschäftigen.