Example #1
0
        static void Main(string[] args)
        {
            #region In Datei schreiben
            Transportmittel transportmittel = new Transportmittel("Mercedes", 30000.00, 280);
            string          jsonString      = JsonConvert.SerializeObject(transportmittel);
            StreamWriter    streamWriter    = new StreamWriter("Transportmittel.json");
            streamWriter.Write(jsonString);
            // Ohne Close bleibt die Datei leer
            streamWriter.Close();
            #endregion

            #region Aus Datei lesen
            StreamReader streamReader = new StreamReader("Transportmittel.json");
            var          objekt       = JsonConvert.DeserializeObject <Transportmittel>(streamReader.ReadToEnd());
            streamReader.Close();
            Console.WriteLine($"objekt is Transportmittel: {objekt is Transportmittel}");
            Console.WriteLine($"{objekt.BeschreibeMich()}");
            #endregion

            PKW    pkw    = new PKW("Audi", 30000.00, 250, 4, 4, 0);
            string fileDB = "FileDB.json";
            //Schreibe(pkw, fileDB);
            Schreibe(pkw);

            Console.WriteLine(
                Lese <PKW>(fileDB).BeschreibeMich()
                );
            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            // Daten geschrieben
            Schiffe schiffe = new Schiffe("Schiff 2", 254, 78000, 0, 3);
            PKW     pKW     = new PKW("Audi", 250, 45000, 0, PKW.MyAntrieb.Front);

            schiffe.Beladen(pKW);
            string       jsonString   = JsonConvert.SerializeObject(schiffe);
            StreamWriter streamWriter = new StreamWriter("Transportmittel.json");

            streamWriter.Write(jsonString);
            streamWriter.Close();

            // Daten lesen
            StreamReader streamReader = new StreamReader("Transportmittel.json");
            var          objekt       = JsonConvert.DeserializeObject <Schiffe>(streamReader.ReadToEnd());

            Console.WriteLine($"Objekt ist Schiffe: {objekt is Schiffe}");
            Console.WriteLine(objekt.BeschreibeMich());
            streamReader.Close();

            objekt.Beschleunige(47, Transportmittel.InEinheit.kilometer);
            Schreibe <Schiffe>(objekt);

            Console.ReadKey();
        }
Example #3
0
        public void Beschleunige_PKW_auf_150()
        {
            PKW pkw1 = new PKW("BMW", 190, 23000, 5);

            pkw1.StarteMotor();
            pkw1.Beschleunige(150);

            Assert.AreEqual(150, pkw1.AktGeschwindigkeit);
        }
Example #4
0
        public void Beschleunige_PKW_ueber_MaxG()
        {
            PKW pkw1 = new PKW("BMW", 210, 25000, 3);

            pkw1.StarteMotor();
            pkw1.Beschleunige(220);

            Assert.AreEqual(pkw1.MaxGeschwindigkeit, pkw1.AktGeschwindigkeit);
        }
Example #5
0
        public void Beschleunige_PKW_über_Max_Geschwindigkeitt()
        {
            PKW pkw = new PKW("VW", 280, 31000, 5);

            pkw.StarteMotor();

            pkw.Beschleunige(300);

            Assert.AreEqual(pkw.MaxGeschwindigkeit, pkw.AktGeschwindigkeit);
        }
Example #6
0
        public void Beschleunige_PKW_über_Max_Geschwindigkeitt()
        {
            PKW pkw = new PKW("VW", 280, 31000, PKW.PKWTreibstoff.Benzin);

            pkw.MotorStarten();

            pkw.Beschleunige(300);

            Assert.AreEqual(pkw.MaxGeschwindigkeit, pkw.AktGeschwindigkeit);
        }
Example #7
0
        public void Bremse_PKW_unter_0()
        {
            PKW pkw1 = new PKW("BMW", 210, 25000, 3);

            pkw1.StarteMotor();
            pkw1.Beschleunige(220);
            pkw1.Beschleunige(-300);

            Assert.AreEqual(-5, pkw1.AktGeschwindigkeit);
        }
