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));

   }

}
 
[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:
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?
 
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());
   }

}
 
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
 

Zurück
Oben