Verständniss Problem bei abstract class

Guten Tag zusammen,

hier habe ich eine Aufgabe die ich ehrlich gesagt nicht einmal wirklich verstehe :( Ich weiß einfach nicht was zu tun ist.
Kann mir das ganze hier vielleicht irgendjemand etwas erklären? Bin dankbar für jede Hilfe :)

Hier mal die Klasse:
Java:
import java.util.*;

public abstract class Bla<U> implements Iterable<B> {
    List<Bla<U>> elements;
    U nodeMarker;
    void getMarkers(List<U> result) {
        result.add(U);
        for(Bla<U> e : elements)
            e.getMarkers(result);
    }

}
Nun soll eine Unterklasse geschrieben werden von Bla<U> die nicht mehr abstrakt ist.

Was ich schon nicht verstehe ist das bei dem Code-Rahmen schon ein Fehler drin ist!
Denn result.add(U); ist doch Falsch ich kann doch keinen Generischen Typ nehmen wir bei U = String in eine Liste aufnehmen!
Da könnte null (für jeden Referenztyp) oder ein "" (leerer String) drin stehen okay doch einfach List.add(String) <- Was soll das werden?
Wenn Ihr mir jetzt sagt das geht dann verstehe ich gar nichts mehr!

Würde die Zeile also so schreiben:
Java:
result.add(nodeMarker);
Dann würde ich das ganze so verstehen das aus elements jedes Element in die Liste result aufgenommen werden soll? Doch keine Ahnung ob das stimmt :(

Vielleicht kann mir hierbei ja jemand helfen :)

LG
 
Was ich schon nicht verstehe ist das bei dem Code-Rahmen schon ein Fehler drin ist!
Es geht schon mal damit los, dass Du einen nicht deklarierten Typparameter verwendest: implements Iterable<B>. Wo kommt das B her?

Dann:
Java:
result.add(U);
result ist eine Liste von Bla-Elementen - was willst Du denn plötzlich mit dem U?

Analog dazu der Aufruf
Java:
e.getMarkers(result);
getMarkers erwartet eine Liste von U-Elementen. Da kannst Du nicht einfach eine Liste von Bla-Elementen übergeben.

PS: hoffentlich liest dieses Bla Bla niemand :)
 
mhhh... also das hier war mein Fehler Tippfehler :D
Java:
public abstract class Bla<U> implements Iterable<B> {
muss selbstverständlich so heißen:
Java:
public abstract class Bla<U> implements Iterable<U> {
Das Problem ist ja das es eine Vorgabe von der Aufgabe ist und ich ja genau diese Fragen habe wie man damit eine "Normale" Klasse schreiben soll???

Das erste war eben Schreibfehler sry hab es mir nicht mehr durchgelesen!

So wie ich das lese soll man dort nicht einfach aus einer Klasse die elements speichert als Liste eine Methode schreiben die nur hin geht die Werte in eine andere Liste speichert.
Was ich meine ist:

List<List<Integer>> elements und daraus eine neue Liste List<Integer> macht. Würde das irgendwie Sinn machen?
Leider kann ich jetzt auch niemand mehr fragen da Vorlesungsfreizeit ist :( sonst hätte ich den Prof mal gefragt :p

LG
 
List<List<Integer>> elements und daraus eine neue Liste List<Integer> macht. Würde das irgendwie Sinn machen?
Naja, das eine ist eine Liste von Listen, die Integers halten. Das andere ist eine einfache Liste, die Integers hält. Klingt das sinnvoll?

Da könnte null (für jeden Referenztyp) oder ein "" (leerer String) drin stehen okay doch einfach List.add(String) <- Was soll das werden?
Null heißt, jedenfalls soweit ich weiß, keinesfalls "jede Referenz". Wenn du jede Referenz akzeptierst, dann sagst du 'Object', weil daß sozusagen die Mutter aller Klassen ist.
Null heißt eigentlich eher 'Keine Referenz'. Jedenfalls kenne ich es in diesem Kontext.
 
Also, noch hast du ja überhaupt nicht die eigentliche Aufgabenstellung genannt, außer, dass eine Subklasse geschrieben werden soll, die "kompiliert". Und, damit die Subklasse kompiliert, brauchst du eine Implementierung von iterator(), da die Superklasse ja das Iterable Interface implementiert.
Es ist also vermutlich gefordert, dass du einen Iterator in dieser iterator() Methode implementierst und zurücklieferst, der über alle (rekursiven) Elemente iteriert.
Geht zum Beispiel so:
Java:
import static java.util.Spliterators.spliteratorUnknownSize;
import static java.util.stream.Stream.of;
import static java.util.stream.Stream.concat;
import static java.util.stream.StreamSupport.stream;
import java.util.*;
import java.util.stream.Stream;
public class ConcreteBla<U> extends Bla<U> {
  ConcreteBla(U nodeMarker, List<Bla<U>> elements) {
    this.nodeMarker = nodeMarker;
    this.elements = elements;
  }
  @Override
  public Iterator<U> iterator() {
    return concat(of(nodeMarker), elementsToStream()).iterator();
  }
  private Stream<U> elementsToStream() {
    return elements.stream().map(Bla::iterator).flatMap(this::iteratorToStream);
  }
  private Stream<U> iteratorToStream(Iterator<U> it) {
    return stream(spliteratorUnknownSize(it, Spliterator.ORDERED), false);
  }
}
 
Aufgabenstellung:
Schreiben Sie eine Unterklasse der Klasse Bla<U> die nicht mehr abstrakt ist. Nutzen Sie für Ihre Lösung aus, dass eine Liste die Methode iterator() hat.

Somit verstehe ich unter der Aufgabe so wie ich es oben geschrieben habe.
Man soll das Datenelement aus der Abstrakten Klasse "clonen". Man übergibt ein Paramet an die Methode getMarkers und der Parameter in diesem Falle eine Liste soll dann die Element aufnehmen die in der Liste<Bla<U>> drin sind. Sprich ich Kopiere nur jedes Bla<U> aus der Liste elements.

@httpdigest der Code sieht ja mal mega cool aus. Werde ich mir genauer anschauen :) Danke erstmal für die Mühe :)


LG
 
Nein, du sollst hier nichts klonen. Du sollst einfach eine nicht-abstrakte Subklasse von Bla<U> schreiben und die hierfür erforderliche Methode iterator() aus dem implementierten Iterable Interface implementieren. Um den Iterator korrekt zu implementieren, kannst du ausnutzen, dass eine java.util.List (was die Bla.elements Liste ja ist!) ja selbst ein Iterable ist, also iterator() unterstützt. Mehr nicht. Nichts mit Klonen, Duplizieren oder sonstwas. Du sollst einfach nur iterator() implementieren.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben