Generics und Vererbung

[kaoZ]

Ich spiele grade beim Refactoring mit Generics rum, und habe meine Konzepte nochmal überdacht,

ich haben eine Klasse angelegt die meine Daten in Form eines VO's halten soll, diese Klasse ist generisch :

import java.io.Serializable;
import java.util.ArrayList;

@SuppressWarnings("serial")
public class ValueObject<T> implements Serializable{

	private ArrayList<T> data;
	
	public ValueObject(){
		init();
	}
	
	public ValueObject(ArrayList<T> list){
		data = list;
	}
	
	@SafeVarargs
	public ValueObject(T...t){
		this();
		if(t.length > 0) {
			for (int i = 0; i < t.length; i++) {
				data.add(t[i]);
			}
		}
	}
	
	private void init(){
		data = new ArrayList<>();
	}
	
	public ValueObject<T> copy(){
		return new ValueObject<>(getData());
	}
	
	@Override
	public boolean equals(Object o){
		
		boolean val = false;
		
		ValueObject<?> other = (ValueObject<?>) o;
		
		for (int i = 0; i < data.size(); i++) {
			if(data.size() == 0) {
				val = this == other;
			}
			val = data.get(i) == other.get(i);
		}
		return val;
	}
	
	public ArrayList<T> getData()			{return data;}
	public int getSize()					{return data.size();}
	public T get(int index)					{return data.get(index);}
}

Ich möchte eigentlich den Typ des ValueObjectes erst in der jeweiligen Spezialisierung festlegen , oder sollte ich dazu übergehen dann wirklich in jeder Speziealisierung ein eigenes VO zu halten ? Was eigentlich nicht mein Ziel war . 🙂

Ein Object dieser Klasse möchte ich nun in einer abstrakten klasse als Attribut verwenden :

import java.io.Serializable;
import editor.valueObjects.ValueObject;

@SuppressWarnings("serial")
public abstract class Entity implements Serializable{
	
	public static int ID = 1;

	protected ValueObject<? extends Object> valueObject;
	
	public Entity(Object...objects){
		valueObject = new ValueObject<>(objects);
	}
	
	public Entity(ValueObject<? extends Object> obj){
		valueObject = obj;
	}
	
	public abstract int getID();
	public abstract Entity copy();
	public abstract String getSaveName();
	
	public ValueObject<? extends Object> getValueObject()	{return valueObject;}
}

Hiervon möchte ich nun Subklassen erstellen :

wie z.B Client oder auch User ,

die Frage ist nun , wie kann ich , bis auf das Verwenden einer Wildcard nun z.B im Konstruktor der noch nicht aufgeführten Klasse User/Client festlegen das hier nur Strings im Konstruktor übergeben werden dürfen ?

Muss ich tatsächlich alle Argumente Casten ? oder gibt es da einen schöneren Weg als das hier :

@SuppressWarnings("serial")
public class Client extends Entity{

	
	public Client(String...input){
		super(input); // <--- hier sagt er mir ich müsste die Varags auf Object Casten 
		
		/*
		 * gibt es keine Möglichkeit dies anders zu realisieren außer die Klasse 
		 * Entity/Client selbst Generisch zu machen ?
		 * Oder muss ich Casten ?
		 */
	}
	
	@Override
	public int getID(){
		return 0;
	}

	@Override
	public Entity copy(){
		return null;
	}

	@Override
	public String getSaveName(){
		return null;
	}

}

ich dachte da ich in Entity eh mit <? extends Object> arbeite müsste ich nicht zwingend Casten, aber pustekuchen... also muss ich wohl tatsächlich Client/Entity als Generisch deklarieren oder ?

EDIT

Ich müsste ja bereits hier den Konstruktor anders deklarieren sonst lege ich mich ja schon auf Object fest....

public Entity(Object...objects){
   valueObject = new ValueObject<>(objects);
}

aber wie wenn Entity nicht generisch ist ^^ ?

Sprich kann ich ja nicht einfach T...t verwenden , da der Platzhalten in Entity nicht bekannt ist.

Wenn ich Entity einfach als Generisch deklariere funktioniert das reibungslos, da ich einfach den Platzhalter übergebe :

import java.io.Serializable;
import editor.valueObjects.ValueObject;

@SuppressWarnings("serial")
public abstract class Entity<T> implements Serializable{
	
	protected static int ID = 1;

	protected ValueObject<T> valueObject;
	
	@SafeVarargs
	public Entity(T...t){
		valueObject = new ValueObject<>(t);
	}
	
	public Entity(ValueObject<T> obj){
		valueObject = obj;
	}
	
	public abstract int getID();
	public abstract Entity<T> copy();
	public abstract String getSaveName();
	
