有多种选择的酒店预订。通过子类进行改进？

Question

下面的代码运行得非常好，正如我所希望的那样。我想要创建更多的子类，以便更好地概述整个代码。我能把setter和getter以及方法放到扩展类中吗？我想要创建子类，如‘单人房’，‘双人房’等，以扩大空间。它会改进我的代码吗？我的教授想看更多的课程。

顺便说一下，代码注释是用德语写的，所以如果有任何问题，我很乐意帮忙。

为了简化我的问题，这个选项宠物只适用于Penthouse。为Penthouse创建一个子类以转移到setter和getter到子类是否有意义？

import org.jetbrains.annotations.NotNull;
import java.io.IOException;
import java.util.Scanner;

public class Booking {
    private static boolean CustomerInterface = true;//Hauptprogramm boolean

    public static void main(String[] args) throws IOException {
        Scanner input = new Scanner(System.in);

        Room[] hotel = new Room[8];//Array für Zimmer

        hotel[0] = new Room(40, true, 1);//Single room
        hotel[1] = new Room(40, true, 2);//Single room
        hotel[2] = new Room(70, true, 3);//Double room
        hotel[3] = new Room(70, true, 4);//Double room
        hotel[4] = new Room(100, true, 5);//Triple room
        hotel[5] = new Room(100, true, 6);//Triple room
        hotel[6] = new Penthouse(200, true, 7, false);//Penthouse
        hotel[7] = new Penthouse(200, true, 8, false);//Penthouse

        System.out.println("Willkommen im Hotel AppDev1");//Begrüßung

        while (CustomerInterface) {//Abfrage des Boolean zum Start des Hauptprogramms
            System.out.println("Bitte wählen sie eine der folgenden Auswahlmöglichkeiten:");
            System.out.println("********************************************************");
            System.out.println("1: Buchen sie einen Raum\n2: List der verfügbaren Zimmer anzeigen" +
                    "\n3: Liste aller Zimmer anzeigen\n4: Kunde auschecken\n5: Gäste Anzeigen\n6: Program ende");
            System.out.println("********************************************************");

            String Selection = input.next();
            switch (Selection) {
                case "1":
                    Booking(hotel);//Methode zum Buchen
                    break;
                case "2":
                    ShowEmpty(hotel);//Freie Zimmer anzeigen
                    break;
                case "3":
                    ShowAll(hotel);//Alle Zimmer anzeigen
                    break;
                case "4":
                    DeleteCustomer(hotel);//Kundendaten je Zimmernummer löschen
                    break;
                case "5":
                    Gastdaten(hotel);//Gästedaten:Name, Preise, Buchungsoptionen anzeigen
                    break;
                case "6":
                    ShutDown();//Programm beenden
                    break;
                default:
                    WrongInput();//Flasche Eingabe getätigt
                    CustomerInterface = true;//Hauptprogramm neu starten
            }
        }
    }

