Model + ModelInterfaces

[pl4gu33]

Hey,...

ich beschäftige mich gerade genauer mit Interfaces,... ich hab gelesen, dass man z.b. Daten aus einer Persistenzschicht nicht einfach an die Anwendung hochschmeißt, sondern eher Interfaces benutzt. Also nicht nur für die Persistenzschicht allgemein sondern auch für die Persistenz Objekte

Das hab ich soweit auch alles hinbekommen,... nur die Art, wie ich es hinbekommen habe, mit 1000 Casts etc. finde ich nicht so schön... daher wollte ich fragen, ob ihr mir da bessere Ansätze empfehlen könnt?

Hier mal ein kleines Beispiel, da das richtige zuviel gewesen wäre

Interfaces:

public interface AdresseInterface {
	public String getOrt();
	public String getStraße();
	public PersonInterface getPerson();
}

public interface PersonInterface {
	public String getName();
	public List<AdresseInterface> getAdressen();
}

Klassen:

public class Adresse implements AdresseInterface{
	private String ort;
	private String straße;
	private Person person;
	
	public Adresse(String ort, String straße){
		this.ort=ort;
		this.straße=straße;
	}
	
	@Override
	public String getOrt() {
		// TODO Auto-generated method stub
		return ort;
	}

	@Override
	public String getStraße() {
		// TODO Auto-generated method stub
		return straße;
	}

	@Override
	public PersonInterface getPerson() {
		// TODO Auto-generated method stub
		return (PersonInterface) person;
	}
	
	public void setOrt(String ort){
		this.ort=ort;
	}
	
	public void setStraße(String straße){
		this.straße=straße;
	}
	
	public void setPerson(Person person){
		this.person=person;
	}

}

public class Person implements PersonInterface{
	private String name;
	private List<Adresse> adressen;
	
	public Person(String name){
		this.name=name;		
		adressen=new ArrayList<Adresse>();
	}
	
	@Override
	public String getName() {
		return name;
	}	

	@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	public List<AdresseInterface> getAdressen() {
		List<AdresseInterface> list= (List<AdresseInterface>)(List) adressen;
		return Collections.unmodifiableList(list);
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public void addAdresse(Adresse adresse){
		adressen.add(adresse);
		adresse.setPerson(this);
	}
}

 

[Logaff]

wenn ich mich nicht irre brauchst du doch nicht

@Override
    public PersonInterface getPerson() {
        // TODO Auto-generated method stub
        return (PersonInterface) person;

sondern eigentlich reicht als rückgabetyp Person und return person.

irre ich mich?

undwie override? im Interface ist doch garkeine getPerson() methode definiert o.0

 

[Clayn]

Den rückgabetyp ändern sollte nichtmal nötig sein, da ja Person das interface PersonInterface implementiert. D.h. dort wo PersonInterface gebraucht wird, geht jede Klasse die PersonInterface implementiert

 

[pl4gu33]

jap das stimmt

mir gehts aber eher um die Listen

 

[Logaff]

denn mach doch einfach eine Liste von Adressen?

warum nimmst du strikt überall die Interfaces o.0 das Leuchtet mir garnicht ein.

"3) Ein Interface beschreibt bestimmte "Fähigkeiten" von (i.d.R. mehreren) Objekten. Insofern werden Interfaces von Java-Entwicklern auch immer "....able" benannt, wie z.B. Clonable, Obserable, Serializable, Comparable, ...."

 

[pl4gu33]

wenn ich mich nicht irre brauchst du doch nicht

@Override
    public PersonInterface getPerson() {
        // TODO Auto-generated method stub
        return (PersonInterface) person;

...
undwie override? im Interface ist doch garkeine getPerson() methode definiert o.0

doch isse

allgemein zum Interface... es geht darum, einer bestimmten Instanz nur bestimmte Rechte auf die Klasse zu ermöglichen ...würde ich z.b. eine Liste Adressen übergeben, könnte man auf den Objekten rumfuschen wie man wollte.... das Beispiel is jetzt vll. schlecht gewählt aber es sollte nur verdeutlich, wie ich das mit den Casts umgesetzt hab und ob es da halt eine andere Lösung gibt

 

[Logaff]

sry ich dachte PersonInterface wurde implementiert^^

 

[Marcinek]

"3) Ein Interface beschreibt bestimmte "Fähigkeiten" von (i.d.R. mehreren) Objekten. Insofern werden Interfaces von Java-Entwicklern auch immer "....able" benannt, wie z.B. Clonable, Obserable, Serializable, Comparable, ...."

Das bezieht sich wohl nur auf eine kleine Menge von Interfaces. Sogenannter Markerinterface, die garkeine Methoden enthalten.

@TO:

ICh glaube du hast was grundlegendes im Zusammenhang mit Polymorphie nicht verstanden.

List<AdresseInterface> list= (List<AdresseInterface>)(List) adressen;

Also das hier ist schon echt derbe: Hier sind ZWEI cast hintereinander. Allein das istunnötig.

Des Weiteren braucht hier doch garkein cast zu kommen.

allgemein zum Interface... es geht darum, einer bestimmten Instanz nur bestimmte Rechte auf die Klasse zu ermöglichen ...würde ich z.b. eine Liste Adressen übergeben, könnte man auf den Objekten rumfuschen wie man wollte.... das Beispiel is jetzt vll. schlecht gewählt aber es sollte nur verdeutlich, wie ich das mit den Casts umgesetzt hab und ob es da halt eine andere Lösung gibt

Das ist KEIN Anwendungebiet der Polymorphie.

 

[pl4gu33]

okay, irgendwie stehe ich gerade auf dem Schlauch oder hab gerade ein großes Verständnisproblem,...
aber ich hab kein Problem damit, dass mir weitergeholfen wird


also mit dem Cast, das hab ich gegooglet und es lief,... aber es ist unschön wie ich finde aber wenn ich, wie du sagst, keinen Cast brauch klappt das nicht o0

du meinst so:

	public List<AdresseInterface> getAdressen() {
		return adressen;
	}

das gibt schon in Eclipse nen Fehler

Mir ist schon klar, dass ich für die Person oben keinen Cast brauche da er ja eh das Interface implementiert,... aber bei der Liste mag er das so nicht o0

mein eigentliches Ziel ist, dass ich ein Objekt rausgeben will, was halt nur bestimmte Methoden anbietet...aber das kann ich nicht über Public/Protected o.ä. regeln,... da später andere Klassen die außerhalb des Projektes sind setter teilweise benutzen dürfen ... jetzt mal von meinem Beispiel ab ...
Ziel ist es, dass ich z.b. eine Methode hab, die etwas aus einer DB lädt.... sagen wir eine Liste von Personen, diese sollen aber keine Setter benutzen und mir wurde dazu gesagt, dass ich dafür Interfaces benutzen soll

 

[bygones]

Du brauchst ale rueckgabe

? extends Personeninterface

 

[Marco13]

Wenn ich es richtig verstanden habe, geht es hauptsächlich um die Frage, wie man die Liste zurückgibt? Da die Liste auch nur die Interfaces enthalten soll, kann man sie gleich als
private List<AdresseInterface> adressen;
definieren, dann spart man sich den meisten Ärger. Wenn innerhalb der Klasse die konkrete Implementierunge bekannt sein soll (warum?) kann man das auch erreichen - insbesondere kann das Collections.unmodifiableList dort gezielt Information "wegnehmen", was praktisch sein kann.