Generics

Xeno1987

Mitglied
Hallo,

ich bin bei der eine Aufgabe schon am verzweifeln muss nächste Woche schon abgeben.

Also

Diese Aufgabe basiert auf der in der Vorlesung vorgestellten generischen Implementierung
einer sortierten verketteten Liste (vgl. Abschnitt 0.3). Durch diese allgemeine Implementierung
ist es möglich diese Liste auch für andere Objekttypen zu verwenden, ohne die Implementierung
der Liste ändern zu müssen.

a) Implementieren Sie eine Klasse BeerBottle und modellieren Sie darin die Bezeichnung,
Brauerei, Alkoholgehalt sowie die Füllmenge. Geben Sie einen Konstruktor an
und überschreiben Sie die toString()-Methode geeignet. (2 Punkte)

b) Erweitern Sie BeerBottle, so dass unter Verwendung des Interface MyList und
der Klasse MyLinkedList (in unveränderter Form(!)) eine Liste von Objekten dieses
Typs erzeugt werden kann. Die Sortierung soll anhand der Füllhöhe (aufsteigend)
realisiert werden. Sollten zwei Flaschen die selbe Füllmenge besitzen, so soll alphabetisch
nach der Bezeichnung sortiert werden. Testen Sie Ihre Implementierung in einer
main-Methode.(7 Punkte)


Teil a) habe ich hoffe ich richtig gelöst aber bei b) komme ich nicht weiter, soll ich die Klasse Bottle so erweitern, dass ich über die LinkedList elemente einfügen kann?

Hier mal mein Ansatz:

Klasse MyList(von der Aufgabenstellung):

Java:
public interface MyList <X extends Comparable<X>>
{   
    /**
     * insert fuegt das Paremeterobjekt sortiert in die Liste ein.
     * @param o  einzufuegendes Objekt
     * @return   true, wenn das Objekt eingefuegt wurde
     *           false, wenn das Objekt nicht eingefuegt wurde, weil
     *           ein Objekt mit dem gleichen Inhalt bereits
     *           in der Liste existiert
     */
   public boolean insert(X o);

    /**
     * delete loescht das Objekt mit dem gleichen Inhalt wie das
     * Parameterobjekt aus der Liste
     * @param o  zu loeschendes Objekt
     * @return   true, wenn das Objekt geloescht wurde
     *           false, wenn das Objekt nicht geloescht wurde, weil
     *           ein Objekt mit dem gleichen Inhalt nicht existiert
     */
   public boolean delete(X o);
   
    /**
     * search sucht in der Liste nach einem Objekt mit dem gleichen
     * Inhalt wie das Parameterobjekt
     * @param o  zu suchendes Objekt
     * @return   null, falls Objekt nicht gefunden wurde
     *                gefundenes Objekt sonst
     */
   public X search(X o);
   
   /**
    * showList liefert den Inhalt aller Elemente der Liste 
    * hintereinander als Zeichenkette
    */
   public String showList();
   
}

MyLinkedList:

Java:
public class MyLinkedList<X extends Comparable<X>> implements MyList<X>
{
    private class ListElement
    {
        X content;
        ListElement next;
        
        public ListElement(X content, ListElement next)
        {
            this.content = content;
            this.next = next;
        }

    }
    
    private ListElement first = null;


    /**
     * insert fuegt ein Element in die Liste ein
     * @param element  einzufuegendes Element
     * @return  true: Element wurde eingefuegt
     *               false: Element ist schon vorhanden, keine Einfuegung
     */
    public boolean insert(X element) {
           ListElement laufzeiger = first;
           ListElement vorgaenger = null;
           while(laufzeiger != null) {
               int vergleich = (laufzeiger.content).compareTo(element);
               if (vergleich==0) return false;
               if (vergleich > 0) break;
              
               vorgaenger = laufzeiger;
               laufzeiger = laufzeiger.next;
           }
           
           if (vorgaenger==null) 
               first = new ListElement(element,laufzeiger);
           else 
               vorgaenger.next = new ListElement(element,laufzeiger);
        
           return true;    
    }    
    
    /**
     * delete loescht ein Element aus der Liste
     * @param element zu loeschendes Element
     * @return  true: element wurde geloescht
     *               false: element in der Liste nicht vorhanden
     */
    
    public boolean delete(X element) {
        ListElement laufzeiger = first;
        ListElement vorgaenger = null;
        while(laufzeiger!=null) {
            int vergleich = (laufzeiger.content).compareTo(element);
            if (vergleich>0) return false;
            if (vergleich==0) {
                if (vorgaenger== null)
                    first = laufzeiger.next;
                else
                    vorgaenger.next = laufzeiger.next;
                
                return true;    
            }  
            
            vorgaenger = laufzeiger;
            laufzeiger = laufzeiger.next;
        }    
        
        return false;  
    }    