	public ValueObject<? extends Object> getValueObject()	{return valueObject;}
}

und dann in Client

@SuppressWarnings("serial")
public class Client extends Entity<String>{
	
	public Client(String...input){
		super(input); 
	}
	
	@Override
	public int getID(){
		return 0;
	}

	@Override
	public Entity<String> copy(){
		return null;
	}

	@Override
	public String getSaveName(){
		return null;
	}

}

Ist das so gewollt oder gibt es da noch einen anderen Weg ?

Sinn dahinter ist das ich nachher nicht bei den ganzen Settern jedes Feld wie z.B
in der Klasse Client

public String getName()	{return valueObject.get(0);}

auf den Rückgabetyp Casten muss....

 

[Joose]

Soweit ich weiß gibt es hier glaub ich keinen anderen Weg.
Aber ich finde diesen auch nicht so schlecht, oder gibt das bei dir woanders Probleme?

 

[kaoZ]

Also ich hab jetzt folgendes gemacht :

import java.io.Serializable;
import editor.valueObjects.ValueObject;

@SuppressWarnings("serial")
public abstract class Entity<T> implements Serializable{
	
	protected static int ID = 1;

	protected ValueObject<T> valueObject;
	
	@SafeVarargs
	public Entity(T...t){
		valueObject = new ValueObject<>(t);
	}
	
	public Entity(ValueObject<T> obj){
		valueObject = obj;
	}

	
	public abstract int getID();
	public abstract Entity<T> copy();
	public abstract String getSaveName();
	
	
	public T get(int index) 			{return valueObject.get(index);}
	public ValueObject<T> getVO()		{return valueObject;}
}

Client

import editor.valueObjects.ValueObject;


@SuppressWarnings("serial")
public class Client extends Entity<String>{
	
	private int id;
	
	public Client(String...input){
		super(input);
		id = ID++;
	}
	
	public Client(ValueObject<String> obj){
		super(obj);
	}
	
	@Override
	public int getID(){
		return id;
	}

	@Override
	public Entity<String> copy(){
		return new Client(getVO());
	}

	@Override
	public String getSaveName(){
		return null;
	}
	
	@Override
	public boolean equals(Object o){
		if(o == null) {
			return false;
		}		
		Client other = (Client) o;

		return this.getVO().equals(other.getVO());
	}

	public String getName()				{return get(0);}
}

und das scheint bis jetzt ganz gut zu funktionieren 🙂 ich wollte halt eigentlich ein Generisches Objekt ohne mich auf einen Typ festlegen zu müssen in einer Nicht Generischen Abstrakten Klasse verwenden, das macht es aber echt kompliziert , und führt zu unzähligen Casts in einer Spezialisierung.....

Das hier schaut doch zumindest bis jetzt ganz gut aus :

public class Main{

	public static void main(String[] args) throws Exception{
		
		Entity<String> e = new Client("Max","Müller");
		
		Entity<String> f = e.copy();
		
		System.out.println(e.equals(f));
		
		System.out.println(((Client)e).getFullName());
	}
}

Ausgabe :

true
Max Müller

Muss ich halt die Entität an der Stelle wo es nötig ist auf den Typ DownCasten 🙂

Dachte nur da gibts vielleicht eine schöne Möglichkeit anstatt Entity auch generisch zu machen .

Eigentlich isses auch nicht weiter wild , so bestimme ich halt über den Typ der Entität, den Typ des ValueObjektes.......scheint zumindest so ganz gut zu funktionieren,
mich stört halt nur da rein vom Logischen her ja nicht die Entität Generisch ist sondern halt das Value Object ^^

 

[kaoZ]

Das Sezialisieren des ValueObjektes in z.B ein ContactDataVO macht auch keinen Sinn da ich ja sonst doch dazu übergehen müsste den einzelnen Entitäten einen Spezialisierten Typ als als Attribut zu geben, also scheint es wohl tatsächlich der Beste Weg zu sein einfach die Entität Generisch zu deklarieren und einfach die Spezialisierungen vom Typ der Entität abhängig zu machen.

Aber das haut hin , geile S******e 😛

Ich wollte das ganze halt soweit wie möglich Abstrahieren 😉 Funzt !

So kann ich später einfach eine Komplette HashMap<String, Entity> ganz einfach Serialisieren und wieder einlesen 🙂

public class Main{

	@SuppressWarnings("serial")
	public static void main(String[] args) throws Exception{
		
		Entity<String> e = new Client("Max","Müller");
		
		SerializeUtil<Entity<String>> ser = new SerializeUtil<>();
		
		ser.save(e, "H:/Apps", e.getSaveName());
		
	}
}

EDIT

Gibt keine Möglichkeit mehr das Thema zu schließen ?