Klassen Generische Klassen, Personen und Gruppen

[Mcburn]

Guden Tag liebe Community,

meine Kommilitionen und ich haben ein Problem. Für uns sogar ein sehr großes.
In den Übungen werden im Moment Generics geprüft.
Leider verstehen wir im Moment nicht wie wir diese auf unsere Übung anwenden.
Das Grund Verständnis ist vorhanden also bitte keine externen Links zu tollen Büchern oder Tuts .

Uns fehlt ein entscheidender Gedanke zur Lösung.

Nun gut auf zur Problemstellung:

Wir haben eine Klasse Personen, Gruppe und ein Interface ContactData.

Personen:
-firstname
-lastname
-title

Gruppe:
-name
-liste(Diese kann Gruppen und Personen enthalten)

Diese Liste soll auch sortiert sein. Das heißt zu erst Personen diese sind nochmal sortiert durch nachname, vorname, titellänge. Danach kommen die Gruppen.

Jede Person speichert ein Objekt mit seinem Kontakt-Daten(ContactData) von denen nur die Schnittstelle(Interface) festgelegt ist: Zur Ausgabe können die Textzeilen des Kontakts mit den Methoden int getLineCount() und String getLine(int index) abgefragt werden. Der Versand einer Nachicht an den Kontakt geschieht über die Methode void sendMessage(String msg).

Damit die Kontaktverwaltung typsicher ist und nicht beliebige verschiedene Kontaktobjekte in einer Liste gemischt werden können wird der konkrete Typ der Kontaktobjekte als generischer Parameter bei den personen und Gruppen gesetzt. Der konkrete generische Typ muss dabei mindestens Contact Data sein, da sonst die Ausgabe nicht möglich ist.

So was wir bis jetzt haben:

(sind nur Code ausschnitte)

 public class Person<T extends ContactData>

(Das gleiche mit Group)
ContactData beinhaltet die Methoden getLine usw.
Außerdem haben wir eine Klasse Data, welche die Superklasse von Group und Person ist.
Das machen wir damit Person und Group kompatibel werden.

Was uns noch vor einen Rätsel stellt:

-Müssen Person und Group generisch sein? Kann man sie dann trotzdem noch die Vornamen, nachnamen und titel vergleichen?
-Müssen diese dann Comparable implementieren?
-Wie arbeiten wir am effectivsten mit Wildcards? ( Zum Beispiel wäre Person<? extends ContactData> gut?)

Vllt sollten wir auch nochmal Generics lernen, aber das Vorlesungsmaterial von unserem Proffesor hilft uns im Moment nicht weiter. Beispiele wären hier deshalb sehr angebracht. Damit wir unsere Denkblockade durchbrechen können.

Ich danke recht herzliche allen schon mal im Vorraus für die Arbeit die ihr mit uns haben werdet.

Mit freundlichen Grüßen Sperling

 

[SlaterB]

wenn Person und Group in eine Liste kommen, dann sollten sie von Data erben und diese Klasse generisch sein,
sofern man eine Liste List<Data<XyContractData>> anlegen will

Person und Group sollten dann auch generisch sein, ja,

was Comparable sein muss merkt man dann bei Sortieren schon..

> Wie arbeiten wir am effectivsten mit Wildcards? ( Zum Beispiel wäre Person<? extends ContactData> gut?)
diese Frage ist in etwa so sinnvoll wie
'Wie arbeiten wir am effectivsten mit einem Hammer? ( Zum Beispiel soll ich hier mal draufhauen?)'
..

man macht mit einem Hammer oder Generics genau das was aktuell sinnvoll und nötig ist,
ohne konkrete Probleme gibts auch keine konkreten Vorgehensweisen

 

[Mcburn]

Ich geb mal meine Anfänge Preis .
Danke für die schnelle Antwort ihr seit hier echt Top.


Die Data Klasse ist die Super Klasse von Person und Group.
Diese soll dafür sorgen das wir Person und Group in eine Liste stecken können und vergleichbar ist.

public abstract class Data<T extends ContactData> {

	
}

Die Person Klasse hier sind die Attribute firstname usw. gespeichert. Sollte ich hier vergleichen?
Außerdem muss der Generische Typ T mindestens ContactData oder darunter sein.

public class Person<T extends ContactData> {
	String firstName;
	String lastName;
	String title;

	public int compareTo(Person<T> o2){
		if(this.firstName.compareTo(o2.firstName) == 0) System.out.println("gleich");
		if(this.firstName.compareTo(o2.firstName) > 0) System.out.println("größer");
		if(this.firstName.compareTo(o2.firstName)< 0)System.out.println("kleiner");
		return 0;
		
	}
}