    private static void PreisKategorie(Room []hotel, int roomNr) {//Auswahl der Zimmerkategorie von Standart bis Luxus
        System.out.println("Welche Preiskategorie möchten sie?\n1 = Standard\n2 = Premium (10% Zuschlag)\n 3 = Luxus (20% Zuschlag)");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch(userInput) {
            case "1":
                System.out.println("Sie haben Standard gewählt. ");
                hotel[roomNr].setPriceLevel(1.0);//Standartpreis
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() * hotel[roomNr].getPriceLevel());
                break;
            case "2":
                System.out.println("Sie haben Premium gewählt. ");
                hotel[roomNr].setPriceLevel(1.1);//10% Premiumzuschlag
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() * hotel[roomNr].getPriceLevel());
                break;
            case "3":
                System.out.println("Sie haben Luxus gewählt. ");
                hotel[roomNr].setPriceLevel(1.2);//20% Luxuszuschlag
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() * hotel[roomNr].getPriceLevel());
                break;
            default:
                WrongInput();//Falsche Eingabe
                PreisKategorie(hotel, roomNr);//Zurück zum Beginn der Kategorieauswahl
        }

    }

    private static void ShutDown() {//Programm beenden
        System.out.println("Danke, auf wiedersehen.");
        System.exit(0);
    }

    private static void Booking(Room[] hotel) {//Zimmer buchen
        
                String userInput;
                Scanner input = new Scanner(System.in);
                System.out.println("Bitte geben sie eine der folgenden Zimmernummern ein:\n1-2 Einzelzimmer, Preis für eine" +
                        " Übernachtung = " + " " + "\n3-4 Doppelzimmer" +
                        "\n5-6 Drreibettzimmer\n7-8 Ferienwohnug\n9 Programm beenden");
                userInput = input.next();

                switch (userInput) {
                    case "1":
                        if (hotel[0].getAvailable(hotel[0].available)) {
                            System.out.println(hotel[0].getPricePerNight());
                            int roomNr = 0;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            System.out.println(hotel[0].getPricePerNight());
                            Balcony(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "2":
                        if (hotel[1].getAvailable(hotel[1].available)) {
                            int roomNr = 1;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            Balcony(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);

                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "3":
                        if (hotel[2].getAvailable(hotel[2].available)) {
                            int roomNr = 2;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            Balcony(hotel, roomNr);
                            SinglePerson(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "4":
                        if (hotel[3].getAvailable(hotel[3].available)) {
                            int roomNr = 3;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            Balcony(hotel, roomNr);
                            SinglePerson(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "5":
                        if (hotel[4].getAvailable(hotel[4].available)) {
                            int roomNr = 4;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            SecondToilet(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "6":
                        if (hotel[5].getAvailable(hotel[5].available)) {
                            int roomNr = 5;
                            PreisKategorie(hotel, roomNr);
                            Breakfast(hotel, roomNr);
                            SecondToilet(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "7":
                        if (hotel[6].getAvailable(hotel[6].available)) {
                            int roomNr = 6;
                            PreisKategorie(hotel, roomNr);
                            CountGuests(hotel, roomNr);
                            Pet(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            RoomService(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "8":
                        if (hotel[7].getAvailable(hotel[7].available)) {
                            int roomNr = 7;
                            PreisKategorie(hotel, roomNr);
                            CountGuests(hotel, roomNr);
                            Pet(hotel, roomNr);
                            BookingPeriode(hotel, roomNr);
                            RoomService(hotel, roomNr);
                            FinalizeBooking(hotel, roomNr);
                        } else {
                            AldreadyBooked(hotel);
                        }
                        break;
                    case "9":
                        ShutDown();
                        break;
                    default:
                        WrongInput();
                        Booking(hotel);
                }

                //int roomNr;
                //roomNr = Integer.valueOf(userInput) - 1;//wandelt die eingabe in int um und -1 damit Zimmer 1 = room[0]
                //FinalizeBooking(hotel, roomNr);



    }

    private static void FinalizeBooking(Room @NotNull [] hotel, int roomNr) {
        String userInput;
        Scanner input = new Scanner(System.in);
        String rName;
        System.out.println("Bitte geben sie ihren Namen ein : ");
        rName = input.next();//Kundenname für die Buchung
        //rName = String.valueOf(roomNr);//wandelt rName in int um es der arry zuzuodrnen
        //Option 1 mit boolean
        hotel[roomNr].setAvailable(false);
        //Option 2 mit equals
        hotel[roomNr].setName(rName);//hinterlegt in der arry den Namen des Gastes
        Receipt(hotel, roomNr);

    }

    private static void Receipt(Room @NotNull [] hotel, int roomNr) {
        System.out.println("Danke für ihre Buchung, das Zimmer" + " " + (roomNr + 1) + " " +
                "ist für sie reserviert\nDie Gesamtsumme beträgt: " + (hotel[roomNr].getPricePerNight() * 1.19) + "€" +
                "\n Die enthaltende Mehrwertsteuer beträgt: " +(hotel[roomNr].getPricePerNight() * 0.19));
        if ((hotel[roomNr].getFrühstück()==true) || (hotel[roomNr].getBalkon()==true) || (hotel[roomNr].getSinglePerson()==true) || (hotel[roomNr].getGästetoilette()==true) || (hotel[roomNr].getPet()==true) || (hotel[roomNr].getRoomService()==true)) {
            System.out.println("Sie haben die folgenden optionen mit gebucht:");
            if (hotel[roomNr].getFrühstück() == true) {
                System.out.println("Frühstück: " + hotel[roomNr].getBreaky() * hotel[roomNr].getBookingPeriode() + "€");
            }

            if (hotel[roomNr].getBalkon() == true) {
                System.out.println("Balkon: " + hotel[roomNr].getBalcony() * hotel[roomNr].getBookingPeriode() + "€");
            }

            if (hotel[roomNr].getSinglePerson() == true) {
                System.out.println("Einzelpersonrabatt: " + hotel[roomNr].getEinzelPerson() * hotel[roomNr].getBookingPeriode() + "€");
            }

            if (hotel[roomNr].getGästetoilette() == true) {
                System.out.println("Gäste Toilette: " + hotel[roomNr].getSecondToilet() * hotel[roomNr].getBookingPeriode() + "€");
            }

            if (hotel[roomNr].getPet() == true) {
                System.out.println("Haustierzuschlag: " + hotel[roomNr].getHaustier() * hotel[roomNr].getBookingPeriode() + "€");
            }
            if (hotel[roomNr].getRoomService() == true) {
                System.out.println("Zimmerservie: " + hotel[roomNr].getZimmerservice() * hotel[roomNr].getBookingPeriode() + "€");
            }
        } else {
            System.out.println("Sie haben keine Zusatzoptionen gebucht");
        }
    }

    private static void RoomService(Room[] hotel, int roomNr) {
        System.out.println("Möchten sie Zimmerservice dazubuchen? \n" +" 1 = ja 2= Nein");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput){
            case "1":
                System.out.println("Sie haben inklusive Zimmerservice gebucht");
                hotel[roomNr].setRoomService(true);
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() + Room.getZimmerservice());
                break;
            case "2":
                System.out.println("Sie haben ohne Zimmerservice gebucht");
                hotel[roomNr].setRoomService(false);
                break;
            default: WrongInput();
            RoomService(hotel, roomNr);
        }
    }

    private static void AldreadyBooked(Room[] hotel) {
        System.out.println("Dieses Zimmer ist leider schon belegt\n Bitte wählen sie ein anders Zimmer.");
        //CustomerInterface = true;
        Booking(hotel);
    }

    private static void WrongInput() {
        System.out.println("********************************************************");
        System.out.println("Ihre eingabe war leider nicht Korrekt.\nBitte versuchen sie es erneut.");
        System.out.println("********************************************************");
    }

    private static void Pet(Room[] hotel, int roomNr) {
        System.out.println("Kommen Sie mit oder ohne Haustier\n1 = mit \n2 = ohne");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
                System.out.println("sie nehmen ein Haustier mit");
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() + hotel[roomNr].getHaustier());//3 € Aufpreis für ein Haustier
                hotel[roomNr].pet = true;
                break;
            case "2":
                System.out.println("sie nehmen kein Haustier mit");
                hotel[roomNr].pet = false;
                break;
            default:
                WrongInput();
                Pet(hotel, roomNr);
                break;
        }
    }

    private static void BookingPeriode(Room[] hotel, int roomNr) {
        if (roomNr < 7){
            System.out.println("Wie lange bleiben Sie? ");
            Scanner input = new Scanner(System.in);
            String userInput;
            userInput = input.next();
            switch (userInput) {
                case "1":
                case "2":
                case "3":
                case "4":
                case "5":
                case "6":
                case "7":
                case "8":
                case "9":
                case "10":
                case "11":
                case "12":
                case "13":
                case "14":
                    System.out.println("sie haben" + " " + userInput + " " + "Tage gewählt");
                    hotel[roomNr].setBookinperiode(Integer.valueOf(userInput));
                    hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() * Integer.valueOf(userInput));

                    break;
                default:
                    WrongInput();
                    BookingPeriode(hotel, roomNr);}

        } else{
            System.out.println("Wie lange bleiben Sie? (Die Mindestbuchungsdauer beträgt 3 Tage\nDie maximale Buchungsdauer beträt 14 Tage)");
            Scanner input = new Scanner(System.in);
            String userInput;
            userInput = input.next();


            switch (userInput) {
                case "1":
                case "2":
                    MinBooking(hotel, roomNr);
                    break;
                case "3":
                case "4":
                case "5":
                case "6":
                case "7":
                case "8":
                case "9":
                case "10":
                case "11":
                case "12":
                case "13":
                case "14":
                    System.out.println("sie haben" + " " + userInput + " " + "Tage gewählt");
                    hotel[roomNr].setBookinperiode(Integer.valueOf(userInput));
                    hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() * Integer.valueOf(userInput));
                    break;
                default:
                    WrongInput();
                    BookingPeriode(hotel, roomNr);
            }
        }
    }

    private static void MinBooking(Room[] hotel, int roomNr) {
        System.out.println("Sie unterschreiten die Mindestbuchungsdauer! \nMöchten Sie erneut wählen? 1 = neuwahl 2= Programm beenden");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        if (userInput.equals("1")) {
            BookingPeriode(hotel, roomNr);
        } else if (userInput.equals("2")) {
            ShutDown();
        } else {
            WrongInput();
            MinBooking(hotel, roomNr);
        }
    }

    private static void CountGuests(Room[] hotel, int roomNr) {
        System.out.println("Mit wie vielen Personen möchten sie buchen?\nDie maximale Anzahl beträt 6 Personen.)");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
            case "2":
            case "3":
            case "4":
            case "5":
            case "6":
                System.out.println("sie haben" + " " + userInput + " Personen gewählt");
                hotel[roomNr].setCountGuests(Integer.valueOf(userInput));
                break;
            default:
                WrongInput();
                CountGuests(hotel, roomNr);
        }
    }

    private static void SecondToilet(Room[] hotel, int roomNr) {
        System.out.println("Möchten sie ein Zimmer mit Gäste Toilette? 1 = ohne Gäste Toilette 2 = 2 mit Gäste Toilette");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
                System.out.println("sie haben ein Zimmer ohne Gäste Toilette gewählt");
                hotel[roomNr].gästetoilette = false;


                break;
            case "2":
                System.out.println("sie haben ein Zimmer mit Gäste Toilette gewählt");
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() + Room.getSecondToilet());//10 € Aufpreis für eine extra Toilette
                hotel[roomNr].gästetoilette = true;

                break;
            default:
                WrongInput();
                SecondToilet(hotel, roomNr);
        }
    }

    private static void SinglePerson(Room[] hotel, int roomNr) {
        System.out.println("Bitte geben sie an um wie viele Personen es sich bei ihrer Buchung handelt\n1 = Einzelperson 2= Paar");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
                System.out.println("sie haben Einzelperson gewählt");
                System.out.println("Sie bekommen einen Sondertarif (10 Euro weniger)");

                hotel[roomNr].singlePerson = true;
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() - hotel[roomNr].getEinzelPerson());
                System.out.println(hotel[roomNr].getPricePerNight());
                break;
            case "2":
                System.out.println("sie haben die Paaroption gewählt");
                hotel[roomNr].singlePerson = false;
                //System.out.println(hotel[roomNr].getPricePerNight());
                break;
            default:
                WrongInput();
                SinglePerson(hotel, roomNr);
        }
    }

    private static void Balcony(Room[] hotel, int roomNr) {
        System.out.println("Möchten sie ein Zimmer mit Balkon buchen? 1 = mit Balkon 2= ohne Balkon");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
                System.out.println("sie haben ein Zimmer mit Balkon gewählt");
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() + Room.getBalcony());//5 € Aufpreis für einen Balkon
                hotel[roomNr].balkon = true;

                break;
            case "2":
                System.out.println("sie haben ein Zimmer ohne Balkon gewählt");
                hotel[roomNr].balkon = false;
                break;
            default:
                WrongInput();
                Balcony(hotel, roomNr);
        }
    }

    private static void Breakfast(Room @NotNull [] hotel, int roomNr) {
        System.out.println("Möchten sie Frühstück dazu buchen? 1 = mit Frühstück 2= ohne Frühstück");
        Scanner input = new Scanner(System.in);
        String userInput;
        userInput = input.next();
        switch (userInput) {
            case "1":
                System.out.println("sie haben ein Zimmer mit Frühstück gewählt");
                hotel[roomNr].setPricePerNight(hotel[roomNr].getPricePerNight() + Room.getBreaky());//3 € Aufprreis für Frühstück
                hotel[roomNr].frühstück = true;
                //System.out.println(hotel[roomNr].getPricePerNight());
                break;
            case "2":
                System.out.println("sie haben ein Zimmer ohne Frühstück gewählt");
                hotel[roomNr].frühstück = false;
                break;
            default:
                WrongInput();
                Breakfast(hotel, roomNr);
                break;
        }
    }

    private static void ShowEmpty(Room @NotNull [] hotel) {
        for (int i = 0; i < hotel.length; i++) {
            if (hotel[i].getAvailable(hotel[i].available)) {
                System.out.println("Zimmer " + (i + 1) + " steht zur Verfügung");
            }else {
                System.out.println("Zimmer " + (i + 1) + " ist belegt");
            }
        }
    }

    private static void ShowAll(Room @NotNull [] hotel) {
        for (int i = 0; i < hotel.length; i++) {
            System.out.println("Wir bieten Zimmer " + (i + 1) + " an. ");
        }
    }

    private static void DeleteCustomer(Room @NotNull [] hotel) {
        Scanner input = new Scanner(System.in);
        int roomNr;
        System.out.println("Bitte geben sie die Zimmernummer ein");
        roomNr = input.nextInt() - 1;
        hotel[roomNr].setName("Name");
        hotel[roomNr].setAvailable(true);
        System.out.println("Eintrag gelöscht");
    }

    private static void Gastdaten(Room @NotNull [] hotel) {
        for (int i = 0; i < hotel.length; i++) {
            if (hotel[i].getAvailable(!(hotel[i].available))) {

                System.out.println("Es befinden sich zur Zeit Gäste in Zimmer: " + hotel[i].roomNr +
                        "\nName: " + hotel[i].getName() + "\nGesamtpreis ohne MwST: "
                        + hotel[i].getPricePerNight());
                switch (hotel[i].getRoomNr()) {
                    case 1:
                    case 2:
                        System.out.println("Frühstück: " + hotel[i].getFrühstück() + "\nBalkon: " + hotel[i].getBalkon() +
                                "\nDauer des Aufenthalts:" + hotel[i].getBookingPeriode() + "\n");
                        break;
                    case 3:
                    case 4:
                        System.out.println("Frühstück: " + hotel[i].getFrühstück() + "\nBalkon: " + hotel[i].getBalkon() + "\n"
                                + "Einzelpersonenrabatt:" + hotel[i].getSinglePerson() + "\nDauer des Aufenthalts:" + hotel[i].getBookingPeriode() + "\n");
                        break;
                    case 5:
                    case 6:
                        System.out.println("Frühstück: " + hotel[i].getFrühstück() + "\nBalkon: " + hotel[i].getBalkon() + "\n"
                                + "Gäste Toilette:" + hotel[i].getGästetoilette() + "\nDauer des Aufenthalts:" + hotel[i].getBookingPeriode() + "\n");
                        break;
                    case 7:
                    case 8:
                        System.out.println("Anzahl der Gäste: " + hotel[i].getCountGuests() + "\nHaustier: " + hotel[i].getPet() + "\n"
                                + "Zimmerservice: " + hotel[i].getRoomService() + "\nDauer des Aufenthalts:" + hotel[i].getBookingPeriode() + "\n");
                        break;
                }
            } else {
                System.out.println("Es befinden sich zur Zeit keine Gäste in Zimmer: " + " " + hotel[i].getRoomNr() + "\n");
            }
        }
    }
}