Example #8
0
        public void Beschleunige_Test_SchnellerAlsMaxG()
        {
            PKW pkw = new PKW("BMW", 230, 25000.0, 3);

            pkw.StarteMotor();
            pkw.Beschleunige(300);

            //Dies ASSERT-Klasse enthält diverse Vergleichsmethoden, welche in Unit-Tests verwendet werden können. Pro Test-Methode
            ///muss es mindesten einen Assert-Aufruf geben
            Assert.AreEqual(230, pkw.AktGeschwindigkeit);
        }
        public void Beschleunige_PKW_ueber_MaxG()
        {
            PKW pkw1 = new PKW("BMW", 260, 26000, 4);

            pkw1.StarteMotor();
            pkw1.Beschleunige(300);

            //Dies ASSERT-Klasse enthält diverse Vergleichsmethoden, welche in Unit-Tests verwendet werden können. Pro Test-Methode
            ///muss es mindesten einen Assert-Aufruf geben
            Assert.AreEqual(pkw1.MaxGeschwindigkeit, pkw1.AktGeschwindigkeit);
        }
Example #10
0
        public void Beschleunige_PKW_über_Max_Geschwindigkeit()
        {
            PKW pkw = new PKW("VW", 280, 31000, PKW.PKWTreibstoff.Benzin);

            pkw.MotorStarten();

            pkw.Beschleunige(300);

            //Dies ASSERT-Klasse enthält diverse Vergleichsmethoden, welche in Unit-Tests verwendet werden können. Pro Test-Methode
            ///muss es mindesten einen Assert-Aufruf geben
            Assert.AreEqual(pkw.MaxGeschwindigkeit, pkw.AktGeschwindigkeit);
        }
Example #11
0
        public static void RadAb(IBewegbar bewegbarsO)
        {
            bewegbarsO.RäderAnzahl--;

            if (bewegbarsO is PKW)
            {
                PKW pkw1 = (PKW)bewegbarsO;
                Console.WriteLine(pkw1.Treibstoff);

                Console.WriteLine(((PKW)bewegbarsO).Treibstoff);
            }
        }
        private void BtnLoadXml_Click(object sender, EventArgs e)
        {
            XmlSerializer xmlSeri = new XmlSerializer(typeof(PKW));

            FileStream file = File.Open("xmlFahrzeuge.xml", FileMode.Open);

            PKW pkw1 = (PKW)xmlSeri.Deserialize(file);

            MessageBox.Show(pkw1.ToString());

            file?.Close();
        }
Example #13
0
        static void Main(string[] args)
        {
            Action <int> actionVar = Funktion1;

            actionVar += Funktion1;

            actionVar(45);

            actionVar -= Funktion1;

            actionVar(85);


            Func <int, int, string> funcVar = Funktion2;

            funcVar += Funktion2;


            Console.WriteLine(funcVar(12, 123));


            List <int> intList = new List <int>();

            for (int i = 0; i < 50; i++)
            {
                intList.Add(i * 3);
            }

            List <int> ergebnisse = intList.FindAll(delegate(int a)
            {
                return(a % 2 == 0);
            });

            foreach (var item in ergebnisse)
            {
                Console.WriteLine(item);
            }

            List <Fahrzeug> fzList = new List <Fahrzeug>();

            for (int i = 0; i < 10; i++)
            {
                fzList.Add(PKW.ErzeugeZufälligenPKW());
            }

            Fahrzeug ErgFz = fzList.Find(fz => fz.Name.Equals("BMW"));


            Console.WriteLine(ErgFz.BeschreibeMich());

            Console.ReadKey();
        }