Hier die Klasse Group diese hat eine Liste die Personen UND Gruppen SORTIERT speichern kann.

import java.util.LinkedList;
import java.util.List;


public class Group<T extends ContactData> extends Data<T>{
	String name;
	List<Data<T>> list = new LinkedList<Data<T>>();
}

Nun das Interface ContactData hier werden die Kontaktdaten von personen und gruppen verwaltet.

 public interface ContactData {
	public String getLine(int line);
	public int getLineCount();
	public void sendMessage(String msg);
}

Das größte Problem liegt nicht an der implementierung oder an der Syntax sonder wohl eher den springenden Punkt nicht zu sehen. Will mir einer das Brett entfernen .

Euer Mcburn

 

[SlaterB]

also für mich besteht da zum Teil auch noch ein Brett, was dieses ContactData sein soll will ich nicht verstehen
und vor allem wieso eine Gruppe die auch haben kann,
in jedem Fall muss doch noch ein Objekt vom generischen Typ gespeichert werden, z.B. gleich in Data für beide, oder?

wonach du sortieren willst ist dir überlassen, nach den ContactData-Informationen (wenn nur nach denen, dann wiederum in der Data-Klasse) oder nach den sonstigen Feldern,
du solltest das Comparable-Interface implementieren

 

[Crian]

Ich sehe hier irgendwie nicht die Notwendigkeit von generischen Klassen. Um Dinge vom "Typ" Data in einer Liste zu speichern, müssen die Dinge nur das Interface Data implementieren.

 

[Mcburn]

Data.java

public abstract class Data<T extends ContactData> implements Comparable<Data<T>>{

	public abstract int classHelper();
	public int compareTo(Data<T> other) {
			int result = classHelper() - other.classHelper();
			if(result == 0){
				System.out.println("Daten Fehler beim Sortieren");
			}
		return result;
		
	}
	public abstract void output();
}

Person.java

public class Person<T extends ContactData> extends Data<T>{
	private String firstName;
	private String lastName;
	private String title;
	
	private T database;
	
	public Person(String firstName,String lastName,String title,T database){
		this.firstName = firstName;
		this.lastName = lastName;
		this.title = title;
		this.database = database;
	}
	
	
	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public T getDatabase() {
		return database;
	}

	public void setDatabase(T database) {
		this.database = database;
	}

	
	public int compareTo(Data<T> o){
		int result = 0;
		if(o instanceof Person){
			Person<T> oPerson = (Person<T>)o;
			result = getLastName().compareToIgnoreCase(oPerson.getLastName());
			if(result == 0){
				result = getFirstName().compareToIgnoreCase(oPerson.getFirstName());
				if(result == 0){
					result = getTitle().length() - oPerson.getTitle().length();
				}
			}
			return result;
			
		}
		else {
			return super.compareTo(o);
		}
	}

	public int classHelper() {
		
		return 0;
	}
	
	public void output() {
		if(getTitle() != null && getTitle().length() > 0){
			System.out.println(getTitle()+" ");
		}
		System.out.println(getFirstName() + " " + getLastName());
		for(int i = 0; i < getDatabase().getLineCount(); i++){
			System.out.println(getDatabase().getLine(i));
		}
	}

}

Group

import java.util.*;


public class Group<T extends ContactData> extends Data<T>{
	private String name;
	private SortedSet<Data<T>> entries;
	
	public Group(String name){
		this.name = name;
		this.entries = new TreeSet<Data<T>>();
	}
	
	
	
	public String getName() {
		return name;
	}



	public void setName(String name) {
		this.name = name;
	}

	public void addContact(Data<T> entry){
		entries.add(entry);
	}
	public void removeContact(Data<T> entry){
		entries.remove(entry);
	}
	
	

	@Override
	public int classHelper() {
		return 2;
	}
	
	public int compareTo(Data<T> o){
		if(o instanceof Group){
			Group<T> oGroup = (Group<T>) o;
			return getName().compareTo(oGroup.getName());
		}else{
			return super.compareTo(o);
		}		
	}
	@Override
	public void output() {
		if(!entries.isEmpty()){
			System.out.println(getName()+"/");
			for(Data<T> entry : entries){
				entry.output();
			}
		}
		
	}
}

ContactData

public interface ContactData {
	public String getLine(int line);
	public int getLineCount();
	public void sendMessage(String msg);
}

InternetContact.java

import java.util.*;


