# Die Objekte eine ArrayList sortieren



## Guest (22. Okt 2008)

```
final Point point=new Point("Punkt",10,20,30,40);
		final Linie linie=new Linie("Linie",20,5,10);
		final Sphere sphere=new Sphere("Kugel",30,3,1,"gelb");
		final Triangle triangle=new Triangle("Dreieck",40,50,-25,-40,"pink");
		
		
		
         // Consctrucion of an ArrayList
		 final ArrayList c = new ArrayList();
		
		c.add(point);		
		c.add(linie);
		c.add(sphere);
		c.add(triangle);
```

Hier habe ich meine Objekte erzeugt und in meine ArrayList gespeichert. Nun möchte ich gerne die Liste sortieren nach Namen zum Beispiel wie kann man das am besten Lösen ? Collections.sort(c) geht ja nicht weil ich keine einzelnen Strings habe sondern Objekte eingefügt. Wäre für jede Hilfe dankbar.


----------



## The_S (22. Okt 2008)

Doch, das geht. Du musst nur einen eigenen Comparator programmieren, oder deine Klassen Comparable implementieren lassen.


----------



## Guest (22. Okt 2008)

Was ist denn der Unterschied zwischen Comperator und Comparable?


----------



## The_S (22. Okt 2008)

Comparator ist eine eigene Klasse, die du z. B. dann verwenden kannst, wenn du die zu sortierenden Klassen nicht bearbeiten kannst, und Comparable ist ein interface, das direkt von der zu sortierenden Klasse implementiert wird.


----------



## Oli (22. Okt 2008)

Beispiel:



```
public class Linie implements Comparable {

... dein code ....

 //muß implementiert werden um Comparable nutzen zu können
 //paramSorter ist der zu vergleichende Wert
 public int compareTo(Object line) {
  return this.paramSorter.compareTo(((Linie) line).paramSorter);
 }
}
```

Grüße Oli


----------



## Guest (22. Okt 2008)

Würde das so funktionieren?


```
Collections.sort(c, new Comparator() {
		    public int compare(Object o1, Object o2) {
		        String name1 = ((Point) o1).getName();
		        String name2 = ((Point) o2).getName();
		        return name2.compareTo(name1);
		        
		    }
		});
```


----------



## The_S (22. Okt 2008)

nein, da du in die liste nicht nur "Points" hinzufügst, sondern auch noch ander Klassen (die vermutlich nicht von Point erben ...)


----------



## Guest (22. Okt 2008)

ja das stimmt wie könnt ich das problem dann lösen ?


----------



## Guest (22. Okt 2008)

Oli hat gesagt.:
			
		

> Beispiel:
> 
> 
> 
> ...



Müsste dann jede einzelne Klasse also bei mir Point, Linie usw das Comparable implementieren?


----------



## The_S (22. Okt 2008)

ja, muss.

Du kannst das Problem lösen, indem du mit "instanceof" überprüfst, um welchen Typ es sich handelt. Dann den entsprechenden Wert ausliest und die Werte vergleichst (beachte, dass auch Objekte unterschiedlicher Klassen miteinander verglichen werden).


----------



## Landei (22. Okt 2008)

Nebenbei: Wenn du sicher bist, dass du keine Duplikate brauchst (also jedes Objekt nur einmal auftaucht), kannst du auch *TreeSet* nehmen, das ist dann nämlich immer "automatisch" sortiert. Funktioniert ebenfalls mit Comparable oder Comparator.


----------



## Guest (22. Okt 2008)

So habe jetzt in jede einzelne Klasse dei Methode eingeführt allerdings steh ich grad am Schlauch wie kann ich denn jetzt die ArrayList so aufrufen das sie sortiert erscheint ?


----------



## Oli (22. Okt 2008)

Collections.sort(deineArrayListe);


----------



## Guest (22. Okt 2008)

wenn ich das mache bekomme ich als Fehler : Point cannot be cast to java.lang.Comparable


----------



## HLX (22. Okt 2008)

Der Inhalt deine Liste muss das Interface "java.lang.Comparable" implementieren.

Falls du statt Comparable einen Comparator verwendest lautet der Aufruf:
Collections.sort(deineArrayListe,deinComparator);


----------



## Michael... (22. Okt 2008)