Example #14
0
        //Bsp-Methode Modul 06
        public static void RadAb(IBewegbar bewegbaresObjekt)
        {
            bewegbaresObjekt.AnzahlRäder--;

            if (bewegbaresObjekt is PKW)
            {
                ((PKW)bewegbaresObjekt).StarteMotor();

                PKW pkw1 = (PKW)bewegbaresObjekt;

                pkw1.Beschleunige(45);
            }
        }
        //Bsp-Methode Modul06 (Methode erwartet Objekt einer Klasse, die IBewegbar implementiert hat, als Übergabeparameter)
        //vgl. oben stehende Methode BeladeFahrzeuge()
        public static void RadAb(IBewegbar bewegbar)
        {
            bewegbar.Räderanzahl--;

            if (bewegbar is PKW)
            {
                PKW pkw1 = (PKW)bewegbar;

                pkw1.AnzahlTüren--;

                (bewegbar as PKW).AnzahlTüren--;
            }
        }
        //Bsp-Methode Modul 06
        /// <summary>
        /// Hier kann eine Beschreibung der Methode stehen
        /// </summary>
        /// <param name="bewegbar">Ein bewegbares Objekt</param>
        /// <exception cref="FormatException"></exception>
        public static void RadAb(IBewegbar bewegbar)
        {
            bewegbar.RäderAnzahl--;

            if (bewegbar is PKW)
            {
                PKW pkw1 = (PKW)bewegbar;
                Console.WriteLine($"{pkw1.Name} hat ein Rad verloren.");

                Console.WriteLine($"{((PKW)bewegbar).Name} hat ein Rad verloren.");

                Console.WriteLine($"{(bewegbar as PKW).Name} hat ein Rad verloren.");
            }
        }
        public void Teste_Beschleunigung()
        {
            //Initialisierungphase
            PKW pkw = new PKW("BMW", 190, 26000);

            //Vorbereitungsphase
            pkw.StarteMotor();
            pkw.Beschleunige(200);

            //Testphase

            //Die ASSERT-Klasse enthält diverse Vergleichsmethoden, welche in Unit-Tests verwendet werden können. Pro Test-Methode
            ///muss es mindesten einen Assert-Aufruf geben
            Assert.AreEqual(pkw.MaxGeschwindigkeit, pkw.AktGeschwindigkeit);
        }
Example #18
0
        //Methode zur zufälligen Erstellung von Fahrzeugen
        public Fahrzeug ErstelleNeuesFz()
        {
            switch (Generator.Next(1, 4))
            {
            case 1:
                return(new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));

            case 2:
                return(new Flugzeug("Boing", 800, 3000000, 9999));

            case 3:
                return(PKW.ErzeugeZufälligenPKW(""));
            }
            return(null);
        }
Example #19
0
        static void Main(string[] args)
        {
            List <string>  strListe1 = new List <string>();
            IList <string> strListe2 = new List <string>();

            Garage garage = new Garage();

            try
            {
                BobbyCar  bobbyCar  = new BobbyCar("Lalelu", "Turboschnuller 2.0", 2020, 3, "Rot", 50);
                PKW       pkw       = new PKW("VW", "Passat", 1992, 120, "Blau", 4, 4);
                PKW       pkw1      = new PKW("Ferrari", "Rote Göttin", 2001, 320, "Rot", 2, 4);
                Yacht     yacht     = new Yacht("Gib'Sea", "Ver 1.1", 1982, 10, "hellblau", 2.1, true);
                Yacht     yacht1    = new Yacht("Wester", "Nautilus1", 1999, 12, "gelb", 3.1, false);
                Tretboot  tretboot  = new Tretboot("Opas Best Boats", "SimpleBoat 1.0", 2010, 2, "Blau", 0.3, 2);
                Tretboot  tretboot1 = new Tretboot("Omas Best Boats", "SimpleBoat 2.0", 2010, 2, "Geld", 0.5, 2);
                Tretboot  tretboot2 = new Tretboot("Titanic Best Boats", "SimpleBoat 3.0", 2010, 2, "Orange", 0.6, 1);
                Jet       jet       = new Jet("Airbus", "X-Wing", 2055, 800, "Schwarz", 15.6, 36000, 0, 2, 2.8);
                Jet       jet1      = new Jet("Airbus", "Millenium Falke", 3001, 1800, "Grau", 15.6, 36000, 0, 2, 2.8);
                Propeller propeller = new Propeller("Fugger", "Albatros", 1915, 40, "Rot", 6.4, 4000, 0, 1, 1200);


                garage.Einparken(bobbyCar);
                garage.Einparken(pkw);
                garage.Einparken(pkw1);
                garage.Einparken(yacht);
                garage.Einparken(yacht1);
                garage.Einparken(tretboot);
                garage.Einparken(tretboot1);
                garage.Einparken(tretboot2);
                garage.Einparken(jet);
                garage.Einparken(jet1);
                garage.Einparken(propeller);

                bobbyCar.Baujahr = 1800;

                //Referenztypen, können im Nachgang noch den Inhalt einer Liste bearbeiten. Siehe am Beispiel BobbyCar
                BobbyCar clonedBobbyCar = (BobbyCar)bobbyCar.Clone();
                clonedBobbyCar.Baujahr = 1300;
                garage.Einparken(clonedBobbyCar);

                garage.DisplayInventar();
            }
            catch (FahrzeugMaxException ex)
            {
            }
        }
        private static void TPT()
        {
            using (var context = new InheritanceContext())
            {
                var lkw = new LKW {
                    Farbe = "Rot", MaxLadung = 13000
                };
                var pkw = new PKW {
                    Farbe = "Blau", Sitzplaetze = 5
                };

                context.Fahrzeuge.Add(lkw);
                context.Fahrzeuge.Add(pkw);

                context.SaveChanges();
            }
        }
