# Logeintrag



## bluebaby (17. Dez 2011)

Hallo,
Ich hab da mal eine Frage zu meiner Aufgabe.

Aufgabenstellung: Gegeben ist folgende Klasse Logeintrag:

Das Bild für die Klasse Logeintrag ist im Anhang

Implementiere die Klasse und füge alle notwendigen Methoden hinzu, um diese Klasse in einem SortedSet verwenden zu können. Ein SortedSet sortiert Elemente automatisch beim Hinzufügen, allerdings müssen alle Elemente für diese Funktion das Interface Comparable implementieren. Bei der Implementierung ist darauf zu achten, dass compareTo konsistent mit equals ist. Bei der Sortierung soll zuerst nach Datum, dann nach dem Text und anschließend nach der Nummer sortiert werden.
Schreibe weiters eine Klasse LogVerwaltung, in der als Attribut ein SortedSet verwendet wird. Die Klasse soll neben dem Konstruktor noch Methoden zum hinzufügen, löschen und auflisten von Einträgen haben.

Teste die Klassen Logeintrag und LogVerwaltung ausführlich.

Meine Frage ist jetzt soll ich die Klasse Logeintrag schreiben und dann mit extends die andere Klasse so schreiben das ich die Methoden verwenden kann die ich benötige oder soll ich die Klasse als Interface schreiben damit ich mit implements die Methoden verwenden kann?.

Ich habe erstmal die Klasse Logeintrag geschrieben:

```
import java.util.GregorianCalendar;



public class Logeintrag {
	private long nummer;
	private GregorianCalendar datum;
	private String text;
	
	public Logeintrag(long nr,GregorianCalendar datum,String text){}
	
	public long getNummer(){
		return nummer;
	}
	
	public GregorianCalendar getDaturm(){
		return datum;
	}
	
	public String getText(){
		return text;
	}
	
	public void setText(String text){
		text="Das ist ein Test";
	}
	
	

}
```

Und jetzt soll ich ja eine weitere Klasse schreiben die Logeintrag implementiert.
bluebaby


----------



## AlexSpritze (17. Dez 2011)

Du hast schon eine Klasse Logeintrag geschrieben, und diese implementiert bzw. stellt die Implementation der in dem Diagramm gegebenen Informationen dar.

Du müsstest lediglich noch das Interface 
	
	
	
	





```
Comparable<Logeintrag>
```
 implementieren: 
	
	
	
	





```
public class Logeintrag implement Comparable<LogEintrag> {...}
```
 und dann noch die Klasse LogVerwaltung.


----------



## bluebaby (17. Dez 2011)

AlexSpritze hat gesagt.:


> Du hast schon eine Klasse Logeintrag geschrieben, und diese implementiert bzw. stellt die Implementation der in dem Diagramm gegebenen Informationen dar.
> 
> Du müsstest lediglich noch das Interface
> 
> ...



Hallo wenn ich versuche Comparable zu implementieren kommt mir eine Fehlermeldung: the type Logeintrag must implement the inherited abstract method Comparable<Logeintrag>.compareTo(Logeintrag) 

```
public class Logeintrag implements Comparable<Logeintrag>{
```
An was könnte das liegen?


----------



## bluebaby (17. Dez 2011)

Ich verstehe nicht ganz was jetzt wirklich machen soll.
Soll ich Comparable in der Klasse Logeintrag implementieren oder wie soll ich das verstehen?.
Ich dachte das ich eine weiter Klasse schreiben muss die die Klasse Logeintrag erbt und ich dort die Aufgabenstellung programmiere.
Also ungefähr so: 
	
	
	
	





```
import java.util.GregorianCalendar;


public class Sortedset extends Logeintrag {

	public Sortedset(long nr, GregorianCalendar datum, String text) {
		super(nr, datum, text);
		// TODO Auto-generated constructor stub
	}

}
```
Kann mir bitte jemand helfen ich kenne mich überhaupt nicht mehr aus.


----------



## JohannisderKaeufer (17. Dez 2011)

> the type Logeintrag must implement the inherited abstract method Comparable<Logeintrag>.compareTo(Logeintrag)



Was bedeutet das wohl?

Comparable (Java Platform SE 6)

