Aufgabe Generics

[katze555]

Ich muss folgende Aufgabe möglichst gut und ordentlich lösen:

http://jeebone.je.funpic.de/java/6.JPG

das hab ich bisher folgendermaßen gemacht:


[Java]import java.util.ArrayList;

public class Hole<T>
{

private ArrayList<T> objects = new ArrayList<T>();
private int depth;
private boolean isBlack = false;

public static void main(String[] args)
{
Hole<String> hole = new Hole<String>(1);
hole.dump("FFG");
System.out.print(hole.get());
}

Hole(int n) throws RuntimeException
{
if(n <= 0)
throw new RuntimeException();
this.depth = n;
}

public int depth()
{
if(this.isBlack)
return Integer.MAX_VALUE;
return this.depth;
}

public void dump(T x)
{
if(objects.size() < depth || this.isBlack())
objects.add(x);
}

public boolean isEmpty()
{
if(objects.size() == 0 || this.isBlack)
return true;
return false;
}

public int size()
{
if(this.isBlack)
return Integer.MAX_VALUE;
return objects.size();
}

// ältestes zurückgeben und löschen, so interpretiere ich das
public T get()
{
if(this.size() > 0 && !this.isBlack)
return objects.remove(0);
return null;
}

public void deepen(int n) throws RuntimeException
{
if(n <= 0)
throw new RuntimeException();
this.depth += n;
}

public void dumpInto(Hole<T> that) throws RuntimeException
{
if(this.isBlack() && !that.isBlack())
throw new RuntimeException();
while(this.size() > 0)
that.dump(this.get());
}

public void black()
{
this.isBlack = true;
}

public boolean isBlack()
{
return this.isBlack;
}

}[/Java]


da ich aber noch Anfänger bin, wird das sicher nicht perfekt sein, könntet ihr mir sagen, wo da noch was zu verbessern ist, bzw wo was nicht so schön ist usw ...

 

[Marcinek]

ich würde bei black() die maxsitze() auf MAX_INT setzen.

Dann ersparst du dir überall das isBlack() abzufragen, weil dann die size() ihr übriges tut.

 

[eRaaaa]

das throws RuntimeException an den Methodensignaturen kannst du dir sparen! Da du hier eine RuntimeException wirfst, die man nicht fangen muss, braucht mans nicht oben angeben, nur werfen 🙂

 

[Landei]

So würde ich das machen:

import java.util.ArrayList;
import java.util.List;

public class Hole<T> {
    
    private List<T> objects = new ArrayList<T>();
    private int depth;
    
    public static void main(String[] args)
    {
        Hole<String> hole = new Hole<String>(1);
        hole.dump("FFG");
        System.out.print(hole.get());
    }
    
    Hole(int n) throws RuntimeException
    {
        if(n <= 0)
            throw new RuntimeException();
        this.depth = n;
    }
    
    public int depth() {
        return objects == null ? Integer.MAX_VALUE : depth;
    }
    
    public void dump(T x) {
        if(objects != null && objects.size() < depth) {
            objects.add(x);
        }
    }
    
    public boolean isEmpty() {
        return objects == null || objects.isEmpty();
    }
    
    public int size() {
        return objects == null ? Integer.MAX_VALUE : objects.size();
    }
    
    // ältestes zurückgeben und löschen, so interpretiere ich das
    public T get() {
        return isEmpty() ? null : objects.remove(0);
    }
    
    public void deepen(int n) throws RuntimeException
    {
        if(n <= 0)
            throw new RuntimeException();
        this.depth += n;
    }
    
    public void dumpInto(Hole<T> that) throws RuntimeException
    {
        if(this.isBlack() && !that.isBlack())
            throw new RuntimeException();
        while(! isEmpty())
            that.dump(this.get());
    }
    
    public void black() {
        objects = null;
    }
    
    public boolean isBlack() {
        return objects == null;
    }
    
}

Wobei diese Aufgabe eigentlich nach zwei unveränderlichen Unterklassen (eventuell versteckt als innere Klassen) "NormalHole" und "BlackHole" schreit...

 

[Marco13]

Wobei diese Aufgabe eigentlich nach zwei unveränderlichen Unterklassen (eventuell versteckt als innere Klassen) "NormalHole" und "BlackHole" schreit...

Wenn da die Methode "black" nicht wäre, die ersteres in letzteres verwandeln muss...

 

[Landei]

Man könnte die äußere Klasse als reinen "Wrapper" implementieren, und intern zwei immutable NormalHole / BlackHole Klassen verwenden. Wird der Leerkörper aber nicht mögen...

 

[Marcinek]

Eigentlich müsste beim setzen von black() das getten nicht mehr gehen..

Somit müssten die Objekte auch nicht mehr in der Liste gespeichert werden..

 

[Landei]

??? Mach ich doch auch so...

 

[Degget]

Man könnte die äußere Klasse als reinen "Wrapper" implementieren, und intern zwei immutable NormalHole / BlackHole Klassen verwenden. Wird der Leerkörper aber nicht mögen...

Was wäre der große Vorteil daran und warum glaubst du, dass die Lehrkraft dem skeptisch gegenüber stehen wird? Ist es nichts, was man normalerweise tut?

 

[Landei]

Der große Vorteil wäre, dass zwei völlig unterschiedliche Verhaltensweisen auch auf zwei völlig unterschiedliche Klassen aufgeteilt würde.

Die Leerkraft würde dem skeptisch gegenüberstehen, weil sie von guter Programmierung keine Ahnung hat 😛
Denn sonst hätte sie schon bei der Aufgabenstellung ein Hole mit einer immutablen API vorgezogen, q.e.d.

 

[slawaweis]

da ich aber noch Anfänger bin, wird das sicher nicht perfekt sein, könntet ihr mir sagen, wo da noch was zu verbessern ist, bzw wo was nicht so schön ist usw ...

sieht schon ganz gut aus. Man kann sich aber die Varible "isBlack" sparen. Für "black()" reicht es einfach "objects" auf null zu setzen und es immer abzufragen. So schickt man auch die bisherigen gespeicherten Objekte ins Nirvana. RuntimeException sollte man nicht zu der Funktionsdeklaration hinzufügen. Weiterhin sollte man unbedingt immer eine Erklärung in die RE schreiben, z.B.: RuntimeException("n darf nicht negativ sein!"). In "dump(T x)" gehört übrigens auch eine RuntimeException rein, damit der Verwender weis, ob das Objekt gespeichert wurde oder nicht.

Slawa