Example #21
0
        private static void TPT()
        {
            using (var context = new InheritanceContext())
            {
                var pkw = new PKW {
                    Geschwindigkeit = 50, Sitzplätze = 5
                };
                var lkw = new LKW {
                    Geschwindigkeit = 30, MaxLadung = 18000
                };

                context.Fahrzeuge.Add(pkw);
                context.Fahrzeuge.Add(lkw);

                context.SaveChanges();
            }
        }
Example #22
0
        //Methode zur zufälligen Erstellung von Fahrzeugen
        private void ErstelleNeuesFZ()
        {
            switch (Generator.Next(1, 4))
            {
            case 1:
                FzListe.Add(new Flugzeug($"Boing", 800, 3600000, 9999));
                break;

            case 2:
                FzListe.Add(new Schiff($"Titanic", 40, 3500000, Schiff.Schiffstreibstoff.Dampf));
                break;

            case 3:
                FzListe.Add(PKW.ErzeugeZufälligenPKW());
                break;
            }
        }
Example #23
0
        static void Main(string[] args)
        {
            Fahrzeug myBMW = new Fahrzeug("BMW", 200, 500000, 100, Fahrzeug.Zustand.Stehend);

            Console.WriteLine($"{myBMW.Name}");
            int geschw = myBMW.Beschleunige(50);

            Console.WriteLine($"{geschw}");

            myBMW.Startemotor();

            Console.WriteLine($"myBMW.Beschreibemich(): {myBMW.Beschreibemich()}");

            myBMW.Stoppemotor();

            Console.WriteLine($"myBMW.Beschreibemich(): {myBMW.Beschreibemich()}");

            Flugzeug myBoeing = new Flugzeug("Boeing", 1000, 50000, 500, Fahrzeug.Zustand.Fahrend, "USA");

            Console.WriteLine($"myBoeing.Beschreibemich(): {myBoeing.Beschreibemich()}");

            Schiff Titanik = new Schiff("Titanik", 5000, 100000, 500, Fahrzeug.Zustand.Fahrend, "USA");

            Console.WriteLine($"Titanik.Beschreibemich(): {Titanik.Beschreibemich()}");


            PKW Opel = new PKW("Opel", 200, 10000, 500, Fahrzeug.Zustand.Fahrend, "Germany");

            Console.WriteLine($"Opel.Beschreibemich(): {Opel.Beschreibemich()}");

            Flugzeug flieger1 = new Flugzeug("Boeing", 800, 3000000, 500, Fahrzeug.Zustand.Stehend, "USA", 9000, 800);

            foreach (var item in flieger1)
            {
                Console.WriteLine($"item:{item}");
            }
            string testeArrayÄhnlichkeit = flieger1[2];

            Console.WriteLine($"testeArrayÄhnlichkeit:{testeArrayÄhnlichkeit}");



            Console.ReadKey();
        }