    /**
     * search sucht ein Element in der Liste
     * @param element   zu suchendes Element
     * @return null, falls Objekt nicht gefunden wurde
     *              gefundenes Objekt sonst
     */
    public X search(X element) {
        ListElement laufzeiger = first;
        while(laufzeiger!=null) {
            int vergleich = (laufzeiger.content).compareTo(element);
            if (vergleich>0) return null;
            if (vergleich==0) return laufzeiger.content;
                
            laufzeiger = laufzeiger.next;
        }    
        
        return null;  
    }    
    
    /**
     * showList wandelt die Elemente der Liste in
     * eine Zeichenkette um, wobei jedes Element durch
     * '\n' abgeschlossen wird 
     */
        
    public String showList() {
        String ergebnis = "";
        ListElement laufzeiger = first;
        
        while (laufzeiger != null){
            ergebnis = ergebnis +  (laufzeiger.content).toString() + '\n';
            laufzeiger = laufzeiger.next;
        }    
        
        return ergebnis;
        
        
    }    
    
    
    
    
    
    
    
   

  
}

Und jetzt mein Code :

Java:
public class BeerBottle{

   private String bezeichnung;
   private String brauerei = "";
   private double vol;
   private double menge;
   
   public BeerBottle(String bezeichnung, String brauerei, double vol, double menge){

      this.bezeichnung=bezeichnung;
      this.brauerei=brauerei;
      this.vol=vol;
      this.menge=menge;
   }
   
   public String toString(){

      return "Das Bier " + this.bezeichnung + " von der Brauerei" + this.brauerei + ", " + this.menge + " enthaelt " + this.vol + " Alkohol!";
   }

   public MyLinkedList sortUp(double menge){



        return null;
   }

}

und die main:

Java:
public class Main{

   public static void main(String[] args){

      MyLinkedList kasten = new MyLinkedList();
      
      kasten.insert(new BeerBottle("becks", "bremen", 4.9, 0.5));

   }

}
 

Landei

Top Contributor
[c]MyList[/c] fordert doch, dass der übergebene Typ [c]X[/c] auch ein [c]Comparable<X>[/c] ist, also muss das [c]BeerBottle[/c] eben implementieren:

Java:
public class BeerBottle implements Comparable<BeerBottle> {
  ...
  public int compareTo(BeerBottle otherBottle) {
   ???
  } 
}

Was du für die ??? eintragen musst, sagt doch die Aufgabenstellung schon recht deutlich.
 
Zuletzt bearbeitet:

Xeno1987

Mitglied
Hallo, habs jetzt mal so gemacht:

Java:
public int compareTo(BeerBottle bier){

      if(this.menge==bier.menge){

         return 0;

      }
      if(this.menge>bier.menge){

         return 1;

      }
      else{

         return -1;

      }
      

   }

ich muss aber noch zusätzlich wenn erforderlich eine alphabetische sortierung durchführen, dafür muss ich doch dann den String in substrings zerlegen oder nicht?
 

Xeno1987

Mitglied
halli hallo bin wieder da, so habs endlich hinbekommen freu:)

Hoffe das ist auch nach der augabenstellung das was sie wollten:

erstmal die beerbottle:

Java:
public class BeerBottle implements Comparable<BeerBottle>{

   private String bezeichnung;
   private String brauerei;
   private double vol;
   private double menge;
   
   public BeerBottle(String bezeichnung, String brauerei, double vol, double menge){

      this.bezeichnung=bezeichnung;
      this.brauerei=brauerei;
      this.vol=vol;
      this.menge=menge;
   }
   
   public int compareTo(BeerBottle bier){

      int result = 0;

         if(this.menge == bier.menge){


            if((result=bezeichnung.compareTo(bier.bezeichnung))!=0){

               return  result > 0 ? 1 : -1;

            }
            else{

               return result;

            }

         }
         else{

            if(this.menge == bier.menge){

               return 0;

            }
            else if(this.menge > bier.menge){

               return 1;

            }
            
            else{

               return -1;

            }

         }
   }
   

   
   public String toString(){

      return "Das Bier " + this.bezeichnung + " von der Brauerei" + this.brauerei + " " + this.menge + "l, enthaelt " + this.vol + " % Alkohol!";
   }



}

und die main:

Java:
public class Main{