package Hotel;

public class Room {



    //String CustomerName;
    private String Name;
    int roomNr;
    double pricePerNight;
    boolean available; //= true;//Zimmer frei oder belegt?
    static double breaky = 3;
    static double balcony = 5;
    boolean frühstück;
    boolean balkon;
    boolean singlePerson;
    boolean gästetoilette;
    static double secondToilet = 10;
    int countGuests;
    boolean pet;
    int bookinperiode;
    boolean roomservice;
    static double zimmerservice = 10;
    static double einzelPerson = 10;
    double haustier = 3;
    static double priceLevel;



    //Constructor
    public Room(double pricePerNight, boolean available,int roomNr) {
        this.pricePerNight = pricePerNight;
        this.available = available;
        this.roomNr = roomNr;
    }

    public boolean getPet() {
        return pet;
    }
    public double getHaustier() {
        return haustier;
    }

    public boolean getRoomService() {
        return roomservice;
    }
    public void setRoomService(boolean roomservice) {
        this.roomservice = roomservice;
    }
    public static double getZimmerservice() {
        return zimmerservice;
    }

    public boolean getGästetoilette() {
        return gästetoilette;
    }
    public static double getSecondToilet() {
        return secondToilet;
    }

    public void setCountGuests(int countGuests) {
        this.countGuests = countGuests;
    }
    public int getCountGuests() {
        return countGuests;
    }