Hier ist beschrieben wie das Interface Comparable aussieht. Wie dort zu lesen ist, ist dort definiert, das eine Klasse die von Comparable erbt, die methode compareTo<T o>() besitzen muß.

Sprich, du mußt in der Klasse Logeintrag, eine zusätzliche Methode public int compareTo(Logeintrag eintrag) hinzufügen.
Wie die methode aussehen muß ist auf dem Link, bzw. auch in deiner Aufgabenstellung beschrieben.

Das Thema Interfaces solltest du nochmals genauer anschauen.


----------



## bluebaby (17. Dez 2011)

Ok das habe ich jetzt verstanden nur ich verstehe noch immer nicht "wo" ich weiter machen soll, soll ich eine neue Klasse schreiben um die Aufgabenstellung durchzuführen oder soll ich das alles in der Klasse Logeintrag lösen, denn die Klasse Logverwaltung macht ja was anderes um das ich mich später kümmere.


```
import java.util.GregorianCalendar;



public class Logeintrag implements Comparable<Logeintrag>{
	private long nummer;
	private GregorianCalendar datum;
	private String text;
	
	public Logeintrag(long nr,GregorianCalendar datum,String text){}
	
	public long getNummer(){
		return nummer;
	}
	
	public GregorianCalendar getDaturm(){
		return datum;
	}
	
	public String getText(){
		return text;
	}
	
	public void setText(String text){
		text="Das ist ein Test";
	}

	@Override
	public int compareTo(Logeintrag o) {
		// TODO Auto-generated method stub
		return 0;
	}
	
	

}
```


----------



## AlexSpritze (17. Dez 2011)

Meiner Meinung nach verlangt die Aufgabenstellung wirklich nur diese beiden Klassen Logeintrag und LogVerwaltung. Dann vielleicht noch irgendwelche Testklassen. In deinem letzten Code würde wohl nur noch fehlen, dass du die Methoden 
	
	
	
	





```
hashCode(), equals(Object), compareTo(Logeintrag)
```
 implementierst.


----------



## bluebaby (17. Dez 2011)

AlexSpritze hat gesagt.:


> Meiner Meinung nach verlangt die Aufgabenstellung wirklich nur diese beiden Klassen Logeintrag und LogVerwaltung. Dann vielleicht noch irgendwelche Testklassen. In deinem letzten Code würde wohl nur noch fehlen, dass du die Methoden
> 
> 
> 
> ...



Für was benötigt man hier hashcode() ? für das Sortieren oder wie soll ich das verstehen?


----------



## AlexSpritze (17. Dez 2011)

Du sollst ja 
	
	
	
	





```
compareTo
```
 implementieren und darauf achten, dass "compareTo konsistent mit equals ist". Das heißt du implementierst auch die Method 
	
	
	
	





```
Logeintrag.equals(Object)
```
, und laut API zu der Methode 
	
	
	
	





```
Object.equals(Object)
```
: "Note that it is generally necessary to override the hashCode method whenever this method (equals) is overridden, so as to maintain the general contract for the hashCode method, which states that *equal objects must have equal hash codes.*". Das heißt dann im Endeffekt, dass du alle drei Methoden implementieren solltest. Damit die Methoden insgesamt konstistent  sind. Das wäre etwas sinnfrei, wenn ein Objekt zwar equal zu einem anderen wäre, aber der 
	
	
	
	





```
hashCode
```
 nicht übereinstimmt. Und bei der Sortierung von Objekten wird ja auf 
	
	
	
	





```
compareTo
```
 zurückgegriffen, diese Methode sollte genau dann 0 als Rückgabewert liefern, wenn auch equals true liefert. Alles andere wäre, wie gesagt, sinnfrei und nicht konsistent. Das kann die lustigsten Nebenwirkungen haben, zum Beispiel bei deinem 
	
	
	
	





```
SortedSet
```

Wenn du NetBeans (oder auch Eclipse) benutzt, kannst du dir die Methoden equals und hashCode generieren lassen. Dennoch den Code anschauen


----------



## bluebaby (18. Dez 2011)

AlexSpritze hat gesagt.:


> Du sollst ja
> 
> 
> 
> ...



Danke ich hätte da noch eine frage und zwar kann ich die Methode equals und compareTo auch so schreiben? 