Ich würde in dem Fall eine Superklasse für die geom. Objekte schreiben und dann die Klassen Point, Linie, usw. davon ableiten.
Die Superklasse stellt so allg. Methoden wie getName() zur Verfügung. Zum Sortieren kann man dann den Weg über einen Comparator gehen, in dem man nur auf die Superklasse casten muss. Das hätte dann auch den Vorteil, dass Du später eventuell auch ein Object Pyramide, das von der Superklasse erbt, in der Liste aufnehmen kannst, ohne dich um die Sortierung zu kümmern.


----------



## Guest (22. Okt 2008)

Die einzelnen Klassen wie Point , Linie usw implementieren Comparable nur meine Klasse in der die Main Methode ist nicht muss sie das auch?


----------



## Michael... (22. Okt 2008)

Hier mal ein Bsp. wie ich das gemeint habe mit der Superklasse, man könnte das auch mit einem Interface machen, keine Ahnung was da besser ist. Ich denke so ist das auf jeden Fall sauberer, als wenn Deine gesamten Point, Linie, ... Klassen Comparable implementieren.

```
import java.util.*;

public class CompareDemo {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(new Punkt("F_Punkt"));
		list.add(new Punkt("Z_Punkt"));
		list.add(new Linie("H_Linie"));
		list.add(new Punkt("A_Punkt"));
		list.add(new Linie("F_Linie"));
		list.add(new Linie("C_Linie"));
		
		System.out.println("Liste vor dem Sortieren:");
		for (int i=0; i<list.size(); i++)
			System.out.println(((GeometrieObjekt)list.get(i)).getName());
		
		Collections.sort(list, new NameComparator());
		System.out.println("Liste nach dem Sortieren:");
		for (int i=0; i<list.size(); i++)
			System.out.println(((GeometrieObjekt)list.get(i)).getName());
	}
}

class GeometrieObjekt {
	private String name;
	public GeometrieObjekt(String name) {
		this.name = name;
	}
	public String getName() {
		return this.name;
	}
}

class Punkt extends GeometrieObjekt {
	public Punkt(String name) {
		super(name);
	}
}

class Linie extends GeometrieObjekt {
	public Linie(String name) {
		super(name);
	}
}

class NameComparator implements Comparator {
	public int compare(Object object1, Object object2) {
		String name1 = ((GeometrieObjekt)object1).getName();
		String name2 = ((GeometrieObjekt)object2).getName();
		return name1.compareTo(name2);
	}
}
```


----------



## Guest (22. Okt 2008)

ich habe meine Klassen Linie usw Comparable implementiert

und habe diese Funktion :


```
public int compareTo(Object line) {
		  return this.name.compareTo(((Linie) line).name);
		}
```

Als Fehler erhalte ich beim Aufruf von Collections.sort(c) :

Objektverwaltung.Linie cannot be cast to Objektverwaltung.Point

Was mach ich falsch ?


----------



## Michael... (22. Okt 2008)

Das liegt daran, dass Du einen Point in eine Linie casten willst.
Aus dem Grund habe ich ja oben gemeint, dass das mit dem Implementieren von Comparable ist in diesem Fall nicht so sauber ist. Mit der Vorgehensweise muss man immer eine Fallunterscheidung machen. Mit einer Superklasse (s. mein Bsp) oder einem geeigneten Interface kann man sich das ganze Sparen und kann zukünftig die Liste um neue Objekte erweitern.


----------



## Guest (22. Okt 2008)

also gibt es mit meiner Methode keine Möglichkeit das zu lösen?


----------



## Oli (22. Okt 2008)

Was spricht gegen saubere die Lösung von Michael??


----------



## Guest (22. Okt 2008)

Meine Klassen erben schon von einer anderen Klasse die Funktionen da ich die Funktionen dort ausgelagert habe und Mehrfachvererbung ist in Java nicht möglich


----------



## Oli (22. Okt 2008)

dann lös das Problem über ein Interface


----------



## Michael... (22. Okt 2008)

Anonymous hat gesagt.:
			
		

> also gibt es mit meiner Methode keine Möglichkeit das zu lösen?


Doch. Es gibt immer eine Möglichkeit, nur gibt es besser und schlechtere ;-)
z.B. könntest Du wie bereits erwähnt eine Fallunterscheidung in Deine compareTo Methoden einbauen.

