Zusammenfassung von Klassen (Vererbung? Abstrakte Klass? ...?)

[dflasjjs]

Hi,

ich habe insgesamt 6 solcher Klassen. Alle nur eben mit anderen Objekten, also nicht Action, sondern irgendeine andere Klasse.
Ansonsten sind sie, bis auf ein paar Kleigkeiten wie removeAction(String name) heisst dann in der anderen Klasse removeAction(String account), also immer das wo durch man die Klasse identifizieren kann.

Nun ist meine Frage, kann ich die irgendwie zusammenfassen?
Ich habe z.B. gedacht, eine Oberklasse, die dann beerbt wird.

Oder wie mach ich das am besten?

[HIGHLIGHT="Java"]import java.util.Vector;

public class Actions {
private Vector<Action> actions;



public Actions() {
super();
}


public final Vector<Action> getActions() {
if (actions == null) actions = new Vector<Action>();
return actions;
}


public Action getAction(String name) {
int idx = getActions().indexOf(new Action(name));
if (idx < 0) return null;
return getActions().get(idx);
}


public boolean removeAction(String name) {
return getActions().remove(new Action(name));
}


public boolean addAction(Action action) {
if (getActions().contains(action)) return false;
return getActions().add(action);
}


public int size() {
return getActions().size();
}

public String toString() {
return this.getActions().toString();
}
}
[/HIGHLIGHT]

 

[tfa]

Generics!

[HIGHLIGHT="Java"]public class MeinTollerVectorWrapper<T> {
private Vector<T> items;
....[/HIGHLIGHT]

Nimm aber besser List und eine entsprechende Implementierung wie ArrayList statt Vector. Das ist schöner.

 

[Spacerat]

Im Forum steht hier irgendwo jüngst die Annahme zu lesen, das "Interfaces" nur "Schreibaufwand" sind... glaub' denen nicht... den genau diese bieten sich hier an.

(edit: ja... genau... besser noch generische Interfaces... immer diese Überschneidungen beim posten...)

 

[tfa]

Die Frage ist, warum sollte man hier überhaupt einen Vector wrappen? Nur, damit man die Methode removeAction, removeDies, removeDas nennen kann?

 

[Spacerat]

Moment... etwa so?

public class ActionList<T extends Action>
extends ArrayList<T> // klappt natürlich auch mit Vector<T>
{
}

public interface Action
{
  void actionPerformed()
}

 

[tfa]

Dann wohl eher so:

[HIGHLIGHT="Java"]public class ActionList extends ArrayList<Action> // klappt natürlich auch mit Vector<T>
{
}[/HIGHLIGHT]
typedef durch Vererbung ???:L

 

[dflasjjs]

Die Frage ist, warum sollte man hier überhaupt einen Vector wrappen? Nur, damit man die Methode removeAction, removeDies, removeDas nennen kann?

Hmmm, okay... wie mache ich es denn ansonsten?

Hier mal mein Programm:

[HIGHLIGHT="Java"]
import java.util.Locale;
import java.util.Vector;
public class Manager {


private Trends trends;
private Divisions divisions;



public void initialize() {
trends = new Trends();
divisions = new Divisions();
}

public Manager() {
super();
this.initialize();
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

public Trends getTrends() {
return trends;
}

public void setTrends(Trends trends) {
this.trends = trends;
}


public Divisions getDivisions() {
return divisions;
}

public void setDivisions(Divisions divisions) {
this.divisions = divisions;
}
}

[/HIGHLIGHT]
Trends:
[HIGHLIGHT="Java"]import java.util.Vector;

public class Trends {
private Vector<Trend> trends;


/*
* constructor
*/
public Trends() {
super();
}


public final Vector<Trend> getTrends() {
if (trends == null) trends = new Vector<Trend>();
return trends;
}


public Trend getTrend(String name) {
int idx = getTrends().indexOf(new Trend(name));
if (idx < 0) return null;
return getTrends().get(idx);
}


public boolean removeTrend(String name) {
return getTrends().remove(new Trend(name));
}


public boolean addTrend(Trend trend) {
if (getTrends().contains(trend)) return false;
return getTrends().add(trend);
}


public int size() {
return getTrends().size();
}

public String toString() {
return this.getTrends().toString();
}
}
[/HIGHLIGHT]

Divisions eben genau so.
Wie würdest du denn das machen? Direkt in die Manager-Klasse Vector<Trend> als Typ nehmen? Wenn ja, packst du dann die ganzen Methoden wie
[HIGHLIGHT="Java"] public Trend getTrend(String name) {
int idx = getTrends().indexOf(new Trend(name));
if (idx < 0) return null;
return getTrends().get(idx);
}[/HIGHLIGHT]

Auch in die Manager-Klasse oder wie kann ich mir das vorstellen?

 

[mvitz]

In dem Fall würde ich es einfach mit zwei Maps machen:

[HIGHLIGHT="Java"]Map<String, Trends> trends;
Map<String, Divisions> divisons;[/HIGHLIGHT]

Dann brauchst du keine deiner Methoden.

Edit:
Und wie schon gesagt, man sollte als Typ Vector möglichst vermeiden, wenn du unbedingt Vector benutzen möchtest, dann
[HIGHLIGHT="Java"]List<Type> x = new Vector<Type>();[/HIGHLIGHT]

 

[tfa]

...Auch in die Manager-Klasse oder wie kann ich mir das
vorstellen?

Ja, genau so.
Der Tipp mit den Sets ist auch nicht schlecht.