Vererbung Wurden die Aufgaben richtig programmiert?

[JavaUndC-Prog]

Hallo zusammen,

ich habe ein paar kleine alte Aufgaben gefunden und wollte mich gerne mal von euch korrigieren lassen. Es sind zwei kleine Aufgaben A und B, deren Aufgabenstellung man dem angefügtem Bild entnehmen kann. Mich würde interessieren, ob ich das so richtig gemacht habe, oder und ob man etwas besser machen könnte.

Danke für kommende Antworten!

Code zu A:

public abstract class Tier {
    public String geräusch;
    public abstract void geräuschMachen();
}


public class Hund extends Tier{
    public Hund(){
        geräusch = "WAU!";
    }
   
    public void geräuschMachen(){
        System.out.println(geräusch);
    }
}


public class Katze extends Tier{
   
    public Katze(){
        geräusch = "MIAU!";
    }
   
    public void geräuschMachen(){
        System.out.println(geräusch);
    }
}

Code zu B:

import java.util.*;

public class Tierlaute {
    private static int zählerHund = 0;
    private static int zählerKatze = 0;
   
    public static void main(String[] args){

        ArrayList<String> tiere = new ArrayList<String>();
       
        for(int i = 0; i < args.length; i++){
            if(args[i].equals("Hund")){
                zählerHund++;
                tiere.add("Hund");
            }
            if(args[i].equals("Katze")){
                zählerKatze++;
                tiere.add("Katze");
            }
        }
        System.out.println("Anzahl Hund(e): " + zählerHund + "\nAnzahl Katze(n): " + zählerKatze);
        System.out.println(tiere);
    }
}

 

[Tarrew]

Zu A:
Die Variable "geräusch" soll private sein. Damit ist die Variable in den Klassen Hund und Katze nicht mehr sichtbar und du musst sie anders setzen.
Die Klasse Tier sollte einen Konstruktor besitzen in dem du Variable "geräusch" setzt. In den Klassen Hund und Katze dann den Konstruktor der Oberklasse mit super() aufrufen und den jeweiligen String übergeben.
Deine geräuschMachen Methode musst du dementsprechend auch anpassen.

Zu B:
Du sollst Objekte vom Typ Hund und Katze zu der Liste hinzufügen. Deine ArrayList ist aber vom Typ String.

 

[JavaUndC-Prog]

Danke für deine Antwort, ja klar private genau... 🙂
Was meinst du mit anpassen der Methode in Aufgabe A?

Zu B habe ich dann auch noch eine Frage, "Du sollst Objekte vom Typ Hund und Katze zu der Liste hinzufügen. Deine ArrayList ist aber vom Typ String." Bedeutet also: tiere.add(new Hund()) ? habe ich das richtig verstanden?

 

[Tarrew]

Zu A:
In den Klassen Hund und Katze hast du keinen Zugriff auf die Variable "geräusch". Deswegen kannst du nicht einfach schreiben:

System.out.println(geräusch);

Zu B:
Ja genau. Dafür musst du den Typ der ArrayList natürlich auch ändern.

 

[JavaUndC-Prog]

Dann habe ich B fast fertig. Kann ich denn:

ArrayList<Object> tiere = new ArrayList<Object>();
tiere.add(new Hund());

einfach so schreiben?

 

[Tarrew]

Das würde gehen, würde aber den Sachverhalt nicht wirklich wiederspiegeln.

Wenn du jetzt ein Tier aus der Liste herausnehmen willst, musst du jedes Mal auf die Klasse "Tier" casten. Und casten will man eigentlich ungern. Deswegen solltest du für den Typ der ArrayList lieber die 'kleinste' gemeinsame Abstraktion nehmen.

 

[JavaUndC-Prog]

Danke für deine Rückmeldung, wie würde diese Implementierung denn aussehen, etwa:

1. List list = new ArrayList();
2. list.add(new Hund());

 

[Tarrew]

Das wäre prinzipiell das gleiche. Du kannst ja mal Folgendes probieren:

List list = new ArrayList();
list.add(new Hund());
Tier t = list.get(0);