   public static void main(String[] args){

      MyLinkedList kasten = new MyLinkedList();
      
      BeerBottle bi1 = new BeerBottle("Beck's", "Bremen", 4.7, 0.5);
      BeerBottle bi2 = new BeerBottle("Bock", "Erlangen", 4.9, 0.5);
      BeerBottle bi3 = new BeerBottle("Holsten", "Hamburg", 4.1, 0.5);
      
      bi1.compareTo(bi2);
      bi1.compareTo(bi3);
      bi2.compareTo(bi3);
      
      kasten.insert(bi1);
      kasten.insert(bi2);
      kasten.insert(bi3);
      


      System.out.println(kasten.showList());
   }

}
 
W

Wishmaster51

Gast
Ich würde das eher so schreiben:
Java:
public int compareTo(BeerBottle bier)
{
 
            if(this.menge == bier.menge)
            {
                        return this.bezeichnung.compareTo(bier.bezeichnung);
            }
            else if(this.menge > bier.menge)
            {
                        return 1;
            }
            else
            {
                        return -1;
            }
}
Das wäre dann kürzer und kompakter, prinzipiell ist deines aber richtig.

Stellt sich nur die theoretische Frage, ob man hier
Code:
bezeichnung.compareTo
oder doch
Code:
bezeichnung.compareToIgnoreCase
verwenden sollte
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
H Generics machen mich verrückt Java Basics - Anfänger-Themen 8
John_Sace Homogene Realisierung von Generics in Java ? Java Basics - Anfänger-Themen 19
MarvinsDepression Datentypen Generics: Erste Berührungen Java Basics - Anfänger-Themen 6
M Generics Vererbung Listen Java Basics - Anfänger-Themen 2
Cassy3 Generics - CompareTo Java Basics - Anfänger-Themen 21
T Collections Sind Subklassen-Objekte in Listen mit Generics erlaubt? Java Basics - Anfänger-Themen 16
districon Generics implementieren Java Basics - Anfänger-Themen 2
CptK Überprüfen ob übergebenes Objekt zu Generics passt Java Basics - Anfänger-Themen 2
CptK Generics: Klassen die Interface implementieren, aber selbst nicht das Interface sind Java Basics - Anfänger-Themen 8
B Hilfe bei Generics Java Basics - Anfänger-Themen 11
G Generics Compilerfehler Java Basics - Anfänger-Themen 6
G Generics Methoden Java Basics - Anfänger-Themen 7
G Generics Java Basics - Anfänger-Themen 3
L Generics Tripel Java Basics - Anfänger-Themen 26
W Fragen zu Generics Java Basics - Anfänger-Themen 14
S Hilfe. Generics und BiFunctions Java Basics - Anfänger-Themen 10
X Wie Generics richtig benutzen ? Java Basics - Anfänger-Themen 5
S Allgemeine Frage über Generics und Vererbungen Java Basics - Anfänger-Themen 5
S Generics-Problem: Class, Class<?>, Class<Object> Java Basics - Anfänger-Themen 4
I Java Generics factory method Java Basics - Anfänger-Themen 2
M Verständnisfrage zu Generics Java Basics - Anfänger-Themen 7
I Generics und Comparable Java Basics - Anfänger-Themen 14
G Generics mit ? und Diamantoperator Java Basics - Anfänger-Themen 4
G Generics: Wildcard ? Java Basics - Anfänger-Themen 12
D Generics methode Java Basics - Anfänger-Themen 2
I Frage zu Generics und Wildcards Java Basics - Anfänger-Themen 2
N Generics und Casting eines Objekts Java Basics - Anfänger-Themen 1
A Generics Java Basics - Anfänger-Themen 6
A Vererbung/Interfaces/Generics Java Basics - Anfänger-Themen 12
W Generics - Typ zurückbekommen Java Basics - Anfänger-Themen 4
Dimax Erste Schritte Generics von Profis leicht erklärt Java Basics - Anfänger-Themen 7
C Warum funktioniert 'instanceof' bei generics nicht? Java Basics - Anfänger-Themen 4
J Collections Generics: Typ wird nicht erkannt Java Basics - Anfänger-Themen 7
D Generics ArrayList: Bug im Quellcode Java Basics - Anfänger-Themen 14
C Generics Java Basics - Anfänger-Themen 8
M Generics getter und setter Methoden Java Basics - Anfänger-Themen 4
T Generics in Java... Java Basics - Anfänger-Themen 9
J Generics Java Basics - Anfänger-Themen 3
J Generics Datentypen vergleichen Java Basics - Anfänger-Themen 16
V Generics / eigene Liste Java Basics - Anfänger-Themen 4
O Generics - Implementierung Java Basics - Anfänger-Themen 7
Shizmo Frage zu Generics Java Basics - Anfänger-Themen 3
F Multiple Generics Java Basics - Anfänger-Themen 10
G Datentypen verschiedene Objekte in eine ArrayList, Generics Java Basics - Anfänger-Themen 2
H Typsicherheit/Generics Java Basics - Anfänger-Themen 1
U Java generics funktioniert nicht Java Basics - Anfänger-Themen 0
Tarrew Generics: Erste gemeinse Oberklasse als Rückgabewert Java Basics - Anfänger-Themen 1
N Generics Vererbung Wildcard Interface Java Basics - Anfänger-Themen 8
S Generics und Comparable Interface Java Basics - Anfänger-Themen 5
A Generics Java Basics - Anfänger-Themen 4
M Frage zu Generics in Klassen, Abstrakten Klassen und Interfaces Java Basics - Anfänger-Themen 5
R Compiler-Fehler Generics Problem Java Basics - Anfänger-Themen 2
K Interface Generics, Interfaces und Listen - ich bin verwirrt. Java Basics - Anfänger-Themen 7
K Generics bei Klassen- und Interfacedeklarationen Java Basics - Anfänger-Themen 3
D toArray und Generics Java Basics - Anfänger-Themen 2
D Zwei Generics beim Überladen von Methoden Java Basics - Anfänger-Themen 3
C Erste Schritte Filter für Generics oder ähnliches Java Basics - Anfänger-Themen 2
M Frage zu Generics-Deklaration Java Basics - Anfänger-Themen 5
S Frage zu Collection-Generics in Subklassen Java Basics - Anfänger-Themen 6
J Java Generics - Frage zu Types Java Basics - Anfänger-Themen 2
M <T> Generics Java Basics - Anfänger-Themen 7
B Interface Generics: prüfen ob Interface deklariert wird Java Basics - Anfänger-Themen 18
T Polymorphie Generics-Problem Java Basics - Anfänger-Themen 2
B Hilfe beim Verständnis zu Generics Java Basics - Anfänger-Themen 7
J Array Generics Java Basics - Anfänger-Themen 3
J Generics casten Java Basics - Anfänger-Themen 14
J Generics wildcard Java Basics - Anfänger-Themen 6
E Listen und Generics Java Basics - Anfänger-Themen 9
M Datei einlesen mit generics? Java Basics - Anfänger-Themen 9
D Warum sind Generics mit Vorsicht zu genießen? Java Basics - Anfänger-Themen 6
M OOP Mit Generics auf Methoden zugreifen? Java Basics - Anfänger-Themen 10
S Generics Java Basics - Anfänger-Themen 4
G Generics kein Zugriff auf getter eines Objekts Java Basics - Anfänger-Themen 4
L Datentypen Problem mit Generics und null Java Basics - Anfänger-Themen 6
E Klassen java.util.ArrayList<E> als Generics Java Basics - Anfänger-Themen 16
W Interface Problem mit Generics Java Basics - Anfänger-Themen 2
M OOP Generics und Wildcards Java Basics - Anfänger-Themen 3
D Generics - Warnmeldungen Java Basics - Anfänger-Themen 2
M Polymorphie generics einsteigerprobleme Java Basics - Anfänger-Themen 3
D Vererbung Generics und Vererbung Java Basics - Anfänger-Themen 8
C Generics Array Java Basics - Anfänger-Themen 43
D Fehler mit generics Java Basics - Anfänger-Themen 10
S Generics - CaseInsensitiveMap selber schreiben? Java Basics - Anfänger-Themen 5
K Datentypen Generics Java Basics - Anfänger-Themen 3
P Comparable und Generics Java Basics - Anfänger-Themen 6
I Generics (Subtypen) Java Basics - Anfänger-Themen 17
N Typeinschränkung bei Generics Java Basics - Anfänger-Themen 13
C Generics und Cast Java Basics - Anfänger-Themen 5
H Generics werden in -source 1.2 nicht unterstützt Java Basics - Anfänger-Themen 16
M Datentypen Generics: Exacten Typ ermitteln Java Basics - Anfänger-Themen 6
N Generics und Interfaces Java Basics - Anfänger-Themen 5
S Generics und "generische Feldzuweisungen" Java Basics - Anfänger-Themen 5
lumo Java Generics Java Basics - Anfänger-Themen 19
M verlinkte Liste mit generics Java Basics - Anfänger-Themen 7
capgeti Datentypen Static methoden aus Superklasse mit Generics definieren? Java Basics - Anfänger-Themen 9
S Generics und Typerkennung Java Basics - Anfänger-Themen 7
A Cast ohne Warnung bei Generics Java Basics - Anfänger-Themen 2
B Java Listen und Generics Java Basics - Anfänger-Themen 35
O Abstract Method & Generics Java Basics - Anfänger-Themen 10
K Aufgabe Generics Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Neue Themen


Oben