```
public int compareTo(Object object) {
    if (line instanceof Linie)
        return this.name.compareTo(((Linie)object).name);
    if (line instanceof Point)
        return this.name.compareTo(((Point)object).name);
    if (line instanceof Hurz)
        return this.name.compareTo(((Hurz)object).name);
    if (line instanceof ???)
        return this.name.compareTo(((???)object).name);
    ...
}
```
Das ganze funktioniert ist aber nicht unbedingt so toll, wie bereits erläutert.
Wenn mein Bsp. mit Vererbung nicht funktioniert, kann man das - wie von Oli angemerkt- auch über ein Interface lösen.


----------



## Guest (22. Okt 2008)

aber erwartet er so nicht als rückgabewert int?


----------



## Michael... (22. Okt 2008)

return this.name.compareTo(((Linie)object).name);
liefert doch int, oder von welchem Rückgabewert sprichst Du?


----------



## ARadauer (22. Okt 2008)

> So habe jetzt in jede einzelne Klasse dei Methode eingeführt allerdings steh ich grad am Schlauch wie kann ich denn jetzt die ArrayList so aufrufen das sie sortiert erscheint ?


von einer gemeinsamen klasse erben oder ein interface implementieren.... das ist ein typisches vererbungsbeispiel, polymorphie usw...



> Du kannst das Problem lösen, indem du mit "instanceof" überprüfst, um welchen Typ es sich handelt.


kann man, is aber unflexible...


```
import java.util.ArrayList;
import java.util.Collections;


public class Test {
   
   public static void main(String[] args) {
      
      ArrayList<Form> formen = new ArrayList<Form>();
      formen.add(new Kreis("Kreis1"));
      formen.add(new Linie("Linie2"));
      formen.add(new Kreis("Kreis2"));
      formen.add(new Linie("XXX"));
      
      Collections.sort(formen);
      
      for(Form f: formen){
         System.out.print(f.getName()+" :");
         f.zeichneDich();
      }
      
   }
   

}

abstract class Form implements Comparable<Form>{   
   private String name;
   

   public Form(String name) {
      super();
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   
   @Override
   public int compareTo(Form o) {
     return getName().compareTo(o.getName());
   }
   
   public abstract void zeichneDich();
   
   
}

class Kreis extends Form{
   public Kreis(String name) {
      super(name);
   }

   String name;

   @Override
   public void zeichneDich() {
     System.out.println("zeichne Kreis");
      
   }   
}


class Linie extends Form{
   public Linie(String name) {
      super(name);
    }

   String name;

   @Override
   public void zeichneDich() {
      System.out.println("zeichne Linie");
      
   }   
}
```
naja...


----------



## ARadauer (22. Okt 2008)

Anonymous hat gesagt.:
			
		

> Meine Klassen erben schon von einer anderen Klasse die Funktionen da ich die Funktionen dort ausgelagert habe und Mehrfachvererbung ist in Java nicht möglich



welche?


----------



## Guest (22. Okt 2008)

Also zur besseren Übersich zeige ich mal meinen kompletten Quellcode was ich eigentlich vorhabe 


```
package Objektverwaltung;
import java.io.*;
import java.util.Scanner;


public class Linie extends Objekteverwaltung implements Serializable {

	/**
	 * @param args
	 */
	// The Start and End Point of the Line
	protected int A_Punkt;
	protected int E_Punkt;
	public Linie(String name,int ID,int A_Punkt,int E_Punkt){
		setName(name);
		setID(ID);
		setA_Punkt(A_Punkt);
		setE_Punkt(E_Punkt);
		
	}
	
	
public void setName(String name){
	this.name=name;
}
public String getName(){
	return name;
}
public void setID(int ID){
	this.ID=ID;
}
public int getID(){
	return ID;
}
public void setA_Punkt(int A_Punkt){
	this.A_Punkt=A_Punkt;
}
public int getA_Punkt(){
	return A_Punkt;
}
public void setE_Punkt(int E_Punkt){
	this.E_Punkt=E_Punkt;
	}
public int getE_Punkt(){
	return E_Punkt;
}
	
	public String toString(){
		return "Objekt:"+name+" "+"ID:"+ID+" "+"Koordinaten:"+A_Punkt+" "+E_Punkt;
	}
	
}
```