Und gucken was der Compiler dir sagt. Einfach die Liste vom Typ Tier machen 😉
So würde ich es zmdst. machen.

 

[MWin123]

Du solltest schon Generics verwenden.
Sonst kannst du die Liste mit beliebigen Objekten füllen.

List<Tier> tiere = new ArrayList<>();
So passen nur Tiere (d.h. Katzen und Hunde) rein.

 

[JavaUndC-Prog]

Das scheint zu funktionieren, er gibt nur an, das etwas parametrisiert werden soll...?

Dann würde mich natürlich noch Aufgabe A weiter interessieren:
ich habe wieder etwas verändert, ist dies nun richtig oder was muss noch geändert werden?
Bei der Klasse Hund bin ich mir überhaupt nicht sicher...

public abstract class Tier
{
    private String geräusch;
  
    public Tier(String geräusch){
        this.geräusch = geräusch;
    }
    public void geräuschMachen(){
        System.out.println(geräusch);
    }
}


public class Hund extends Tier{
    private String laut1 = "WAU!";
  
    public Hund(String geräusch){
        super(geräusch);
        geräusch = laut1;
        //super.geräuschMachen();
    }
  
     public void geräuschMachen(){
         super.geräuschMachen();
     }
}

Ob ich WAU! oder MIAU! als String vorher deklariere ist eigentlich sinnlos, da es nicht verwendet wird?

Für weitere Hilfen bin ich sehr Dankbar!

 

[JavaUndC-Prog]

Ich habe jetzt mal alle "Überflüssigen" Schritte wegfallen lassen:

public abstract class Tier
{
    private String geräusch;
   
    public Tier(String geräusch){
        this.geräusch = geräusch;
    }
    public void geräuschMachen(){
        System.out.println(geräusch);
    }
}


public class Hund extends Tier{
   
    public Hund(String geräusch){
        super(geräusch);
    }
   
     public void geräuschMachen(){
         super.geräuschMachen();
     }
}


public class TierTester {
    public static void main(String[] args){
        Hund dog = new Hund("Wau!");
        Katze cat = new Katze("Miau!");
        dog.geräuschMachen();
        cat.geräuschMachen();
    }
}

Ausgabe: Wau! Miau!
Es scheint also jetzt richtig zu sein, kann das bestätigt werden oder ist noch irgendwo ein Fehler zu finden. Auch habe ich mir nochmal die Aufgabenstellung angesehen, es scheint mir, als hätte ich es nun?

Falls dem so ist danke an euch, dass ihr mir geholfen habt. Wenn jedoch noch Fehler vorhanden sind würde ich mich freuen, wenn mir dies jemand mitteilen könnte. Danke!

Und nochmal als Nachfrage, die Methode in Tier muss doch nicht abstrakt sein oder?

 

[Tarrew]

#Zu spät.

Ein Hund macht ja in deinem Beispiel immer Wau und eine Katze immer Miau. Hättest du also nicht zwingend als Parameter übergeben müssen.

 

[JavaUndC-Prog]

Aber sonst passt es oder? 😉

Danke nochmal, eigentlich recht einfach, wenn man den Text erst hat...

 

[Flown]

Also man kann deine Variante noch etwas verfeinern, indem man den richtigen Konstruktor erstellt.
Nachdem die Geräusche immer gleich sind, solltest du für den Hund nicht immer "Wau!" übergeben müssen, ergo:

public class Hund extends Tier{
    public Hund(){
        super("Wau!");
    }
}

Du kannst dir das schreiben der Methode in der Kindsklasse sparen, da ja das Verhalten nicht geändert wird.

 

[JavaUndC-Prog]

Hallo nochmal, ich wollte hierfür nicht noch ein neues Thema erstellen. Ich habe noch weitere Aufgaben gefunden und würde mich wieder sehr freuen, wenn ihr mich wieder korrigieren könntet, dabei konnte ich bis jetzt sehr viel lernen, durch die guten Erfahrungswerte von euch!

Falls jemand Lust hat mir mitzuteilen, wie meine Lösungen sind oder ob das überhaupt richtig ist, bzw ob es auch besser geht, würde ich mich sehr über Antworten von euch Freuen!