Example #24
0
        static void Main(string[] args)
        {
            // In eine Datei Schreiben
            // Beschreibung Schiff
            Schiff schiff = new Schiff("Dampfer", 1000000, 86478229, 30500);

            PKW pkw = new PKW("Alfa Romeo", 200, 600000, 4);

            schiff.Belade(pkw);

            // eine Json String erstellen
            string jsonString = JsonConvert.SerializeObject(schiff);

            // in Datei schreiben
            StreamWriter streamWriter = new StreamWriter("Transportmittel.json");

            // Datei wird in Json String gewandelt
            streamWriter.Write(jsonString);

            //schliessen
            streamWriter.Close();

            // In Datei lesen
            // Wird in Jason Datei gelesen
            StreamReader streamReader = new StreamReader("Transportmittel.json");

            // Lesen aus einer Datei
            var objekt = JsonConvert.DeserializeObject <Transport>(streamReader.ReadToEnd());

            // schliessen
            streamReader.Close();

            //
            Console.WriteLine($"object is Transport: {objekt is Transport}");
            Console.WriteLine($"object: {objekt.BeschreibeMich()}");


            objekt.Beschleunige(5, Transport.GeschwEinheit.Kilometer);

            // Aufruf für static void Schreiben<T>(T o)
            Schreibe <Transport>(objekt);

            Console.ReadKey();
        }
        //Methode zur zufälligen Fahrzeug-Erzeugung
        private void ErzeugeNeuesFz()
        {
            switch (generator.Next(1, 4))
            {
            case 1:
                FahrzeugListe.Add(new Schiff("Titanic", 40, 3000000.0, Schiff.Treibstoffart.Dampf));
                break;

            case 2:
                FahrzeugListe.Add(new Flugzeug("Boing", 980, 3500000.0, 9999));
                break;

            case 3:
                FahrzeugListe.Add(PKW.ErzeugeZufälligenPKW());
                break;

            default:
                break;
            }
        }