So das ist die Klasse Linie mit Gettern und Settern die anderen Klassen der Objekte sehen genauso aus dann :


```
import java.util.*;

public class Objekteverwaltung {
       
       
                protected  int ID;
                protected  String name;       
                  
                
                
               public static void hinzufügen(List list){
            	   list.add(list);
            	   System.out.println(list);
               }
               // Einzelnes Hinzufügen einzelner Objekte
               // -------------- für Aufgabe 3 ---------
               public static void hinzufügen1(List list,Object o){
            	   list.add(o);
            	   System.out.println(o+" wurde in Liste gespeichert");
               }
               
                // Suchfunktion für Array Liste anhand ID
                public static void suchen(List list,Sphere sphere){
                                               
                        Iterator it1=list.iterator();
                        while(it1.hasNext()){
                        it1.next();
                       
                        if(sphere.getID()==30){
                                list.remove(sphere);
                               
                       
                                System.out.println("Das Objekt " +sphere+" wurde gefunden");
                                  break;     
                        }
                        else{
                               
                                System.out.println("Das Objekt mit der ID wurde nicht gefunden");
                                // break für direkten Schleifenabbruch 1 malige Ausgabe 
                                break;
                        }
                }
                }
                // Löschfunktion für Array Liste
                public static void löschen(List list,Point point){
                        
                        Iterator it=list.iterator();
                        while (it.hasNext()){       
                        Object o=it.next();
                   
                        if(point.getID()==10){
                        list.remove(o);
                                                               
                   
                        System.out.println("Objekt mit der ID "+point.getID()+" wurde gelöscht,"
                                          +" Restlist ist:"+list);
                       }
                       else{
                               list.remove(o);
                               System.out.println("Das Objekt mit der ID wurde nicht gefunden");
                               // Schleifenabbruch 
                               break;
                      }
                   }
                }
                // Filterfunktion auf Liste angewendet
                public static void filtern(List list,Linie linie){
                	Iterator it2=list.iterator();
			        while(it2.hasNext()){
			        	Object o=it2.next();
			        	if(list.contains(linie)){
			        		list.remove(o);
			        		System.out.println("Die Liste enthält ein "+list.get(0));
			        	}
			        		else{
			        			System.out.println("Das Objekt ist nicht vorhanden");
			        			break;
			        	}
			        }
                }
}
```
 Das ist jetzt die Klasse in der nur Funktionen geschrieben sind die von meiner Main Klasse die jetzt folgt geerbt werden !!!



