Collections Frameworks

Status
Nicht offen für weitere Antworten.

Han

Bekanntes Mitglied
Hallo....wenn in der Angabe steht:

Teil 1: Generische Kontaktverwaltung
Implementieren Sie eine Verwaltung von Personen und Gruppen mit beliebigen Kontakt-Daten.
Personen (Person) haben einen akademischen Titel (title), einen Vornamen (firstName)
und einen Familiennamen (lastName). Gruppen (Group) haben einen Namen (name) und
verwalten eine sortierte Liste (entries; verwenden Sie eine entsprechende generische Klasse des
Collections Frameworks)
, die sowohl Personen als auch weitere Gruppen enthalten kann. Die Liste
soll folgendermaßen sortiert werden:
1. Personen vor Gruppen.
2. Personen alphabetisch nach Familiennamen, wenn diese gleich sind alphabetisch nach
Vornamen, wenn diese auch gleich sind dann nach der Länge der Titel.
3. Gruppen alphabetisch nach Gruppenname.

muss ich dann in Java folgendes eingeben:

Code:
import java.util.Collection;

oder kann ich auch das eingeben:

Code:
import java.util.LinkedList;

Mich stört der Begriff Framework.....was versteht man da drunter? Und is mit Collections auch wirklich das CollectionsInterface gmeint oder is das nur ein allgemeiner Begriff.....?

mfg,
Hannes
 
B

Beni

Gast
Mit "Collection Framework" werden normalerweise alle Klassen und Interfaces bezeichnet, welche irgendwas mit "java.util.Collection" zu tun haben. Also Listen, Sets, Maps, Iteratoren, Enumerationen, ... du kannst dich da frei bedienen (und den zweiten Import nehmen).
 

Murray

Top Contributor
Mit dem Collections-Framework ist normalerweise ein Satz von Klassen und Interfaces gemeint, mit denen Sun die ursprünglichen Libraries um höherwertige Funktionalitäten zur Verwaltung von Listen etc. erweitert hat; java.util.Collection ist ein Interface dieses Frameworks.

Was man importieren muss, hängt davon ab, was man verwenden will. Du wirst zumindest die Klasse importieren müssen, die Du wirklich verwenden willst (also z.B. java.util.LinkedList). Guter Stil ist es aber, dort , wo man die konkrete Implementierung nicht wissen muss, lieber mit dem abstrakten Typen umzugehen.

Bsp:

Code:
import java.util.LinkedList;

[...]
LinkedList l;

l = new LinkedList(); //--- nicht so schön


Code:
import java.util.LinkedList;
import java.util.List;

[...]
List l;
l = new LinkedList(); //--- besser; was da für eine Liste ist, ist ein Implementierungsdetail

/EDIT: zu spät, Beni war wieder schneller :toll:
 

Han

Bekanntes Mitglied
Aha...verstehe...is klar..danke..habs jetzt so gmacht...

Code:
import java.util.Collection;
import java.util.LinkedList; 

.....

Collection entries = new LinkedList();

....

mfg,
Hannes
 

Han

Bekanntes Mitglied
Hallo...stehe vor einem Problem....und zwar...will ich das eine Liste nur 2 Parametertypen speichert...Person und Group....

Code:
public class Group {

    private Collection<Person/*??wie sag ich JAVA dass auch Group Typelemente genommen werden können?*/> entries;
    
    public Group(){
    	this.entries = new LinkedList<Person>();
    }
    
    public void addElement(Person element) {
        entries.add(element);
    }
   
	
}

mfg,
Hannes
 

Murray

Top Contributor
Da must Du ein gemeinsames Interface definieren:

Code:
public interface Collectable { //reines Marker-Interface, darf gern auch besser benannt werden ;-)
}

public class Group implements Collectable {
 [...]
}

public class Person implementsCollectable {
 [...]
}

Die Liste kann dann so deklariert sein:
Code:
private Collection<? extends Collectable> entries;
 

Leroy42

Top Contributor
Han hat gesagt.:
Implementieren Sie eine Verwaltung von Personen und Gruppen

Das sagt doch schon, daß Personen und Gruppen irgendwie zusammengehören.
Daß heißt daß du denen eine gemeinsame Basisklasse verpassen kannst, die dann
auch tum Inhaltstyp deiner Liste wird.
 

