# Interface, GenericList, Comparable



## rokko123 (16. Apr 2012)

Hey,

Ich hab ne Aufgabe mit Interface, GenericList und muss die Methoden toString, add, size und sort implementieren. Nur für die sort-Methode die mir noch fehlt, muss ich noch die Methode smallerThan() implementieren, bei der ich aber nicht vorwärts komme. Ich muss so wie ich das verstanden habe auf GeometricObjects casten, so dass die Ergebnisse der Beiden Methoden Rectangle und Triangle miteinander verglichen werden können, so dass ich die Methode sort schreiben kann.
Ich komm aber einfach nicht weiter, hat vielleicht jemand einen Tip für mich? 


```
package u6a3;

public class ListUtils implements IListUtils {

	
	public String toString(GenericList list) {

		if (list == null) {
			return "null";
		} else {

			StringBuffer buf = new StringBuffer();
			buf.append(list.value).append(", ").append(toString(list.next));
			return buf.toString();
		}
	}

	
	public GenericList add(GenericList list, Object value) {
		
		return new GenericList(value, list);
	}

	
	public int size(GenericList list) {
		if (list == null) {
			return 0;
		} else {
			return 1 + size(list.next);
		}
	}

	
	public GenericList sort(GenericList list) {
		
		// muss ich noch machen
	
	}

}
```

Interface Comparable:


```
package u6a3;

/**
 * Interface for objects which can be compared with each other
 */
public interface Comparable {
	/**
	 * Operator <
	 * 
	 * @param rhs the right-hand side of the operation
	 * @return true iff this < rhs; false otherwise
	 */
	public boolean smallerThan(Comparable rhs);
	
	
}
```


Hier muss ich die smallerThan Methode implementieren:


```
package u6a3;

/**
 * abstract class of geometric objects
 */
public abstract class GeometricObject implements Comparable {
	public abstract int area();
	
	public boolean smallerThan(Comparable rhs) 
    {
		 
		 GeometricObject GeoObj = ((GeometricObject) rhs); // wird wohl nicht der richtige Ansatz sein?
		 
		 
	}
}
```

Rectangle:


```
package u6a3;

public class Rectangle extends GeometricObject {
	private int a;
	private int b;
	
	public String toString()
	{
		return String.format("Rectangle(%d,%d)", a, b);
	}
	
	public int area()
	{
		return a * b;
	}
	
	public Rectangle(int base, int height)
	{
		this.a = base;
		this.b = height;
	}
}
```

Triangle:


```
package u6a3;

public class Triangle extends GeometricObject {
	private int base;
	private int height;
	
	public String toString()
	{
		return String.format("Triangle(%d,%d)", base, height);
	}
	
	public int area()
	{
		int product = base * height;
		
		return product / 2;
	}
	
	public Triangle(int base, int height)
	{
		this.base = base;
		this.height = height;
	}
}
```


----------



## nillehammer (16. Apr 2012)

Comparable ist ein bereits verwendeter Name in Java. Ein eigenes Interface so zu nennen ist extrem unglücklich. Mach das bitte nur, wenn explizit in Deiner Aufgabe so gefordert. Abgesehen davon willst Du eine Methode schreiben, die zwei geometrische Figuren (GeometricObject ) anhand ihrer Fläche vergleicht. Der Parameter für die Methode muss also eine geometrische Figur sein.


----------



## SlaterB (16. Apr 2012)

> Der Parameter für die Methode muss also eine geometrische Figur sein. 

nicht wenn das Interface den Parameter als Comparable festsetzt,
es sei denn das Interface ist generisch, wie man beim richtigen Comparable abschauen könnte:


```
public interface Comparable<T> {
    /**
     * [..]
     * 
     * @param   o the Object to be compared.
     * @return  a negative integer, zero, or a positive integer as this object
     *		is less than, equal to, or greater than the specified object.
     * 
     * @throws ClassCastException if the specified object's type prevents it
     *         from being compared to this Object.
     */
    public int compareTo(T o);
}
```
--------

ist soweit erstmal korrekt, der Cast wäre nötig,
sonst fehlt noch jeder Code, eine richtige Frage ist auch nicht erkennbar


----------



## nillehammer (16. Apr 2012)

SlaterB hat gesagt.:
			
		

> nicht wenn das Interface den Parameter als Comparable festsetzt,
> es sei denn das Interface ist generisch, wie man beim richtigen Comparable abschauen könnte:


Hier war die Frage nach dem Code für die Implementierung gestellt. Egal, ob von einem generischen oder nicht-generischen Interface vorgeschrieben, der Parameter für die Methode muss ein GeometricObject sein.


----------



## SlaterB (16. Apr 2012)

@nillehammer
ich kann deine Argumente mit 'müssen' nicht nachvollziehen, jedenfalls würde der Code unten zum Compilerfehler
>   The type GeometricObject must implement the inherited abstract method Comparable.smallerThan(Comparable)	
führen, während ein Comparable-Parameter sauber kompiliert,
das war mein Punkt

vielleicht meintest du was ganz anderes, z.B. dass man von außen besser nur GeometricObject als Argumente an die Methode übergeben sollte?
bzw. dass man in der Methode davon ausgehen kann und muss und der Cast richtig ist?
dann wären wir uns ja einig

'Parameter für die Methode' ist aber nun wirklich der Begriff für den Quellcode in den Klammern der Methoden-Deklaration,
meiner Meinung nach


```
class GeometricObject   implements Comparable {
    public boolean smallerThan(GeometricObject rhs)  {
        return false;
    }
}


interface Comparable {
    public boolean smallerThan(Comparable rhs);
}
```


----------