    public boolean getSinglePerson() {
        return singlePerson;
    }
    public double getEinzelPerson() {
        return einzelPerson;
    }

    public boolean getBalkon() {
        return balkon;
    }
    public static double getBalcony() {
        return balcony;
    }

    public boolean getFrühstück() {
        return frühstück;
    }
    public static double getBreaky() {
        return breaky;
    }

    public void setPricePerNight(double pricePerNight) {
        this.pricePerNight = pricePerNight;
    }
    public double getPricePerNight() {
        return pricePerNight;
    }

    public void setBookinperiode(int bookinperiode) {
        this.bookinperiode = bookinperiode;
    }
    public int getBookingPeriode() {
        return bookinperiode;
    }

    public void setAvailable(boolean available) {
        this.available = available;
    }
    public boolean getAvailable(boolean available) {
        return available;
    }

    public String getName() {
        return Name;
    }
    public void setName(String Name) {
        this.Name = Name;
    }

    public double getPriceLevel() {
        return priceLevel;
    }
    public void setPriceLevel(double priceLevel) {
        this.priceLevel = priceLevel;
    }

    public int getRoomNr() {
        return roomNr;
    }
}

Answer 1

面向对象的

分析与设计

在你做任何编码之前，从笔和铅笔开始总是一个好主意。下面是一个关于这样的设计如何看起来的演示(我强烈推荐UML，因为工程师中的每个人都理解这种图表)。