```
import java.io.*;
import java.util.*;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;
public class Kontrolle extends Objekteverwaltung {
	
	private ArrayList c1;
	/**
	 * @author Stephan Trapp
	 */
	
    
	public static void main(String[] args) {
        // Objects construction
		Point point=new Point("Punkt",10,20,30,40);
		Linie linie=new Linie("Linie",20,5,10);
		Sphere sphere=new Sphere("Kugel",30,3,1,"gelb");
		Triangle triangle=new Triangle("Dreieck",40,50,-25,-40,"pink");
		
		
		
         // Consctrucion of an ArrayList
		ArrayList c = new ArrayList();
		
		c.add(point);		
		c.add(linie);
		c.add(sphere);
		c.add(triangle);
		
		

		
	boolean ende=false;
	mainMenü: while(ende==false){
	    // Printing of the "Objektverwaltung" with Switch Construct
		System.out.println("Die Objekteverwaltung von Grafiken");
		System.out.println("=================================="+
				           "==================================");
		System.out.println("\nHauptmenue");
		System.out.println("\n(1) Objekte in Datei schreiben");
		System.out.println("(2) Objekte auslesen");		
		System.out.println("(3) Objekte suchen");
		System.out.println("(4) Objekt loeschen");
		System.out.println("(5) Objekte filtern");
		System.out.println("(6) Objekte hinzufügen");
		System.out.println("\n(0) Programm beenden");
		try{
			System.out.println("\nAuswahl: ");
			Scanner eingabe=new Scanner(System.in);
			int auswahl=eingabe.nextInt();
			
			switch(auswahl){
			
            //	Fall 1 Objekte in Datei schreiben
			
			case 1: System.out.println("\n Objekt werden angelegt...");
                    
                    
			        try{
			        	// Serialisiert Objekt und legt ArrayList und Eingabe in Datei
			        	FileOutputStream fos = new FileOutputStream("test.txt");
						ObjectOutputStream oos = new ObjectOutputStream(fos);
						
		        		// Schreibt ArrayList in Datei
		        		
		        		oos.writeObject((ArrayList) c);
		        		System.out.println(c);
					    						
					    System.out.println("ArrayList wurde in Datei gespeichert");
					    oos.close();
					    }
			        
			        
			        
			catch(IOException e){
				e.printStackTrace();
			}
					
			break;
             //	 Fall 2 Liest aus ArrayList
			case 2:  System.out.println("Objekte laden...");
			       	        	        
	        
	        	 try{
	        		 FileInputStream in=new FileInputStream("test.txt");
	        		 ObjectInputStream in1=new ObjectInputStream(in);
	        		
	        		 c=(ArrayList)in1.readObject();
	        		 System.out.println(c.toString());
	        		 in1.close();
	        		 
	        	 }	 
	        catch(FileNotFoundException e){
	        	System.out.println("Datei nicht gefunden");
	        }
	        break;
			// Fall 3 Objekt anhand ID suchen	
			case 3: suchen(c,sphere);
				    				
				break;
				
			// Fall 4  Objekte Anhand ID in der ArrayList löschen
			case 4:   löschen(c,point); 
				       				       				     				            
			break;
			
			// Fall 5 Objekte nach Namen filtern
			
			case 5: filtern(c,linie);
			
			break;
			// Fall 6 Objekte zur ArrayList hinzufügen
			
			case 6: System.out.println("Objekt anlegen...");
			        try{
			        	System.out.println("\nBitte wählen Sie: ");
			        	System.out.println("(1) für Sphere");
			        	System.out.println("(2) für Point");
			        	System.out.println("(3) für Linie");
			        	System.out.println("(4) für Triangle");
			        	System.out.println("(5) Hauptmenü");
			        	System.out.println(" Nummer eingeben :");
			        	
						Scanner eingabe1=new Scanner(System.in);
						int auswahl1=eingabe1.nextInt();
						switch(auswahl1){
						case 1: hinzufügen1(c,sphere);
						break;
						case 2: hinzufügen1(c,point);
						break;
						case 3: hinzufügen1(c,linie);
						break;
						case 4: hinzufügen1(c,triangle);
						break;
						case 5:   break;
						}}
			        catch(Exception e){
				    e.printStackTrace();
			        }
			        
			break;
			// Fall 0 Exit Program
			case 0: System.out.println("\nProgramm wurde beendet");
			ende=true;
			break;
			default: System.out.println("\nEingabe existiert nicht");
			
			
			}}
		catch(Exception e){
			System.out.println("");
		}
		 
		
		}
	}}
```


----------



## ARadauer (22. Okt 2008)

```
public class Linie extends Objekteverwaltung
```
deine Linie ist also eine Objekteverwaltung? warum?
ist ein hund und eine tierhandlung?

"Generalisierung" ich habe Eigenschaften und Methoden gemeinsam somit leite ich meine Klassen von anderen Klassen ab....

warum leitest du von Objektverwaltung ab? ich würde das nicht machen, dann kannst du deine formen von einer gemeinsamen abstrakten klasse ableiten... was du aber nicht muss, du kannst ja auch interfaces verwenden


----------



## Gast (22. Okt 2008)

Andreas Adenauer hat wieder Recht... Man könnte ja noch verstehen, wenn die Klasse Objektverwaltung instanzen von Linie verwalten würde.


----------



## Guest (23. Okt 2008)

Ja der Name "Objekteverwaltung" hab ich wohl ein wenig falsch gewählt es sollen ja nur die Methoden geerbt werden die ich darin habe  und zum Thema warum eine Objekteverwaltung für Linien usw? Die Eigenschaften der ZeichenObjekte sollen einfach nur gespeichert werden so ähnlich wie eine Benutzerverwaltung Daten speichert nur halt diesmal mit den Eigenschaften von Zeichenobjekten.


----------



## Guest (23. Okt 2008)

zum Sortieren hab ich das jetzt so gemacht :