```
public int compareTo(HighScorenew o) {
		int wert=this.score - o.getScore();
		if(wert==0){
			int nvergleich=this.name.compareTo(o.getName());
			return nvergleich;
		} else
			return wert;
		
		
	}
	
	@Override
	public boolean equals(Object o){
		if(o instanceof HighScorenew){ // Instanz == Objekt
			HighScorenew h=(HighScorenew)o; // zu HighScorenew casten
			if(this.score == h.getScore() && this.name.equals(h.getName())){
				return true;
			}
				return false;
		}
		else{
			return false;
		}
			
			                                         
		}
```

Das ist ein Beispiel das wir in der Schule gemacht haben.


----------



## AlexSpritze (18. Dez 2011)

Bei den Methoden solltest du auf jeden Fall zu erst auch prüfen, ob die übergebenen Objekte nicht null sind:


```
public boolean equals(Object obj) {
      if (obj == null) {
        return false;
      }
      if (getClass() != obj.getClass()) {
        return false;
      }
      final Highscore other = (Highscore) obj;
      if (this.score != other.score) {
        return false;
      }
      if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
        return false;
      }
      return true;
    }
```

Und compareTo so ungefähr:


```
@Override
    public int compareTo(Highscore o) {
      if (o == null) {
        return -1; // null objekte werden an den Anfang sortiert
      }
      int wert = this.score - o.getScore(); // Objekte mit großer Score werden ans Ende sortiert
      if (wert == 0) { // nach Namen sortieren, ohne Beachtung von Großschreibung
        return String.CASE_INSENSITIVE_ORDER.compare(this.name, o.getName());
      } else {
        return wert;
      }
    }
```


----------



## bygones (18. Dez 2011)

instanceof macht auch schon die null ueberpruefung.


----------



## bluebaby (18. Dez 2011)

Hallo kann jemand vielleicht die Klasse Logeintrag noch kontrollieren ob sie der Aufgabenstellung entspricht?

```
import java.util.GregorianCalendar;



public class Logeintrag implements Comparable<Logeintrag>{
	private long nummer;
	private GregorianCalendar datum;
	private String text;
	
	public Logeintrag(long nr,GregorianCalendar datum,String text){}
	
	public long getNummer(){
		return nummer;
	}
	
	public GregorianCalendar getDatum(){
		return datum;
	}
	
	public String getText(){
		return text;
	}
	
	public void setText(String text){
		text="Das ist ein Test";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((datum == null) ? 0 : datum.hashCode());
		result = prime * result + (int) (nummer ^ (nummer >>> 32));
		result = prime * result + ((text == null) ? 0 : text.hashCode());
		return result;
	}


	public boolean equals(Logeintrag o){
		if(o instanceof Logeintrag){ 
			Logeintrag h=(Logeintrag)o; 
			if(this.nummer == h.getNummer() && this.text.equals(h.getText())){
				return true;
			}
				return false;
		}
		else{
			return false;
		}
			
			                                         
		}
		

	@Override
	public int compareTo(Logeintrag o) {
		if(o==null){
			return -1;
		}
		long wert = this.nummer - o.getNummer();
		if(wert==0){
			return String.CASE_INSENSITIVE_ORDER.compare(this.text, o.getText());
		}
		else{
			return (int)wert;
		}
		
		
	}	

}
```

Wie kann ich jetzt am Besten die Klasse LogVerwaltung realisieren?.
ungefähr so?

```
NavigableSet<Calendar> set = new TreeSet<Calendar>(); 
set.add( new GregorianCalendar(2007, Calendar.MARCH, 10) ); 
set.add( new GregorianCalendar(2007, Calendar.MARCH, 12) ); 
set.add( new GregorianCalendar(2007, Calendar.APRIL, 12) ); 
 
Calendar cal1 = set.lower( new GregorianCalendar(2007, Calendar.MARCH, 12) ); 
System.out.printf( "%tF%n", cal1 );   // 2007-03-10 
 
Calendar cal2 = set.ceiling( new GregorianCalendar(2007, Calendar.MARCH, 12) ); 
System.out.printf( "%tF%n", cal2 );   // 2007-03-12 
 
Calendar cal3 = set.floor( new GregorianCalendar(2007, Calendar.MARCH, 12) ); 
System.out.printf( "%tF%n", cal3 );   // 2007-03-12 
 
Calendar cal4 = set.higher( new GregorianCalendar(2007, Calendar.MARCH, 12) ); 
System.out.printf( "%tF%n", cal4 );   // 2007-04-12
```

