(Generischer) Adapter

[Fenixx]

Hi zusammen,

gegeben sei folgendes Interface:

public interface Dynamic<T> {
T get(int i) throws IndexException;
void set(int i, T t) throws IndexException;
}

Nun habe ich eine gegebene Adapter-Klasse, die dieses Interface implementieren soll und dementsprechend ergänzt werden soll:

public class Adapter
{
Object[] f = new Object[0];
}

Meine Lösung:

public class Adapter implements Dynamic<Object>{

Object[] f = new Object[0];
@Override
public Object get(int i) throws IndexException {
if (i<0 || i>f.length)
throw new IndexException();
return f;
}

@Override
public void set(int i, Object t) throws IndexException {
if (i<0)
throw new IndexException();
if (i>f.length-1)
{
Object[] holder = f;
f = new Object[i+1];
for (int j=0; j<holder.length; j++)
{
holder[j] = f[j];
}
set(i,t);

}
else
f = t;

}

}

Meine Frage: Ist es so richtig, dass ich die Klasse wie folgt deklarieren muss?: "public class Adapter implements Dynamic<Object>"
Wieso reicht es nicht einfach zu schreiben: public class Adapter implements Dynamic<T>? Dementsprechend müssten die Methodendeklarationen von Object nach T geändert werden.

Liegt die Begründung darin, dass T auch ein Primitive also klein int, char, etc. sein kann und deshalb nicht unbedingt folgendes gilt: T extends Object. Sprich T könnte ein Primitive sein?

Gruß

 

[Illuvatar]

Der Trick ist hier, die Adapter-Klasse auch generisch zu machen - ansonsten gehen dir alle Vorteile der Generics verloren:

[HIGHLIGHT="Java"]public class Adapter<T> implements Dynamic<T>[/HIGHLIGHT]

 

[Fenixx]

Das Problem ist, was du noch nicht wissen konntest, dass nach Aufgabenstellung nicht explizit ein generischer Adapter gefordert war:

Gegeben ist das Interface Dynamic.
Programmieren Sie die Klasse Adapter, die das Interface Dynamic implementiert.
• Die Klasse Adapter nutzt das vorgegebene Feld der Klasse Object.
• Die Methode get liefert die Referenz an der Position i von f.
• Die Methode set setzt die Referenz t an der Position i von f.
• Wird beim Aufruf der Methode set ein zu großer Index i benutzt, so soll das
vorhandene Feld durch ein neues Feld mit genau der benötigten Größe ersetzt und mit
den vorhandenen Werten gefüllt werden, so dass set ausgeführt werden kann.
• In allen anderen Fällen, in denen der Index i beim Aufruf von get und set die
Grenzen des Feldes f verletzen würde, wird eine IndexException geworfen.

Demnach ist meine Lösung doch auch akzeptabel oder?

 

[Illuvatar]

Stimmt, in dem Fall ist deine Lösung richtig. Deine Begründung aber nicht ganz

Wieso reicht es nicht einfach zu schreiben: public class Adapter implements Dynamic<T>? Dementsprechend müssten die Methodendeklarationen von Object nach T geändert werden.

Das liegt daran, dass du nicht weißt, was T ist. Stell dir vor, jemand der die Klasse verwendet, legt T auf String fest. T ist durchaus immer ein Object (primitive Typen dürfen hier gerade nicht verwendet werden!) - dennoch hast du keine Information über den geforderten Typ, und könntest deshalb keine get-Methode implementieren, denn du weißt ja nicht was du zurückgeben sollst, und dein Array ist einfach nur ein Object[], und da könnte potentiell alles drin sein - vor allem eben gerade nicht der geforderte Typ.

 

[Fenixx]

Danke für deinen Hinweis. Hier habe ich noch eine abschließende Aufgabe:

Implementieren Sie eine generische Klasse Container, in der Referenzen verwaltet werden
können. Diese Referenzen sollen kompatibel zu genau einer Klasse sein, die bei der Erzeugung
eines Container-Objekes festgelegt wird.
• Die Klasse Container nutzt ein Feld f der Klasse Object.
• Die Klasse Container besitzt einen Konstruktor, der beliebig viele Referenzen als
Parameter übergeben bekommen kann und diese in dem Feld f ablegt.
• Die Klasse Container besitzt eine Methode at(int p), die die Referenz liefert, die
an der als Parameter übergebenen Position p von f steht. Würden bei einem Aufruf
von at die Grenzen des Feldes f verletzt, so wird eine Ausnahme der Klasse
IndexException geworfen.
Ergänzen Sie hier:
public class Container
{
private Object[] f;
}

Meine Lösung:

public class Container<T> {

private Object[] f;

public Container(T... arg) {
f = new Object[arg.length];
for (int i=0; i<arg.length; i++)
{
f = arg;
}
}

public Object at(int p) throws IndexException {
if (p<0 || p>=f.length) throw new IndexException();
else return f[p];
}

}

Ist das so akzeptabel? Kann ich im Konstruktor nich einfach folgendes sagen?
public Container(T... arg) {
f = arg;
}

T... steht doch für ein Array oder nicht?

 

[Illuvatar]

Kann ich im Konstruktor nich einfach folgendes sagen?
public Container(T... arg) {
f = arg;
}

T... steht doch für ein Array oder nicht?

Warum probierst du es nicht einfach? Ich wüsste nichts was dagegen spricht.

 

[Fenixx]

Jo stimmt. Es ist ein Array. Aber wieso kann ich dort keine ArrayList beispielsweise übergeben?

 

[Illuvatar]

Jo stimmt. Es ist ein Array. Aber wieso kann ich dort keine ArrayList beispielsweise übergeben?

Weil es keinen Konstruktor gibt, der eine ArrayList als Parameter nimmt? T... ist intern exakt das gleiche wie T[], nur dass der Compiler dir erlaubt, das als varargs zu schreiben. Da kannst du natürlich keine ArrayList übergeben.
Allerdings hindert dich niemand daran, einen zweiten Konstruktor zu schreiben, mit einer ArrayList als Parameter.

(Allerdings: bitte vorsichtig sein bei überladenen Methoden und varargs. Wenn T dann mal auf ArrayList festgelegt wäre, wäre es nicht mehr einfach ersichtlich, welcher Konstruktor aufgerufen wird, wenn eine einzelne ArrayList übergeben wird)

 

[musiKk]

Es ist spezifiziert, welche Methode genommen werden muss: die spezifischste (JLS 15.12.2.5). Auch wenn man sich hier wieder auf einem schmalen Grad bewegt. Ich würde sagen, dass das noch nicht allzu tief in der Trickkiste ist. Das soll jetzt keine Diskussion über Programmierstil geben, ich bin nur detailverliebt (und klugscheiße gerne).