```
List c = new ArrayList();
				
		c.add(point.toString());		
		c.add(linie.toString());
		c.add(sphere.toString());
		c.add(triangle.toString());

                                Iterator it1 = c.iterator();
				while (it1.hasNext ())
				System.out.println ((String) it1.next ());
				System.out.println("---");
				//Sortierte Ausgabe
				Collections.sort(c);
				it1 = c.iterator();
				while (it1.hasNext ())
				System.out.println((String)it1.next());
```


Funktioniert ja schön und gut allerdings will ich auch mal gerne wissen wie ich es mit einem Comparator schaffe


----------



## ARadauer (23. Okt 2008)

> Ja der Name "Objekteverwaltung" hab ich wohl ein wenig falsch gewählt es sollen ja nur die Methoden geerbt werden die ich darin habe


ich finde der name passt, schon hinzfügen, löschen... verwalten halt..



> warum eine Objekteverwaltung für Linien usw


ich würd mir die vererbung nochmal ansehen, du verwechselst da was. eine linie ist bei dir eine Objekteverwaltung. so wie ein hund ein tier ist. es geht bei der vererbung niciht darum, dass die linie die methoden von Objekteverwaltung benutzen kann, sondern das linie die methoden selber hat.

tier kann springen, hund kann springen,
ein hund kann zu einer tierhandlung hinzugefügt werden, aber deswegen braucht der hund diese methode nicht...



> Die Eigenschaften der ZeichenObjekte sollen einfach nur gespeichert werden so ähnlich wie eine Benutzerverwaltung Daten speichert nur halt diesmal mit den Eigenschaften von Zeichenobjekten


geht schon in die richtige richtung. die daten halten die linien usw.. selber und diese objekte können in der Objekteverwaltung verwalltet werden, aber dieswegen müssen sie nicht davon erben...

also langer rede kurzer sinn: deine formen nicht von Objekteverwaltung  erben lassen....
extends Objekteverwaltung .... raus damit


----------



## ARadauer (23. Okt 2008)

Comperator vs Comparable
Comperator: du hast eine Klasse die fürs Sortieren zuständig ist und weiß welches objekt jetzt größer ist
Comparable: die objekte sind vergleichbar, ein objekt weiß selber wenn es größer ist..


schau dir das mal ganz genau an, da ist auch die sache mit der vererbung drin, schau meine linie leitet nicht von der verwaltung ab...

```
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class Test {
   
   public static void main(String[] args) {
      
      Objectverwaltung verwaltung = new Objectverwaltung();
      
      verwaltung.addForm(new Kreis("Kreis1"));
      verwaltung.addForm(new Linie("Linie2"));
      verwaltung.addForm(new Kreis("Kreis2"));
      verwaltung.addForm(new Linie("XXX"));
      
      verwaltung.sortieren();
      verwaltung.ausgeben();
   }
   

}

class FormComperator implements Comparator<Form>{

   @Override
   public int compare(Form o1, Form o2) {
     return o1.getName().compareTo(o2.getName());
   }
   
}

class Objectverwaltung{
   ArrayList<Form> formen;
   public Objectverwaltung() {
       formen = new ArrayList<Form>();
   }
   
   public void addForm(Form f){
      formen.add(f);
   }
   
   public void sortieren(){
      Collections.sort(formen); //wenn wir das so machen, kannst du dir den Comperator sparen
   }
   
   
   public void sortierenMitComperator(){
      Collections.sort(formen, new FormComperator()); //wenn wir das so machen, kannst du dir das Comparable sparen
   }
   
   
   public void ausgeben(){
      for(Form f: formen){
         System.out.print(f.getName()+" :");
         f.zeichneDich();
      }
   }
   
   public Form suchen(String wasweisich){
     //....
      return null;
   }
   
   public void remove(Form f){
      //...
   }
   
}

abstract class Form implements Comparable<Form>{   
   private String name;
   

   public Form(String name) {
      super();
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   
   @Override
   public int compareTo(Form o) {
     return getName().compareTo(o.getName());
   }
   
   public abstract void zeichneDich();
   
   
}

class Kreis extends Form{
   public Kreis(String name) {
      super(name);
   }

   String name;

   @Override
   public void zeichneDich() {
     System.out.println("zeichne Kreis");
      
   }   
}


class Linie extends Form{
   public Linie(String name) {
      super(name);
    }

   String name;

   @Override
   public void zeichneDich() {
      System.out.println("zeichne Linie");
      
   }   
}
```


