Vererbung Ueben mit kleiner Datenstruktur von Räumen

[ocsme]

Guten Tag,

hab mal wieder eine Frage 😛
Ich habe ein paar Klassen geschrieben (Räume). Es sind folgende Räume:
Raum, Seminarraum, Hörsaal, Professorbüro, Büro und Rechnerraum.

Nun möchte ich eine Main schreiben in der ich per Zufall Räume erstelle und dann diese Räume mit Sitzplätzen initialisiere. Doch es dürfen nur Seminarraum, Hörsaal, Professorbüro Sitzplätze bekommen. Das ganze klappt auch soweit doch muss ich das ganze wirklich so umständlich machen?
In der Klasse Raum von denen ich die andere Räume ableite habe ich nur ein int wert drin

public class Raum {
    int nummer;
//    public abstract void setSitze(int sitze);
//    public abstract int getSitze();
   
}

In den anderen Klassen stehen nur getter und setter drin 🙂

so sieht meine Main Klasse aus:

public class MainRaueme {
   
    public static Raum[] befuehllenZufall(Raum[] raum) {
        for(int i=0;i<raum.length;i++) {
            int k=(int)(Math.random()*5+1);
            if(k==1)
                raum[i]=new Seminarraum();
            else if(k==2)
                raum[i]=new Hoersaal();
            else if(k==3)
                raum[i]=new Buero();
            else if(k==4)
                raum[i]=new Rechnerraum();
            else if(k==5)
                raum[i]=new Professorbuero();
        }
       
        return raum;
    }
   