Aufgabe 1:

import java.util.*;

public class Potenz {
    public static void main(String[] args){
       
        ArrayList<Integer> liste = new ArrayList<Integer>();
       
        // String ohne [] dann würde auch args ohne [0] funktionieren...
        int n = Integer.parseInt(args[0]);
        while(n > 0){
            liste.add(n*n);
            n--;
        }
       
        Collections.reverse(liste); // Das stört mich, ich würde gerne ohne diesen Ausdruck //auskommen wollen
       
        for(Integer k : liste){
            System.out.println(liste);
        }
       [B][U] // Geht dies auch anders? [/U][/B]
    }
}

Aufgabe 2:

public class EnumAufrufart {

      public enum Aufrufart {
            KEIN_PARAMETER, EIN_PARAMETER, ZWEI_PARAMETER, VIELE_PARAMETER
    }
     
      public static Aufrufart gibAufrufart(String[] args) {
            if(args.length == 0){
                Aufrufart keinparam = Aufrufart.KEIN_PARAMETER;
                return keinparam;
            }
            if(args.length == 1){
                Aufrufart einparam = Aufrufart.EIN_PARAMETER;
                return einparam;
            }
            if(args.length == 2){
                Aufrufart zweiparam = Aufrufart.ZWEI_PARAMETER;
                return zweiparam;
            }
            if(args.length > 2){
                Aufrufart vieleparam = Aufrufart.VIELE_PARAMETER;
                return vieleparam;
            }
            return null;
          }
     
      public static void main(String[] args) {
           
            System.out.println(gibAufrufart(args));
            System.out.println();
          }
}

Meine Lösung zu 1 stört mich etwas, ich meine es funktioniert zwar, aber kann ich die Liste nicht auch rückwärts mit einer For Each durchlaufen, ich meine bei der for Schleife würde man dann einfach i-- einbauen, daher geht das nicht auch mit einer For Each Schleife?

Aufgabe 2 scheint auch zu funktionieren, aber ist das überhaupt so richtig? Oder soll die Methode im Konstruktor eingebaut werden?


Danke für kommende Antworten!
Ich freue mich!

 

[Flown]

Warum nicht?

for(int i = 0; i <= n; i++) {
  list.add(i*i);
}

 

[JavaUndC-Prog]

Richtig, wäre auch gegangen, ich wollte einfach mal die While benutzen 😉

War der Rest soweit in Ordnung?

 

[Flown]

Die zweite Aufgabe ist noch nicht richtig. Du musst die Methode im Enum definieren.

 

[JavaUndC-Prog]

Also so?

public class EnumAufrufart {

      public enum Aufrufart {
            KEIN_PARAMETER, EIN_PARAMETER, ZWEI_PARAMETER, VIELE_PARAMETER;
           
            Aufrufart gibAufrufart(String[] args) {
                if(args.length == 0){
                    Aufrufart keinparam = Aufrufart.KEIN_PARAMETER;
                    return keinparam;
                }
                if(args.length == 1){
                    Aufrufart einparam = Aufrufart.EIN_PARAMETER;
                    return einparam;
                }
                if(args.length == 2){
                    Aufrufart zweiparam = Aufrufart.ZWEI_PARAMETER;
                    return zweiparam;
                }
                if(args.length > 2){
                    Aufrufart vieleparam = Aufrufart.VIELE_PARAMETER;
                    return vieleparam;
                }
                return null;
              }
    }
     
     
      public static void main(String[] args) {
           
            //System.out.println(gibAufrufart(args));
            System.out.println();
          }
}

Wie kann ich die Methode denn mit System.out.println() aufrufen? //System.out.println(gibAufrufart(args)); geht ja nun nicht mehr.

 

[JavaUndC-Prog]

Ein kurzes static vor der Methode hat dann doch noch funktioniert. Naja das hat jetzt bei mir gedauert... 😀 Wobei das fast schon trivial ist.

Sind somit alle Fehler ausgebügelt oder gibt es noch Fehler?

 

[Flown]

Ja so in etwa. Man kann einiges noch etwas anders schreiben, aber sonst ok.