Leroy42

Top Contributor
Murrays Interface-Lösung ist natürlich auch möglich. Ich vermute anhand der Aufgabenstellung
nur, daß statt des Interfaces auch eine gemeinsame Basisklasse genommen werden kann.
 

Murray

Top Contributor
Leroy42 hat gesagt.:
Murrays Interface-Lösung ist natürlich auch möglich. Ich vermute anhand der Aufgabenstellung
nur, daß statt des Interfaces auch eine gemeinsame Basisklasse genommen werden kann.

Wobei man wieder bei der spitzfindigen Diskussion ankommen kann, ob ein Interface nicht eine abstrakte Basisklasse ist :wink:

Du hast natürlich Recht; bei der Aufgabe wird es vermutlich Gemeinsamkeiten geben, so dass es bestimmt kein reines Marker-Interface sein wird, sondern eines, in dem eben das gemeinsame API beschrieben ist. Und wenn bezüglich der Ableitung noch keine anderen Randbedingungen bestehen, dann wird man natürlich eine Basisklasse verwenden. Falls das aus irgendwelchen Gründen aber nicht geht (weil Person und Gruppe eben schon unterschiedliche Basisklassen haben), dann kann / muss man eben ein Interface benutzen.

/EDIT: Typo
 

Leroy42

Top Contributor
Murray hat gesagt.:
Wobei man wieder bei der spitzfindigen Diskussion ankommen kann, ob ein Interface nicht eine abstrakte Basisklasse ist :wink:

Leider überhaupt nicht spitzfindig :(
Denn mich stört es schon seit Urzeiten, daß Interfaces nur abstrakte Methoden haben dürfen.
Ich habe schon viele Beispiele gehabt wo es passend gewesen wäre, Methoden die durch Aufrufe
von Basismethoden implementiert werden könnten nicht in dem Interface coden zu können,
sondern den identischen Code in jeder einzelnen Implementation des Interface kopieren
zu müssen, wenn es aureichend wäre, nur diese Basismethoden je nach Implementation zu coden.
 

Murray

Top Contributor
Klar, aber damit rüttelst Du an den Grundfesten der Java-Architektur: dann gäbe es nämlich echte Multiple-Inheritance.
 

Han

Bekanntes Mitglied
Danke.....Für mich scheint die Interface Lösung die beste zu sein, denn Group und Person haben eigentlich nichts gemeinsam(von den Speicherelementen).....bis jetzt....also kann ich immer noch später schauen ob ich das Interface nicht doch in eine abstrakte Klasse umändere....

mfg,
Hannes
 

Han

Bekanntes Mitglied
Hallo...eine Frage noch....wieso

@Murrays Kommentar

Code:
private Collection<? extends Collectable> entries;

Collectable ist ein Interface und ich schreib trotzdem extends hin?...was für einen Sinn macht das?...wollts natürlich mit implements ausprobieren aber geht nicht....wieso?

mfg,
Hannes
 

Leroy42

Top Contributor
Weil man Interfaces genauso erweitern kann wie jede Klasse.

Murray hat also für die Zukunft vorgebaut und nicht dur das Interface, sondern auch
alle seine eventuellen späteren verfeinerten Interfaces in der Liste erlaubt.
 

byte

Top Contributor
Code:
Collection<Collectable> entries = new LinkedList<Collectable>();

ist richtig.
 

Leroy42

Top Contributor
Und Murrays Ansatz geht dann nicht? :shock:

Naja, habe halt selbst noch keine Erfahrung mit den Java 1.5 Neuerungen :(
Werd' mich in Zukunft raushalten
 

Murray

Top Contributor
Leroy42 hat gesagt.:
Und Murrays Ansatz geht dann nicht? :shock:

Asche auf mein Haupt. Die Deklaration geht zwar durch den Compiler, aber spätestens, wenn man die Liste benutzen will, bemerkt man den Fehler. Hier muss die Liste wirklich nur als Collection<Collectable> deklariert sein.
 

byte

Top Contributor
@Leroy42:
Nein das geht nicht. Folgendes Beispiel:

Code:
List<? extends Object> list1 = new ArrayList<String>();

Folgendes funktioniert nun nicht:

Code:
list1.add("Teststring");

list1 weiss nicht, von welchem Typ seine Elemente sind. Es ist nur bekannt, dass es Unterelemente von Object sind.


Folgendes wiederum funktioniert und bindet die Wildcard:

Code:
List<Integer> list2 = new ArrayList<Integer>();
list1 = list2;
 

Han

Bekanntes Mitglied
Hallo...komm irgendwie bei dem Bsp. nicht weiter....die Generics sind sauschwer.....zu verstehen...und zwar hats mich beim sortierten Einfügen in die Liste....

Meine Klasse Group:

Code:
public class Group implements StoreElements{

    private Collection<StoreElements> entries;
    
    public Group(){
    	this.entries = new LinkedList<StoreElements>();
    }
    
    public void add(StoreElements element){
    	
//    	1. Personen vor Gruppen.
//    	2. Personen alphabetisch nach Familiennamen, wenn diese gleich 
//    	sind alphabetisch nach
//    	Vornamen, wenn diese auch gleich sind dann nach der Länge der 
//    	Titel.
   ???????????????????
      	
    }
}

Jetzt kann ich mit entries halt nur die Methode entries.add(element) aufrufen was mir aber nicht wirklich was bringt. Ein TypeCast würde helfen (um auf die Methoden von LinkedList zugreifen zu können) aber genau das will ich ja mit Generics verhindern. Aber wie schaffe ich es mit Generics dass er mir nur Listen vom Typ LinkedList zulässt....ich meine das habe ich ja mit private Collection<StoreElements> entries; schon verspielt....werd nciht schlau draus.....ich kapiers nicht...

mfg,
Hannes
 

Murray

Top Contributor
Du solltest - wenn eine Liste brauchst - keine allgemeine Collection, sondern sondern eine java.util.List deklarieren (aber eben keine LinkedList, denn das ist ein Implementierungdetail). Wenn Du natürlich wirklich auf Methoden von LinkedList zugreifen must, dann spricjt nichts dagegen, diese auch als solche zu deklarieren.
 

Han

Bekanntes Mitglied
Wieso keine LinkedList......ich brauch doch irgendeine Liste...sonst kann ich ja nichts hinzufügen....ich kapier gar nichts mehr.....das interface List bringt mir auch keine neue Methoden......habs jetzt mal so implementiert:

Code:
public class Group<t extends LinkedList> implements StoreElements{
	//Eine Gruppe verwaltet Listen....Elemente sind also Liste
	//im speziellen sind diese Listen nun auf den Typ LinkedList 
	//eingeschränkt worden...
	
	
    private List<StoreElements> entries;
    //Bei Collections hab ich den Hinzufügetyp automatisch auf
    //StoreElements eingeschränkt....
    
    
    public Group(){
    	this.entries = new LinkedList<StoreElements>();
    	//Klasse wird instanziert......LinkedList kann nun
    	//nur Elemente vom Typ StoreElements aufnehmen....
    }
    
    public void add(StoreElements element){
    	
//    	1. Personen vor Gruppen.
//    	2. Personen alphabetisch nach Familiennamen, wenn diese gleich 
//    	sind alphabetisch nach
//    	Vornamen, wenn diese auch gleich sind dann nach der Länge der 
//    	Titel.
       
    	if(element instanceof Person){
    		((t)entries).addFirst(element);
    	}
    		
    }
}

..aber is hald wieder ein Typecast drinnen und außerdem gibt JAVA mir eine Warnung aus dass das falsch ist....


mfg,
Hannes
 
B

bygones

Gast
verstehe deinen code nicht ....

Code:
public class Group<t extends LinkedList> implements StoreElements
warum ist Groups generisch und mit LinkedList ?!

und dies ist auch unsinnig
Code:
if(element instanceof Person){ 
          ((t)entries).addFirst(element); 
       }
warum nicht einfach bei der Liste addFirst(element). der Cast und das instanceof ist unnötig
 

Han

Bekanntes Mitglied
Das Group generisch ist hab ich wieder umgestellt auf nicht generisch....aber ich kapier halt einfach nicht wie ich die Sortierung hinbekomme, wenn ich bei meiner Liste entries nur die Methode add(element) zur Verfügung habe.und sonst nichts.
Ich meine wie soll ich da erreichen das Person vor Group liegt? Darum hab ich mir gedacht ich wandle das Interface List (welches auf LinkedList zeigt) in die LinkedList um (darum der TypeCast) weil ich dann mehr Methoden zur Verfügung habe und nicht nur die ganz allgemeinen. Mein Problem ist halt das ich einfach mit dieser allgemeinen Liste nicht zurechtkomme. Wie sortier ich da was....wie komm ich da überhaupt auf den Head der Liste wenn mir nur die paar Methoden von List zur Verfügung stehen...
..darum halt der krampfhafte Versuch die allgemeine Liste irgendwie zum Sortieren zu bringen...brauch bitte irgendeinen Denkanstoss...bin schon am Verzweifeln...

mfg,
Hannes
 

byte

Top Contributor
Ich glaube hier liegt noch einiges im Argen. Erst ging es um Generics, jetzt auf einmal ums sortieren. Das sind zwei Baustellen...

1. Mit Generics legst Du die Elemente Deiner Liste auf einen bestimmten Typ fest. Du willst aber offensichtlich sowohl Elemente des Typs Person als auch des Typs Group zu einer Liste hinzufügen. Also entweder Du machst Deine Liste nicht generisch und addest die Elemente dieser Typen, oder wie oben beschrieben Person und Group müssen das selbe Interface implementieren. Andere Alternative: Person und Group erben von der selben (abstrakten) Oberklasse.

2. Wenn Du dann Deine Liste hast, kannst Du sie mit Collections.sort() sortieren. Dafür sollten am besten Person und Group das Interface comparable implementieren und jeweils die Methode compareTo() überschreiben.
 

Han

Bekanntes Mitglied
Hallo....ok...hab mal deinen Rat befolgt und die Methode compareTo in den beiden Klassen Person und Group vom Interface Comparable überschrieben.

das schaut dann so aus:

Code:
public interface StoreElements<T> extends Comparable<T>{}

Code:
public class Person implements StoreElements<Person>{	
	private String title;
	private String firstName;
	private String lastName;
	........
	.........
	public int compareTo(Person p) {
		int i = this.getLastName().compareTo(p.getLastName());
		if(i == 0){
			i = this.getFirstName().compareTo(p.getFirstName());
			if(i == 0){
				if(this.getTitle().length() >= p.getTitle().length()){
					return 1;
				}else{
					return -1;
				}
			}
			return i;
		}
		return i;
	}
}

Code:
public class Group implements StoreElements<Group>{
	
    private List<StoreElements> entries;
    String name;
    
    public Group(String name){
    	this.name = name;
    	this.entries = new LinkedList<StoreElements>();
    }
    ......
    public void add(StoreElements element){
    	entries.add(element);
        Collections.sort(entries);
    }
	public int compareTo(Group g) {
		return this.getName().compareTo(g.getName());
	}
}


Was ich hingegen noch nicht so kapiere ist wie ich das hinkriege das ein Person Element in der Liste vor einem Group
Element liegt...das muss ich doch auch in compareTo implementieren...nur wie?
...und warum meldet mir JAVA bei Collections.sort(entries); eine Warnung????

mfg,
Hannes
 

byte

Top Contributor
Achso, in diesem Fall kannst Du noch einen Comparator implementieren. Dort überschreibst Du die Methode compare(), die dann zwei verschiedene Objekte vergleichen kann. Von dort kannst Du ja Deine compareTo()s verwenden, dann musst Du das nicht neu schreiben. Diesen Comparator musst Du dann der sort() übergeben, also:

Code:
Collections.sort(liste, comparator);

Wie lautet denn die Warnung?
 

Han

Bekanntes Mitglied
Hallo....die Warnung lautet:

"Type safety: unchecked invocation sort(List<StoreElements>) of the generic method sort (List<T>)of Type Collections"

mfg,
Hannes
 

Han

Bekanntes Mitglied
Hallo...das mit dem Comparator ist mir so ganz noch nicht klar....denn in unserem Skript steht:

Comparator:
Problem:
Man möchte Objekte vergleichen, deren Klasse nicht Comparable implementiert und die man nicht ändern kann.
Aber meine Objekte implementieren ja Comparable...wozu also eine Comparator....und woher weiß JAVA dann welche compare Methode es hernehmen muss...die vom Comparator oder die von Comparable...

mfg,
Hannes
 

byte

Top Contributor
comparable bezieht sich auf die Klasse, die das Interface implementiert. Comparator kann mehrere Klassen miteinander vergleichen. Wenn Du einen Comparator übergibst, wird dieser auf verwendet. Der Comparator wiederum kann aber die compareTo()s der einzelnen Objekte verwenden für seinen Vergleich.
 

Han

Bekanntes Mitglied
Hallo....man ist das schwer.....jetzt spinnt Java beim Testen....

Also....ich habs jetzt so implementiert.....

Code:
public class PersonGroupComparator<P extends StoreElements

> implements Comparator

{

	public int compare(P p, P g){	
		int a = p.elementType();
		int b = p.elementType();
		
		if(a < b){
			return -1;
		}else{
			if(a > b){
				return 1;
			}
			return p.compareTo(g);
		}
	}
}

Code:
public abstract class StoreElements<T> implements Comparable<T>{
	public abstract int elementType();
	public abstract int compareTo(T arg0);
	public abstract void draw();
}

Code:
public class Group extends StoreElements<Group>{
	public int elementType(){
		return 1;
	}
   ........
    .......
    public void add(StoreElements element){
    	entries.add(element);
    	PersonGroupComparator c = new PersonGroupComparator();
        Collections.sort(entries,c);
    }
    
    public void tod(){	
    	 for (StoreElements element : entries) {
             element.draw();
         }	
    }
    
    public void draw(){
    	System.out.println(this.getName());
    }
    
	public int compareTo(Group g) {
		return this.getName().compareTo(g.getName());
	}
}

Code:
public class Person extends StoreElements<Person>{

......
	public int elementType(){
		return 0;
	}
.....	
....
	public void draw(){
		System.out.println(this.getLastName());
	}
}

...wenn ich jetzt das testen will hauts mir eine ClassCastException raus....
Code:
public class TestKontaktVerwaltung {

	public static void main(String args[]) {
		
		Person p1 = new Person("Mag","Hannes","Rechberger");
		Person p2 = new Person("Mag","Han","Blu");
		Group g1 = new Group("Tanzverein");
		Group g2 = new Group("Sportverein");
		
		g2.add(g1);
		g2.add(p1);
		g2.add(p2);

		g2.tod();	
	}	
}

Ich werd aus den Generics einfach noch nicht so recht schlau...und aus den Interfaces schon recht nicht....da passiert alles auf einer Ebene die ziemlich abstrakt ist..........man hat einfach keinen Einblick in gewisse Teile des Codes....

mfg,
Hannes
 
B

Beni

Gast
Ein Problem ist, dass du die Generics nicht konsequent an jeder Stelle anwendest, dann wären ClassCastExceptions nicht möglich.
Das zweite Problem ist, dass wenn du die Generics konsequent anwenden würdest, der Code nicht funktionieren würde. Denn der GroupPersonComparator muss seine Argumente erst Casten, bevor er die "compareTo"-Methode aufrufen kann (die compareTo-Methoden in Person und in Group haben verschiedene Signaturen).
Das ist also eine hübsche kleine Sackgasse...

Mein Vorschlag wäre: anstelle von einer Liste zwei Listen zu verwenden. Eine Liste für "Person", und eine Liste für "Group".
 

Han

Bekanntes Mitglied
Hallo....und wie soll ich dann das mit der Regelung einbinden, dass Group Elemente vor Person Elementen sein sollenin der Liste...?

Soll ich dann die 2 Listen wieder zu einer "susammenfügen"? Wenn ich 2 getrennte Listen mache is wahrscheinlich die Aufgabenstellung verletzt....schöner Mist......

mfg,
Hannes
 
B

Beni

Gast
Wenn du unbedingt nur eine Liste haben willst, muss der Cast halt rein. Dann wäre es hilfreich, wenn du mal genauer sagst, wo "...wenn ich jetzt das testen will hauts mir eine ClassCastException raus...." auftritt.

Also: Eine Liste: möglich, aber gefährlich
Zwei Listen: möglich, ungefährlich, aber passt nicht zur Aufgabe
 

M.C.S.

Mitglied
Irgendwie werde ich beim Lesen der Aufgabenstellung das Gefühl nicht los, dass das vorgegebene Modell in dieser Form einfach nur schrottig ist. Da fällt es wirklich schwer, gute Tipps zu geben :roll:
 

Han

Bekanntes Mitglied
Na ja....vielleicht liegts daran dass ich euch nicht die gesamte Aufgabenstellung gegeben habe...aber der restliche Teil hat wohl nichts mit dem 1.Teil zu tun den ich zuerst erledigen wollte....

Implementieren Sie eine Verwaltung von Personen und Gruppen mit beliebigen Kontakt-Daten.
Personen (Person) haben einen akademischen Titel (title), einen Vornamen (firstName)
und einen Familiennamen (lastName). Gruppen (Group) haben einen Namen (name) und
verwalten eine sortierte Liste (entries; verwenden Sie eine entsprechende generische Klasse des
Collections Frameworks), die sowohl Personen als auch weitere Gruppen enthalten kann. Die Liste
soll folgendermaßen sortiert werden:
1. Personen vor Gruppen.
2. Personen alphabetisch nach Familiennamen, wenn diese gleich sind alphabetisch nach
Vornamen, wenn diese auch gleich sind dann nach der Länge der Titel.
3. Gruppen alphabetisch nach Gruppenname.
Jede Person speichert ein Objekt mit seinen Kontakt-Daten (ContactData), von denen nur die
Schnittstelle festgelegt ist: Zur Ausgabe können die Text-Zeilen des Kontakts mit den Methoden
int getLineCount() und String getLine(int index) abgefragt werden. Der
Versand einer Nachricht an den Kontakt geschieht über die Methode void
sendMessage(String msg).
Die gesamte hierarchische Liste aller Personen (inklusive die Zeilen der Kontakt-Daten) und
Gruppen soll von einer Methode in einer sinnvoll formatierten Form auf der Konsole ausgegeben
werden.
Damit die Kontaktverwaltung typsicher ist und nicht beliebige verschiedene Kontakt-Objekte in
einer Liste gemischt werden können, wird der konkrete Typ der Kontakt-Objekte als generischer
Parameter bei den Personen und Gruppen gesetzt. Der konkrete generische Typ muss dabei
mindestens ContactData sein, da sonst die Ausgabe nicht möglich ist.

Na ja....und das schreibts mir hin wenn ich versuche zu kompilieren:

Exception in thread "main" java.lang.ClassCastException: UE4.Person
at UE4.Group.compareTo(Group.java:1)
at UE4.PersonGroupComparator.compare(PersonGroupComparator.java:26)
at UE4.PersonGroupComparator.compare(PersonGroupComparator.java:1)
at java.util.Arrays.mergeSort(Unknown Source)
at java.util.Arrays.sort(Unknown Source)
at java.util.Collections.sort(Unknown Source)
at UE4.Group.add(Group.java:65)
at UE4.TestKontaktVerwaltung.main(TestKontaktVerwaltung.java:13)


...ich werd nicht schlau draus...denn das sind einfach alle Klassen wo Vergleiche stattfinden..also weiß ich nicht bei welcher compareTo Methode ich einen Fehler gemacht habe..:)

mfg,
Hannes
 

Han

Bekanntes Mitglied
OK....geht jetzt...war ein blöder Tippfehler.....

statt

Code:
public class PersonGroupComparator<P extends StoreElements

> implements Comparator

{ 

   public int compare(P p, P g){    
     [b] int a = p.elementType(); 
      int b = p.elementType(); [/b]
       .....usw...


Code:
public class PersonGroupComparator<P extends StoreElements

> implements Comparator

{ 

   public int compare(P p, P g){    
     [b] int a = p.elementType(); 
      int b = g.elementType(); [/b]
       .....usw...

...:)...aber die Warnung bei

Collections.sort(entries,c); bleibt noch immer....und ich weiß dass Warnungen bei Generics nichts gutes bedeuten da der Code eigentlich dann falsch ist....hat uns unser Tutor gsagt...

mfg,
Hannes
 

Han

Bekanntes Mitglied
Hallo....da bei anderen fast identischen Post nichts mehr gehtfang ich einen neuen an....aber is eh eine andere Frage

Die Aufgabenstellung lautet :
Implementieren Sie eine Verwaltung von Personen und Gruppen mit beliebigen Kontakt-Daten.
Personen (Person) haben einen akademischen Titel (title), einen Vornamen (firstName)
und einen Familiennamen (lastName). Gruppen (Group) haben einen Namen (name) und
verwalten eine sortierte Liste (entries; verwenden Sie eine entsprechende generische Klasse des
Collections Frameworks), die sowohl Personen als auch weitere Gruppen enthalten kann. Die Liste
soll folgendermaßen sortiert werden:
1. Personen vor Gruppen.
2. Personen alphabetisch nach Familiennamen, wenn diese gleich sind alphabetisch nach
Vornamen, wenn diese auch gleich sind dann nach der Länge der Titel.
3. Gruppen alphabetisch nach Gruppenname.
Jede Person speichert ein Objekt mit seinen Kontakt-Daten (ContactData), von denen nur die
Schnittstelle festgelegt ist: Zur Ausgabe können die Text-Zeilen des Kontakts mit den Methoden
int getLineCount() und String getLine(int index) abgefragt werden. Der
Versand einer Nachricht an den Kontakt geschieht über die Methode void
sendMessage(String msg).

........................

Das fettgedruckte kapier ich nicht so ganz....was soll das heißen...ich tipp mal auf das:

Code:
class Person{
//Jede Person speichert ein Objekt mit seinen Kontakt-Daten....aber was heißt von denen nur die Schnittstelle
//festgelegt ist? und der Rest ist sowieso nur mehr Bahnhof für mich....
ContactData d;

}
 

Han

Bekanntes Mitglied
Die Aufgabenstellung lautet :
Implementieren Sie eine Verwaltung von Personen und Gruppen mit beliebigen Kontakt-Daten.
Personen (Person) haben einen akademischen Titel (title), einen Vornamen (firstName)
und einen Familiennamen (lastName). Gruppen (Group) haben einen Namen (name) und
verwalten eine sortierte Liste (entries; verwenden Sie eine entsprechende generische Klasse des
Collections Frameworks), die sowohl Personen als auch weitere Gruppen enthalten kann. Die Liste
soll folgendermaßen sortiert werden:
1. Personen vor Gruppen.
2. Personen alphabetisch nach Familiennamen, wenn diese gleich sind alphabetisch nach
Vornamen, wenn diese auch gleich sind dann nach der Länge der Titel.
3. Gruppen alphabetisch nach Gruppenname.
Jede Person speichert ein Objekt mit seinen Kontakt-Daten (ContactData), von denen nur die
Schnittstelle festgelegt ist: Zur Ausgabe können die Text-Zeilen des Kontakts mit den Methoden
int getLineCount() und String getLine(int index) abgefragt werden. Der
Versand einer Nachricht an den Kontakt geschieht über die Methode void
sendMessage(String msg).

........................

Das fettgedruckte kapier ich nicht so ganz....was soll das heißen...ich tipp mal auf das:

Code:
class Person{
//Jede Person speichert ein Objekt mit seinen Kontakt-Daten....aber was heißt von denen nur die Schnittstelle
//festgelegt ist? und der Rest ist sowieso nur mehr Bahnhof für mich....
ContactData d;

}
 

M.C.S.

Mitglied
Schnittstelle meint vermutlich Interface. Das würde Sinn machen, da ja nur die Methodensignatur vorgegeben ist, die Implementierung aber nicht genauer eingegrenzt wird. (Trotzdem finde ich die Aufgabenstellung weiterhin pfui ;) )
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
U Sortierung in collections testen Java Basics - Anfänger-Themen 11
X Collections.sort als Lambda Java Basics - Anfänger-Themen 14
berserkerdq2 Geht collections.sort bei allen? Linkedhashset, ArrayList, HashSet etc. Java Basics - Anfänger-Themen 4
O Collections.sort und List.sort mit Lambda Verwirrung Java Basics - Anfänger-Themen 5
B Collections.sort mit zwei Bedingungen? Java Basics - Anfänger-Themen 4
I Collections.shuffle funktioniert nicht Java Basics - Anfänger-Themen 1
M Collections Frage Java Basics - Anfänger-Themen 1
D Methoden Collections.shuffle mit bestimmtem Startwert? Java Basics - Anfänger-Themen 8
T Java Collections Java Basics - Anfänger-Themen 58
X Collections Collections Maps Frage Java Basics - Anfänger-Themen 4
C Collections: private Map Java Basics - Anfänger-Themen 4
V Collections Java Basics - Anfänger-Themen 3
A Collections Java Basics - Anfänger-Themen 2
P collections.sort Java Basics - Anfänger-Themen 2
R Iterationsreihenfolge über Collections Java Basics - Anfänger-Themen 4
S Klassen Collections Java Basics - Anfänger-Themen 10
J Polymorphie Iteratoren statt Collections Java Basics - Anfänger-Themen 13
H Etwas wie sort() / sorted() in JAVA-Collections? Java Basics - Anfänger-Themen 5
F Collections ArrayList oder Hashmap mittel Collections.sychronised Java Basics - Anfänger-Themen 6
S Bestimmte Objekte aus Collections anwählen/herausbekommen Java Basics - Anfänger-Themen 8
M Collections mit >2 type Parametern? Java Basics - Anfänger-Themen 8
S Frage zu Collections.frequency() Java Basics - Anfänger-Themen 3
T Collections Übersicht Collections Java Basics - Anfänger-Themen 4
X Collections Inhalt von zwei Collections prüfen Java Basics - Anfänger-Themen 4
A Generische Collections und Vererbung Java Basics - Anfänger-Themen 2
K Telefonbuch Implementation mit Java Collections Java Basics - Anfänger-Themen 4
G Collections.binarySearch(LinkedList): cannot find method Java Basics - Anfänger-Themen 6
S Collections Sortieren von 3 Collections nach "einer Sortierung" Java Basics - Anfänger-Themen 3
T Kleine Frage zu Collections Java Basics - Anfänger-Themen 3
A Collections und ArrayList Java Basics - Anfänger-Themen 2
S Klasse Mit Collections Java Basics - Anfänger-Themen 32
X DB4O Collections and Arrays, brauche dringend Hilfe! Java Basics - Anfänger-Themen 3
D Datentypen Generische Collections und Warnings Java Basics - Anfänger-Themen 8
K Aufgabe Collections Java Basics - Anfänger-Themen 2
D Collections - subList erstellen Java Basics - Anfänger-Themen 4
S Frage zu Enumerator der trad.Collections Java Basics - Anfänger-Themen 8
M Instanzen, Referenzen und Collections Java Basics - Anfänger-Themen 3
Dit_ Collections.sort(..); | Anwendung Java Basics - Anfänger-Themen 4
T array erweitern/flexible ohne collections usw. Java Basics - Anfänger-Themen 3
S Collections Java Basics - Anfänger-Themen 13
M Collections{Liste aus Objekten erzeugen] Java Basics - Anfänger-Themen 19
S generics und Collections#unmodifiableList Java Basics - Anfänger-Themen 2
G Wann Arrays, wann Collections? Java Basics - Anfänger-Themen 36
N Collections Sort ArrayList<> Java Basics - Anfänger-Themen 7
N Suche Infos zu Maps - Collections Java Basics - Anfänger-Themen 4
G erstes Arbeiten mit Collections Java Basics - Anfänger-Themen 17
Zed Collections? ArrayList, Vector. Java Basics - Anfänger-Themen 2
M Collections kopieren (ArrayList<Point>) Java Basics - Anfänger-Themen 3
T Fragen zu Collections Java Basics - Anfänger-Themen 2
J Collections "schachteln" Java Basics - Anfänger-Themen 5
ff Java Collections Java Basics - Anfänger-Themen 4
T Object Collections durchsuchen und nutzen Java Basics - Anfänger-Themen 6
S Mit Collections elemente sammeln Java Basics - Anfänger-Themen 7
D Collections.sort() frage Java Basics - Anfänger-Themen 6
G Java Collections Framework : id + 5 Werte , gibt es sowas Java Basics - Anfänger-Themen 4
frau-u Collections und Interfaces Java Basics - Anfänger-Themen 2
O Exception eines Frameworks catchen Java Basics - Anfänger-Themen 5
G Java Collection Frameworks Java Basics - Anfänger-Themen 5
M Frameworks - mehre Wege zum Ziel? Java Basics - Anfänger-Themen 9

Ähnliche Java Themen

Neue Themen


Oben