Was meint man mit hinzufügen, löschen,auflisten?
Meint man damit das man eine Methode zum hinzufügen schreiben soll so das man Datum, text und nummer hinzufügt? bei Löschen einen Eintragt löscht und bei auflisten diese ausgibt?

Sorry für die dummen Fragen aber programmieren steht mir überhaupt nicht, aber da ich nun mal dieses Fach in der Schule habe versuche ich mich zu bemühen 
Ich danke euch jetzt schon mal das ihr es so lange mit mir aushaltet


----------



## AlexSpritze (18. Dez 2011)

Ich denke, dass mit der Klasse LogVerwaltung so etwas gemeint ist:


```
public class LogVerwaltung {
    private SortedSet<Logeintrag> collection = new TreeSet<Logeintrag>(); // gefordertes Attribut

    public LogVerwaltung(){} // Konstruktor
    
    public void add(Logeintrag eintrag){..} // Methode zum Hinzufügen
    public void remove(Logeintrag eintrag){..} // Methode zum Löschen
    public List<Logeintrag> list(){..} // Auflistung
        
  }
```

Du müsstest dann noch die drei Methoden implementieren. Die Klasse verwaltet sozusagen eine Menge von Logeinträgen


----------



## bluebaby (19. Dez 2011)

Stimmt das so?

```
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.*;

public class LogVerwaltung {
	
	public LogVerwaltung(){}
	
	private SortedSet<Logeintrag> collection = new TreeSet<Logeintrag>();
	
	public void add(Logeintrag eintrag){
		collection.add(eintrag);
	}
	
	public void remove(Logeintrag eintrag){
		collection.remove(eintrag);
	}
	
	public List<Logeintrag> list(){
		Iterator it=collection.iterator();
		while(it.hasNext()){
			System.out.println((String)it.next());
		}
		return (List<Logeintrag>) collection;
	}
	
	
	
	
}
```


----------



## AlexSpritze (19. Dez 2011)

Die Frage ist, was die list() Methode genau machen soll. Wenn sie einfach nur die Einträge auf der Konsole ausgeben soll reicht das:


```
public void list() {
        Iterator it = collection.iterator();
        while(it.hasNext()){
            System.out.println((String)it.next());
        }
    }
```

Andererseits, wenn der Inhalt der 
	
	
	
	





```
collection
```
 zurückgegeben werden soll, dann vielleicht eher so:


```
public List<Logeintrag> list() {
        return new ArrayList<Logeintrag>(collection); // einfache Liste
        }
    }
```

Mit der letzten Variante könnte halt irgendeine andere Klasse noch was mit den Einträgen machen, zum Beispiel in eine Dateischreiben oder sowas. Der Rest ist aber okeh so


----------



## bluebaby (21. Dez 2011)

Hallo ich habe noch eine Frage zur Testklasse und zwar wie kann ich die Atribute einer anderen Klasse verwenden?.


```
public class TestLog {
	

	public static void main(String[]args){
		String a="Das ist der Test für setText()";
	
	LogVerwaltung lv1=new LogVerwaltung();
	Logeintrag le1=new Logeintrag(5, null ,null);

    le1.getNummer();
    System.out.println(le1.getNummer());
    
    le1.getDatum();
    System.out.println(le1.getDatum());
    
    le1.getText();
    System.out.println(le1.getText());
    
    le1.setText(a);
    le1.hashCode();
    le1.equals(le1);
    le1.compareTo(le1);
    
    lv1.add(le1);
    lv1.remove(le1);
    lv1.list();
    
  }
}
```

Ich möchte im Konstruktor ja Werte einsetzten wie kann ich die Atribute einer anderen Klasse verwenden oder muss ich mir diese in der Testklasse selber erzeugen und mit diesen Testen?


----------



## Marcinek (21. Dez 2011)

Galileo Computing :: Java ist auch eine Insel - 3 Klassen und Objekte


----------