----------



## Guest (23. Okt 2008)

ach sooo ich verstehe ich brauche die Funktionen garnicht zu erben da ich einfach ein Objekt von Objekteverwaltung erschaffe und damit automatisch auf meine Funktionen zugreifen kann


----------



## ARadauer (23. Okt 2008)

bingo! ;-)


----------



## Guest (23. Okt 2008)

wahnsinn super ich danke dir jetzt probier ich das mit dem Comparator aus


----------



## Guest (23. Okt 2008)

So hab das mit dem Comparator so gemacht ist das so richtig :


```
class ComparatorKlasse implements Comparator
	{ public int compare(Object o1, Object o2) {
	     return o1.toString().compareTo(o2.toString());
	   }
	   
	}
```


als eigene Klasse und in der Klasse meiner Funktionen :




```
public void sortierenMitComperator(){
                    Collections.sort(formen, new ComparatorKlasse());}
```


Und dann aufgerufen in der Main mit :


```
Collections.sort(c,klasse);
		Iterator it = c.iterator();
		while (it.hasNext ())
		System.out.println((String)it.next());
```

Hoffe das das richtig ist


----------



## ARadauer (23. Okt 2008)

return o1.toString().compareTo(o2.toString()); 

naja was gibt dir den toString zurück?

wenn du die methode nicht überschrieben hast, ist das glaub ich irgend ein hashwert


----------



## Guest (23. Okt 2008)

Kann ich in der ComparatorKlasse steht "Objekt" auch schreiben meine eigene Objekte zum Beispiel: Point o1 ??


----------



## Michael... (23. Okt 2008)

Anonymous hat gesagt.:
			
		

> Kann ich in der ComparatorKlasse steht "Objekt" auch schreiben meine eigene Objekte zum Beispiel: Point o1 ??


Nein, da diese Methode ja durch das Interface Comparator implementiert wird. Und dieses Interface verlangt eben eine
Methode compare(Object, Object)


----------



## Landei (23. Okt 2008)

> Und dieses Interface verlangt eben eine Methode compare(Object, Object)


So ein Blödsinn!


```
class UppercaseComparator implements Comparator<String> {
  public int compare(String o1, String o2) {
     return o1.toUpperCase().compareTo(o2.toUpperCase());
  }
}
```


----------



## Michael... (23. Okt 2008)

Tschuldigung, nicht jeder hat die Möglichkeit mit J2SE v5.0 oder höher zu arbeiten.


----------



## Guest (23. Okt 2008)

Landei hat gesagt.:
			
		

> > Und dieses Interface verlangt eben eine Methode compare(Object, Object)
> 
> 
> So ein Blödsinn!
> ...




Was bedeutet der Code? bei mir funktioniert das aber was bedeutet das mit UpperCase?


----------



## Proktmus (24. Okt 2008)

wenn in der API nichts über Uppercase steht, dann ist es Magie, in Java gibt es viele solche Stellen.


----------



## ARadauer (24. Okt 2008)

> Was bedeutet der Code? bei mir funktioniert das aber was bedeutet das mit UpperCase?


ein bisschen muss man schon selber mitdenken!


----------



## Landei (24. Okt 2008)

"Das ist ein String".toUpperCase() --> "DAS IST EIN STRING"
"Das ist ein String".toLowerCase() --> "das ist ein string"


----------



## Guest (24. Okt 2008)

So habe es jetzt mit dem Comparator sortiert.

Mein Prof sagte mir nun ich sollte das nun mal versuchen mit der Methode "public static void sort(Object[] a)"
ohne Comparator ! Dazu denk ich muss ich meine Collection umstrukturieren wie es aussieht in ein Array. Dazu habe ich die Werte einfach kopiert mit :


```
Object[] o = grafik.formen.toArray();
	    for (int i = 0; i < o.length; i++) {
	    System.out.println(o[i]);
	    }
```


Könnt ihr mir da einen Tipp geben wie ich da vorgehen kann?


----------



## Landei (25. Okt 2008)

Wenn du nur sort(Object[] a) nehmen darfst, wird dir nichts anderes übrigbleiben, als die Klasse doch Comparabel zu machen. 

Blöder Prof, beschäftigt ein ganzes Forum!


----------