老实说，我不完全理解你的要求(你的家庭作业任务)，所以这个设计可能有缺陷。拿着它，根据你的需要调整它。

Pets

由于携带宠物到您的房间并不取决于任何房间功能(酒店管理可能允许作为一个例外，将您的宠物带到一个常规房间)，这个功能只是一个定价功能。有了一个设计在你的手中，你可以很容易地决定，在哪里放置这样的额外收费：Booking！这也是你早餐应该在的地方。

有用提示

• 避免静态成员和方法，使用您的设计并将它们放入适当的类中。
• 在命名时坚持使用java命名风格指南
• UMLetino工具
• 请看评论：吉尔伯特·勒布朗说:基本上，问题描述中的每个名词都是一个潜在的类对象。
• 附加:每个动词都是一种方法。
• 初学者:阅读德国清洁代码

Answer 2

• 问: java中的方法和普通变量名按惯例以一个小写字母开头。而不是C#。这是一种特殊的课程惯例吗？
• 数组条目的重复代码。
• X == true就是X，X == false是!X (不是X)。
• 参数f(X[] array, int index)可能只是f(X x)。也可能是被调用的方法应该是X.f()的一个方法。电话：f(array[index])。(您可以在f.中更改X的字段)
• double haustier (宠物)会让我发抖，就像double children - int？