public class InternetContact implements ContactData{
	private String homepage;
	private List<String> mailAdress;
	

	public InternetContact(String hp, String... mA){
		this.homepage = hp;
		this.mailAdress = new ArrayList<String>();
		
		for(String mailadress : mA){
			this.mailAdress.add(mailadress);
		}
	}
	
	public String getHomepage() {
		return homepage;
	}


	public void setHomepage(String homepage) {
		this.homepage = homepage;
	}


	public List<String> getMailadress() {
		return mailAdress;
	}


	public String[] getMailAddresses(){
		return mailAdress.toArray(new String[mailAdress.size()]);
	}
	public void addMailAddress(String mailAddress){
		mailAdress.add(mailAddress);
	}
	public void removeMailAddress(String mailAddress){
		mailAdress.remove(mailAddress);
	}
	
	public String getLine(int line) {
		if(line == 0){
			return homepage;
		}
		else{
			return mailAdress.get(line-1);
		}
	}


	public int getLineCount() {
		return mailAdress.size();
	}


	public void sendMessage(String msg) {
		System.out.println("A Message for Kreuter: pls 20 Points for Germany :D");		
	}
	

}

TelephoneContact.java

public class TelephoneContact implements ContactData{
	private String phoneNumber;
	private String address;
	private int PLZ;
	private String stadt;
	
	public TelephoneContact(String phoneNumber, String adress, int PLZ, String stadt){
		this.phoneNumber = phoneNumber;
		this.address = adress;
		this.PLZ = PLZ;
		this.stadt = stadt;
	}

	public String getLine(int line) {
		switch(line){
			case 0: return phoneNumber;
			case 1: return address;
			case 2: return PLZ+ " " + stadt;
		}
		throw new IndexOutOfBoundsException("invalid line number");
	}


	public int getLineCount() {
		return 3;
	}

	public void sendMessage(String msg) {
		System.out.println("was en mist Programm ey" +msg);
		
	}
	public void setStadt(String stadt) {
		this.stadt = stadt;
	}
	public String getStadt() {
		return stadt;
	}
	public void setPLZ(int plz) {
		PLZ = plz;
	}
	public int getPLZ() {
		return PLZ;
	}
	public void setAdress(String adress) {
		this.address = adress;
	}
	public String getAdress() {
		return address;
	}
	public void setPhoneNumber(String phoneNumber) {
		this.phoneNumber = phoneNumber;
	}
	public String getPhoneNumber() {
		return phoneNumber;
	}

}

Main.java

public class Main {
	public static void main(String[] args){
		Person<InternetContact> hans = new Person<InternetContact>("Hans","Geilendorf","Leichnschönder",new InternetContact("www.stop.de","hanspeter@web.de","FrankHellster@gmx.de"));
		Person<TelephoneContact> paul = new Person<TelephoneContact>("Paul","Feiermann","Feierreisau" , new TelephoneContact("06627", "partystraße 12", 55487, "Feierstadt"));
		Person<InternetContact> franz = new Person<InternetContact>("franz","Geilenschorfer","Jörgler",new InternetContact("www.wer-kennt-wen.de","weiler@web.de","walter@gmx.de"));
		Person<TelephoneContact> kaul = new Person<TelephoneContact>("kaul","Feiertest","feuerwehrmann" , new TelephoneContact("045646", "Gabelstraße", 55487, "testzugang"));
		Group<InternetContact> internetcontact = new Group<InternetContact>("Gabelstaplerfahrer");
		Group<TelephoneContact> phone = new Group<TelephoneContact>("Pauler");
		internetcontact.addContact(hans);
		phone.addContact(paul);
		internetcontact.addContact(franz);
		phone.addContact(kaul);
		
		phone.output();
		internetcontact.output();
	}
}

Hab im Internet mal rum geforscht und ein PDF gefunden. Das hat mir das Brett vorm Kopf weggenommen.

Ich danke euch für eure Hilfe .
Ich klick das Thema als erledigt an und hoffe das die Lösung hier anderen Leuten als denkidee hilft.

Danke an euch Community Danke SlaterB

 

[Guardi]

Würde ich übrigens so nie implementieren.
Generics sind dann praktisch wenn man ein Verhalten eines Objekts mit bestimmten Eigenschaften oft braucht. Irgendeinen AbstractDao für den die save-Operation immer identisch ist z.B.
Dein Beispiel liesse sich aber wesentlich schöner mit Interfaces lösen. Siehe auch Strategie-Pattern.
Aber gut, ist halt ne Übung.