Example #26
0
        //Click-Methoden der Buttons

        //Methode zur zufälligen Erstellung von Fahrzeugen
        private void BtnNew_Click(object sender, EventArgs e)
        {
            switch (generator.Next(1, 4))
            {
            //Erzeugung von Objekten je nach zufälliger Zahl
            case 1:
                FahrzeugListe.Add(new Flugzeug($"Boing", 800, 3600000, 9999));
                break;

            case 2:
                FahrzeugListe.Add(new Schiff($"Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
                break;

            case 3:
                FahrzeugListe.Add(PKW.ErzeugeZufälligenPKW($""));
                break;
            }

            ShowFzs();
        }
        static void Main(string[] args)
        {
            Transportmittel transportmittel = new Transportmittel("Kutsche", 450.23, 200);

            Console.OutputEncoding = Encoding.Unicode;
            Console.WriteLine(transportmittel.BeschreibeMich());

            PKW pkw = new PKW("Audi", 45.45, 189, 3, 45);

            Console.WriteLine(pkw.BeschreibeMich());

            Schiff schiff = new Schiff("Titanic", 2000000.00, 150, Schiff.SchiffsTreibstoff.Diesel);

            Console.WriteLine(schiff.BeschreibeMich());

            Flugzeug flugzeug = new Flugzeug("Boeing", 356433222.22, 500, 7, 20000);

            Console.WriteLine(flugzeug.BeschreibeMich());

            Console.ReadKey();
        }
Example #28
0
        static void Main(string[] args)
        {
            Transport transport = new Transport("Alfa Romeo", 200, 50000);

            Console.WriteLine($"Beschreibung: {transport.BeschreibeMich()}");

            // km/h in dMeilen umrechnen
            double miles = Transport.KmToMiles(220);

            Console.WriteLine($"220 km/h zu Miles: {miles}");

            // Beschreibung PKW
            PKW pkw = new PKW("Alfa Romeo", 200, 600000, 4);

            Console.WriteLine($"Beschreibung PKW: {pkw.BeschreibeMich()}");

            // Beschreibung Schiff
            Schiff schiff = new Schiff("Dampfer", 1000000, 86478229, 30500);

            Console.WriteLine($"Beschreibung Schiff: {schiff.BeschreibeMich()}");

            // Beschreibung Flugzeug
            Flugzeug flugzeug = new Flugzeug("Jet", 500, 645363, 30);

            Console.WriteLine($"Beschreibung Flugzeug: {flugzeug.BeschreibeMich()}");

            List <Passagier> pList = new List <Passagier>();

            pList.Add(new Passagier("Herr Alter", 30));
            pList.Add(new Passagier("Frau Neuer", 20));
            pList.Add(new Passagier("Fräulein Jung", 15));
            flugzeug.Passagierliste = pList;

            foreach (var item in flugzeug.Passagierliste)
            {
                Console.WriteLine(item.Nachname);
            }

            Console.ReadKey();
        }
Example #29
0
        static void Main(string[] args)
        {
            MyFahrzeugClass myFahrzeug = new MyFahrzeugClass("Fahrzeug", 100, 1000, 0, "stehend");

            myFahrzeug.StarteMotor();
            myFahrzeug.Beschleunige(150);
            myFahrzeug.Beschleunige(70);

            string Satz = myFahrzeug.BeschreibeMich();

            Console.WriteLine(Satz);


            PKW pkw = new PKW("BMW", 200, 1000000, 0, "stehend", 3);

            Console.WriteLine(pkw.BeschreibeMich());

            Schiff schiff = new Schiff("Titanic", 30, 1000000000, 0, "stehend", 100);

            Console.WriteLine(schiff.BeschreibeMich());



            Flugzeug flieger1 = new Flugzeug("Boeing", 1000, 10000000, 0, "stehend", 10000);

            // Console.WriteLine(flugzeug.BeschreibeMich());

            // Verwendung von IEnumerable
            foreach (var item in flieger1)
            {
                Console.WriteLine($"item: {item}");
            }

            string testeArrayÄhnlichkeit = flieger1[2];

            Console.WriteLine($"testeArrayÄhnlichkeit: {testeArrayÄhnlichkeit}");


            Console.ReadKey();
        }
        static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            //Console.Write("Bitte Fahrzeugname eingeben: ");
            //string FName = Console.ReadLine();
            //Console.Write("Bitte MaxGeschwindigkeit eingeben: ");
            //int FMaxGeschw = int.Parse(Console.ReadLine());
            //Console.Write("Bitte Preis eingeben: ");
            //int FPreis = int.Parse(Console.ReadLine());
            //Console.Write("Bitte aktuelle Geschwindigkeit eingeben: ");
            //int FAktuellV = int.Parse(Console.ReadLine());
            //Console.Write("Bitte Anfangs-Zustand eingeben (\"Stehend=0, Fahrend=1\"): ");
            //int FZustand = int.Parse(Console.ReadLine());
            //Fahrzeug fahrzeug = new Fahrzeug(FName, FMaxGeschw, FPreis, FAktuellV, FZustand);
            FahrzeugLib fahrzeug = new FahrzeugLib("BMW", 200, 20000);
            Flugzeug    flugzeug = new Flugzeug("Boeing", 900, 9500000, 3);
            PKW         pkw      = new PKW("Audi", 250, 35000, 5);
            Schiff      schiff   = new Schiff("Titanic", 60, 2500000, true);

            foreach (var item in flugzeug)
            {
                Console.WriteLine($"Eintrag: {item}");
            }
            Console.WriteLine("\n###########################");

            //Console.WriteLine($"Name: {fahrzeug.Name}");
            //Console.WriteLine($"Max Geschw: {fahrzeug.MaxGeschwindigkeit}");
            //Console.WriteLine($"Preis: {fahrzeug.Preis}");
            //Console.WriteLine($"Aktuelle Geschw: {fahrzeug.AktuelleGeschwindigkeit}");
            //Console.WriteLine($"Zustand: {fahrzeug.Zustand}");

            Console.WriteLine(fahrzeug.BeschreibeMich());
            Console.WriteLine("\n###########################");
            Console.WriteLine(flugzeug.BeschreibeMich());
            Console.WriteLine("\n###########################");
            Console.WriteLine(pkw.BeschreibeMich());
            Console.WriteLine("\n###########################");
            Console.WriteLine(schiff.BeschreibeMich());

            Console.WriteLine();
            Console.WriteLine("\n###########################");

            bool beenden = true;

            do
            {
                Console.WriteLine();
                Console.WriteLine("Was soll mit dem Fahrzeug passieren?");
                Console.WriteLine("1 = Motor stoppen");
                Console.WriteLine("2 = Motor starten");
                Console.WriteLine("3 = Beschleunigen");
                Console.WriteLine("4 = Habe fertig");
                int Antwort = int.Parse(Console.ReadLine());
                Console.Clear();
                switch (Antwort)
                {
                case 1:
                    fahrzeug.StoppeMotor();
                    Console.WriteLine($"Aktueller Zustand: {fahrzeug.Zustand}");
                    break;

                case 2:
                    fahrzeug.StarteMotor();
                    Console.WriteLine($"Aktueller Zustand: {fahrzeug.Zustand}");
                    break;

                case 3:
                    fahrzeug.Beschleunigen();
                    Console.WriteLine($"Aktuelle Geschw: {fahrzeug.AktuelleGeschwindigkeit} km/h");
                    break;

                case 4:
                    beenden = false;
                    break;
                }
            } while (beenden);
        }