现在来问这个问题：

• 房间的子类:阁楼，贝森卡默，.放置在Room数组中可能不是很容易管理。
• 但是您有一个房间的许多功能，而不是许多字段，您可以拥有一个RoomProperty并派生HavingPet (或其他什么)子类，并调用overridenask()、String toString()、additionalPrice()等等。那就有道理了。然后使用RoomProperty[] properties = new RoomProperties[10];。而不是固定大小的数组，您稍后将学习动态的、不断增长的列表(即ArrayList)。
• 然后，可以通过使用HavingPet填充其初始属性的Room子类来实现顶层公寓。

Answer 3

命名

命名真的很重要。有一些惯例有助于向读者提供有用的提示，说明名称所指的是什么。camelCase名称本身通常是变量，带括号的camelCase(很可能是函数调用。Capitals通常用于类、常量、枚举。

所以，当我看到这样的事情：

预订(酒店)；//Methode zum Buchen

需要更多的处理才能知道Booking所指的是什么，因为它看起来像是构造函数调用。这是由名称本身强化的，Booking听起来像一件事，而不是一个动作，所以我希望它是一个类名。如果您需要添加一个评论来告诉您这是预订方法，那么这可能是一个很好的迹象，名称可以改进……createBooking可能是一个更具描述性的名称。

不要用你们的名字作弊.

布尔型客房服务；静态双Z型服务= 10；

我建议为您的实际代码选择一种语言，用不同的语言进行注释是可以的，但是如果您在代码中使用这两种语言，那么您可能会遇到类似的情况，您的名字基本上是相同的，意思是两种不同的东西。这太让人困惑了。其中一个应该有不同的名字。也许是roomServiceCost？

钱.

人们很有趣，因为错误而损失了钱.通常，当你处理金钱时，你想要考虑使用BigDecimal，而不是double。但是，与double相比，使用它要困难一些，而且这个应用程序可能没有必要。

客户界面？

私有静态布尔CustomerInterface = true;//Hauptprogramm布尔值

目前还不清楚这个变量的作用是什么。似乎它应该被用来确定是否显示了接口，但是它总是被设置为true.

复制

注意代码中的重复。这是一个很好的迹象，可能有其他抽象，方法或类。所以，在您的Booking方法中，您在case的S中做了或多或少相同的事情

case "2": if (hotel[1].getAvailable(hotel[1].available)) { int roomNr = 1; PreisKategorie(hotel, roomNr); Breakfast(hotel, roomNr); Balcony(hotel, roomNr); BookingPeriode(hotel, roomNr); FinalizeBooking(hotel, roomNr);

考虑一下是否有一种方法可以将userInput转换成一个可以用来驱动预订体验的数字，并消除其中的一些冗余。

调用深度

小心打电话的圈子。因此，您的Booking方法可以调用AldreadyBooked，这反过来又会调用Booking。每个方法调用都添加到调用堆栈中。如果这种情况发生了足够多次，那么您将面临堆栈溢出的风险。与其遵循这个循环，不如考虑是否有一种方法可以将成功/失败返回给调用者，这样它就可以决定下一步该做什么，而不是像这样对调用者进行呼叫。

预订与房间与请求

数据分割最明显的第一步是考虑房间的属性和预订的属性。

Room有一些与预订无关的属性，它们只是房间的一部分。这可能是像roomNumber，beds，toilets，allowsPets等。

另一方面，RoomBooking可能包含与特定预订相关的内容，例如bookedRoom、price、breakfastRequired等。

然后，您可能会有另一个抽象，例如BookingRequest，它包含诸如numberPeople、breakfastRequired、fromDate、numberNights等东西，可以用来确定哪些房间可以满足客户的要求，哪些房间是可用的。

有了这些抽象，可以更容易地思考如何重新处理逻辑以添加额外的功能.因此，例如，如果顾客只需要一个人的空间，但所有的房间都有一张单人床，那么你可以为他们提供一个双人间。

能见度

您的Room类有一个私有成员和许多内部成员。想想这是否真的有意义..。

静力学

如果你要让statics加入你的class，最好把它们组合在一起，而不是把它们分散在其他变量中。

如果你的静力学应该是恒定的，我想你的很多人都是这样的，你应该把它们标记为final，以表示它们不会改变。