    public static void main(String[] args) {
       
        Raum[] raum = new Raum[10];
        befuehllenZufall(raum);
       
        for(int i=0;i<raum.length;i++) {
            System.out.println(raum[i].toString());
            if(raum[i] instanceof Seminarraum) {
                int k=(int)(Math.random()*50+1);
                ((Seminarraum) raum[i]).setSitze(k);
            }
            else if(raum[i] instanceof Hoersaal) {
                int k=(int)(Math.random()*50+1);
                ((Hoersaal) raum[i]).setSitze(k);
            }
            else if(raum[i] instanceof Professorbuero) {
                int k=(int)(Math.random()*50+1);
                ((Professorbuero) raum[i]).setSitze(k);
            }
        }
       
        int anzahl=0;
        for(int i=0;i<raum.length;i++) {
            if(raum[i] instanceof Seminarraum) {
                Seminarraum tmp = (Seminarraum) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
            else if(raum[i] instanceof Hoersaal) {
                Hoersaal tmp = (Hoersaal) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
            else if(raum[i] instanceof Professorbuero) {
                Professorbuero tmp = (Professorbuero) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
        }
        System.out.println(anzahl);
       
       
    }

}

Die Klasse ist noch nicht aufgeräumt die zwei schleifen kommen noch in jeweils 1 Methode 🙂

Meine Frage ist eigentlich nur ob die "if-kaskeden" in meinen Schleifen nicht schöner/besser gehen oder muss man das so umständlich machen?
Ich hatte erst angefangen in der Klasse Raum jede Methode rein zu packen und die Klasse dann einfach abstract gemacht doch das wird eine Fette Basisklasse oder eben eine Unvollständige Klasse.
Ich würde sie gerne so lassen 😉 also Standard Klasse 🙂

LG

 

[L0oNY]

Die Vererbung macht an dieser Stelle keinen Sinn, denn alle deine Unterklassen haben die gleichen Eigenschaften (Anzahl der Sitze). Warum dann vererben und in allen Klassen die Methoden zu wiederholen, wenn man sie einmal in der Oberklasse definieren kann?

Was ist für dich der Sinn einer Vererbung?

 

[mrBrown]

Ich hatte erst angefangen in der Klasse Raum jede Methode rein zu packen und die Klasse dann einfach abstract gemacht doch das wird eine Fette Basisklasse oder eben eine Unvollständige Klasse.
Ich würde sie gerne so lassen 😉 also Standard Klasse 🙂

Und was spricht gegen eine fette Basisklasse?

Aktuell hast du eine Klasse ohne Methoden, etwas, was man generell vermeidet.
Und zusätzlich hast du Klassen, die zwar Methoden haben (und zwar alle genau identische), aber keine eigenen Felder - auch etwas, was man vermeidet.


Dein Weg, alles in die eine Klasse zu packen, ist schon richtig - nur der Schluss daraus nicht.
Anstatt dann Code in Unterklassen zu kopieren, kann man diese einfach löschen, sie haben offensichtlich keinen Grund, als Klasse zu existieren.

 

[ocsme]

Und was spricht gegen eine fette Basisklasse?

unser Prof meinte das sollte man vermeiden.
Soll ich mal alle Klassen Posten. Da sind auch noch 3 Interfaces dabei 😀
Also haben die Klassen schon Methoden die aus den Interfaces 🙂

Ich denke aber ihr habt recht ich packe das abrufen der sitze und der gleichen in die Räume Klasse doch wie frage ich dann später ab ob ein Raum überhaupt Sitzplätze hat denn ich will die Summe aller Sitzplätze später erhalten 🙂

Das Klappt bei mir ja auch 🙂 nur eben denke ich mal wieder nicht schön 😀

LG

 

[mrBrown]

unser Prof meinte das sollte man vermeiden.

Gab's auch ne Begründung dafür?

Also ja, fette Klassen an sich sind immer doof - aber die Methoden dann einfach in jede Unterklasse kopieren ist das absolute Gegenteil von sinnvoll 😉

Ich denke aber ihr habt recht ich packe das abrufen der sitze und der gleichen in die Räume Klasse doch wie frage ich dann später ab ob ein Raum überhaupt Sitzplätze hat denn ich will die Summe aller Sitzplätze später erhalten 🙂

Naja, entweder er hat 0 oder eben N Sitzplätze...

 

[ocsme]

so bevor wir aneinander vorbei reden hier mal die aufgabenstellung:

Entwerfen Sie eine objektorientierte Datenstruktur zur Verwaltung von Räumen. Bei
einer zuvor durchgeführten Analyse wurden bereits folgende Eigenschaften für die
verschiedenen Räume ermittelt:
 Jeder Raum wird durch seine Nummer gekennzeichnet.
 Ein Seminarraum ist ein Raum, der sich durch die Fläche seiner Tafel
auszeichnet. Außerdem ist für einen Seminarraum relevant, ob dort ein
Beamer vorhanden ist.
 Ein Hörsaal ist ein Raum, für den neben der Fläche der Tafel auch die Anzahl
der Sitzreihen wichtig ist.
 Neben den Räumen mit Tafel gibt es auch Räume, die als Büros genutzt
werden. Für diese Räume ist ein wichtiges Attribut, auf welcher Etage sie sich
befinden.
 Ein Professorenbüro ist ein Büro, für das der Name des Professors wichtig ist.
 Ein Rechnerraum ist ein Büro, das mit einer bestimmten
Datenübertragungsrate an das Netzwerk der Fachhochschule angeschlossen
ist.
 Alle Räume mit Tafeln sind entweder Seminarräume oder Hörsäle. Es kann
aber Büros geben, die weder Professorenbüros noch Rechnerräume sind.
 Man kann sowohl Professorenbüros als auch Räume mit Tafeln als
Prüfungsräume nutzen. Es ist nicht immer leicht zu erkennen, wie viele Plätze
man bei einer Prüfung in dem jeweiligen Raum verwenden kann. Daher stellen
diese Räume eine Methode zur Verfügung, mit der man die Anzahl der Plätze
berechnen kann, die in einer Prüfung verwendet werden können.

 

[mrBrown]

so bevor wir aneinander vorbei reden hier mal die aufgabenstellung:

Na gut, wenn es durch die Aufgabenstellung vorgegeben ist, muss man natürlich Vererbung nutzen, die Räume haben dort ja auch alle wirklich unterschiedliche Methoden und Attribute.

 

[ocsme]

Hast recht doch ich Poste mal grade die Klassen ich fahre gleich nach Hause vielleicht kann in der Zeit jemand drüber schauen und ich hab später eine Antwort von euch 🙂
Wie gesagt es klappt ja so 😀 hihi =) bin ich ja schon mal froh es überhaupt hinbekommen zu haben 😛

public class Seminarraum extends Raum implements Beamer, Sitze, Tafel{
    private boolean beamer;
    private double flaeche;
    private int sitze;
   
   
    public boolean hasBeamer() {
        return beamer;
    }

    public double getFlaeche() {
        return flaeche;
    }
   
    public int getSitze() {
        return sitze;
    }
   
    public void setBeamer(boolean beamer) {
        this.beamer=beamer;
    }
   
    public void setFlaeche(double flaeche) {
        this.flaeche=flaeche;
    }
   
    public void setSitze(int sitze) {
        this.sitze=sitze;
    }
   
    public String toString() {
        return "Seminarraum";
    }
   

}

public class Hoersaal extends Raum implements Sitze, Tafel {
    private int sitze;
    private double flaeche;
   
    public double getFlaeche() {
        return flaeche;
    }

    public int getSitze() {
        return sitze;
    }
   
    public void setSitze(int sitze) {
        this.sitze=sitze;
    }
   
    public void setFlaeche(double flaeche) {
        this.flaeche=flaeche;
    }
   
    public String toString() {
        return "Hoersaal";
    }

}

public class Professorbuero extends Buero implements Sitze {
   
    private String name;
    private int sitze;
   
    public String getName() {
        return name;
    }
   
    public int getSitze() {
        return sitze;
    }
   
    public void setName(String name) {
        this.name=name;
    }
   
    public void setSitze(int sitze) {
        this.sitze=sitze;
    }
   
    public String toString() {
        return "Professorbuero";
    }

}

public  class Raum {
    int nummer;
//    public abstract void setSitze(int sitze);
//    public abstract int getSitze();
   
}

public interface Sitze {
    public int getSitze();

}

public interface Tafel {
    public double getFlaeche();
}

public interface Beamer {
    public boolean hasBeamer();
   

}

public class Rechnerraum extends Buero {
    private int datenRate;
   
    public int getDatenRate() {
        return datenRate;
    }
   
    public void setDatenRate(int datenRate) {
        this.datenRate=datenRate;
    }
   
    public String toString() {
        return "Rechnerraum";
    }
   

}

public class Buero extends Raum {
    private int stockwerk;
   
    public int getStockwerk() {
        return stockwerk;
    }
   
    public void setStockwerk(int stockwerk) {
        this.stockwerk=stockwerk;
    }
   
    public String toString() {
        return "Buero";
    }
}

 

[ocsme]

Das mit den Settern und Gettern habe ich auch nur so gemacht um eben auf die INSGESAMTE ANZAHL DER SITZPLÄTZE zu kommen 🙂
Hier nochmal die Main 😀

public class MainRaueme {
   
    public static Raum[] befuehllenZufall(Raum[] raum) {
        for(int i=0;i<raum.length;i++) {
            int k=(int)(Math.random()*5+1);
            if(k==1)
                raum[i]=new Seminarraum();
            else if(k==2)
                raum[i]=new Hoersaal();
            else if(k==3)
                raum[i]=new Buero();
            else if(k==4)
                raum[i]=new Rechnerraum();
            else if(k==5)
                raum[i]=new Professorbuero();
        }
       
        return raum;
    }
   
    public static void main(String[] args) {
       
        Raum[] raum = new Raum[10];
        befuehllenZufall(raum);
       
        for(int i=0;i<raum.length;i++) {
            System.out.println(raum[i].toString());
            if(raum[i] instanceof Seminarraum) {
                int k=(int)(Math.random()*50+1);
                ((Seminarraum) raum[i]).setSitze(k);
            }
            else if(raum[i] instanceof Hoersaal) {
                int k=(int)(Math.random()*50+1);
                ((Hoersaal) raum[i]).setSitze(k);
            }
            else if(raum[i] instanceof Professorbuero) {
                int k=(int)(Math.random()*50+1);
                ((Professorbuero) raum[i]).setSitze(k);
            }
        }
       
        int anzahl=0;
        for(int i=0;i<raum.length;i++) {
            if(raum[i] instanceof Seminarraum) {
                Seminarraum tmp = (Seminarraum) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
            else if(raum[i] instanceof Hoersaal) {
                Hoersaal tmp = (Hoersaal) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
            else if(raum[i] instanceof Professorbuero) {
                Professorbuero tmp = (Professorbuero) raum[i];
                System.out.println(tmp.toString()+" "+tmp.getSitze());
                anzahl+=tmp.getSitze();
            }
        }
        System.out.println(anzahl);
       
       
    }

}

 

[ocsme]

werde alles mal in die Raum Klasse Packen 🙂
dann schau ich mal wie die Main dann aussieht 🙂
Danke nochmals 🙂
Poste später alles hab noch zu tun! 😀

LG

 

[ocsme]

Entschuldigung ich glaube ich war vorhin "betrunken"! 🙁
So geht es ja viel leichter 😀
Nochmals Danke für die Klasse Idee 🙂
Hier jetzt die 2 Klassen:
Raum:

public  class Raum {
    protected int nummer;
    protected int sitze;
   
//    public abstract void setSitze(int sitze);
//    public abstract int getSitze();
   
    public int getSitze() {
        return sitze;
    }
   
    public void setSitze(int sitze) {
        this.sitze=sitze;
    }
   
}

Und die Main:

public class MainRaueme {
   
    public static Raum[] befuehllenZufall(Raum[] raum) {
        for(int i=0;i<raum.length;i++) {
            int k=(int)(Math.random()*5+1);
            if(k==1)
                raum[i]=new Seminarraum();
            else if(k==2)
                raum[i]=new Hoersaal();
            else if(k==3)
                raum[i]=new Buero();
            else if(k==4)
                raum[i]=new Rechnerraum();
            else if(k==5)
                raum[i]=new Professorbuero();
        }
       
        return raum;
    }
   
    public static void sitzeFuellen(Raum[] raum) {
        for(int i=0;i<raum.length;i++) {
            if(raum[i] instanceof Seminarraum || raum[i] instanceof Hoersaal || raum[i] instanceof Professorbuero) {
                int k=(int)(Math.random()*50+1);
                raum[i].setSitze(k);
            }
        }
    }
   
    public static int anzahlSitze(Raum[] raum) {
        int anzahl=0;
        for(int i=0;i<raum.length;i++) {
            if(raum[i] instanceof Seminarraum || raum[i] instanceof Hoersaal || raum[i] instanceof Professorbuero)
                anzahl+=raum[i].getSitze();
           
        }
        return anzahl;
    }
   
    public static void main(String[] args) {
       
        Raum[] raum = new Raum[10];
        befuehllenZufall(raum);
        sitzeFuellen(raum);
        System.out.println(anzahlSitze(raum));
       
       
    }

}