static void Main(string[] args)
{
Fahrzeug auto1 = new Fahrzeug("Opel Astra", 30000, 200);
Console.WriteLine(auto1.BeschreibeMich());
auto1.StarteMotor();
auto1.StarteMotor();
auto1.StarteMotor();
Console.WriteLine(auto1.BeschreibeMich());
auto1.Parke();
Console.WriteLine(auto1.BeschreibeMich());
auto1.StarteMotor();
auto1.StarteMotor();
Console.WriteLine(auto1.BeschreibeMich());
Flugzeug flieger1 = new Flugzeug("Boeing", 800, 30000000, 9000);
// 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();
}
public void Uebung1()
{
// Aufgabe 3
Flugzeug flugzeug = new Flugzeug();
Auto auto = new Auto();
Panzer panzer = new Panzer();
Boot boot = new Boot();
foreach (Fahrzeug fahrzeug in Fahrzeug.Fahrzeuge)
{
// erster versuch, gibt besseren weg.
//if (fahrzeug is Flugzeug) {
// (fahrzeug as Flugzeug).Fliegen();
// (fahrzeug as Flugzeug).Fahren();
//} else if (fahrzeug is Auto) {
// (fahrzeug as Auto).Fahren();
//} else if (fahrzeug is Panzer) {
// (fahrzeug as Panzer).Fahren();
// (fahrzeug as Panzer).Schwimmen();
//} else if (fahrzeug is Boot) {
// (fahrzeug as Boot).Schwimmen();
//}
// Bessere Lösung:
// "as" versucht das Objekt in den gegebenen Typ zu konvertieren und gibt null zurück, falls es nicht geht
// "?" prüft ob der vorherige ausdruck nicht null ist
(fahrzeug as IFlugfaehig)?.Fliegen();
(fahrzeug as IFahrbar)?.Fahren();
(fahrzeug as ISchwimmfaehig)?.Schwimmen();
}
}
public async Task <IActionResult> PutFlugzeug([FromRoute] int id, [FromBody] Flugzeug flugzeug)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != flugzeug.Id)
{
return(BadRequest());
}
_context.Entry(flugzeug).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FlugzeugExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] Flugzeug flugzeug)
{
if (id != flugzeug.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(flugzeug);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FlugzeugExists(flugzeug.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(flugzeug));
}
public async Task <IActionResult> Create([Bind("Id,Name")] Flugzeug flugzeug)
{
if (ModelState.IsValid)
{
_context.Add(flugzeug);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(flugzeug));
}
public async Task <IActionResult> PostFlugzeug([FromBody] Flugzeug flugzeug)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Flugzeuge.Add(flugzeug);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetFlugzeug", new { id = flugzeug.Id }, flugzeug));
}
static void Main(string[] args)
{
#region Daten
Flugzeug flugzeug = new Flugzeug()
{
Gewicht = 23,
Farbe = "weiß",
Spannweite = 34
};
Hubschrauber hubschrauber = new Hubschrauber()
{
Gewicht = 3.5m,
Farbe = "grün",
RotorDurchmesser = 8
};
Frachter frachter = new Frachter()
{
Gewicht = 34000,
Farbe = "schwarz",
Brt = 48000,
Tiefgang = 3.5M,
Ladevolumen = 30000
};
#endregion Daten
// Eine Fahrzeugliste erzeugen
List <Fahrzeug> fahrzeugs = new List <Fahrzeug>()
{
flugzeug, hubschrauber, frachter
};
// binär
DataHandler data = new DataHandler(new DateiProvider("liste.dat"), new BinarySerialisierer());
data.SetData(fahrzeugs);
fahrzeugs = data.GetData();
Ausgabe(fahrzeugs, SerializerTyp.Binary);
// xml
data = new DataHandler(new DateiProvider("liste.xml"), new XmlSerialisierer());
data.SetData(fahrzeugs);
fahrzeugs = data.GetData();
Ausgabe(fahrzeugs, SerializerTyp.Xml);
// soap
data = new DataHandler(new DateiProvider("liste.soap"), new BinarySerialisierer());
data.SetData(fahrzeugs);
fahrzeugs = data.GetData();
Ausgabe(fahrzeugs, SerializerTyp.Soap);
Console.ReadKey();
}
//BSP-Methode Modul06
static void RadAb(IBewegbar bewegbaresObjekt)
{
bewegbaresObjekt.AnzahlRäder--;
if (bewegbaresObjekt is Flugzeug)
{
Flugzeug flugzeug1 = (Flugzeug)bewegbaresObjekt;
flugzeug1 = bewegbaresObjekt as Flugzeug;
Console.WriteLine(flugzeug1.Name + " hat auf " + flugzeug1.MaxFlughöhe + "m ein Rad verloren.");
Console.WriteLine((bewegbaresObjekt as Flugzeug).Name);
}
}
static void Main(string[] args)
{
Luftfahrzeug[] arr = new Luftfahrzeug[5];
arr[0] = new Flugzeug();
arr[1] = new Hubschrauber();
arr[2] = new Hubschrauber();
arr[3] = new Flugzeug();
arr[4] = new Rakete();
foreach (Luftfahrzeug item in arr)
{
item.Starten();
}
Console.ReadLine();
}
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();
}
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();
}
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)
{
#region Modul04 OOP
////Instanzierung von Fahrzeugen
//Fahrzeug fz = new Fahrzeug("BMW", 270);
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 310);
////Ausgabe der Maximalgeschwindigkeit von fz
//Console.WriteLine(fz.MaxGeschwindigkeit);
////Änderung des Namens von fz1
//fz.Name = "VW";
////Ausgabe der BeschreibeMich()-Methoden der Fahrzeuge
//Console.WriteLine(fz.BeschreibeMich());
//Console.WriteLine(fz1.BeschreibeMich());
////Neuzuweisung der fz1-Variable auf Objekt in fz-Variable
//fz1 = fz;
////Manueller Aufruf der Garbage Collection
//GC.Collect();
#endregion
#region Lab04 Fahrzeug_Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen zum Testen der Fahrzeug-Funktionen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Modul05 Vererbung
////Instantiierung der Beispiel-Fahrzeuge
//PKW pkw1 = new PKW("BMW", 190, 23000, 5);
//PKW pkw2 = new PKW("BMW", 190, 23000, 5);
//PKW pkw3 = new PKW("BMW", 190, 23000, 5);
//PKW pkw4 = new PKW("BMW", 190, 23000, 5);
//PKW pkw5 = new PKW("BMW", 190, 23000, 5);
////Testen der überschriebenen BeschreibeMich()-Methode (vgl. PKW)
//Console.WriteLine(pkw1.BeschreibeMich());
////Testen der überschriebenen ToString()-Methode (vgl. PKW)
//Console.WriteLine(pkw1);
////Testen der statischen Property und Methode (vgl. PKW)
//Console.WriteLine(Fahrzeug.AnzahlFahrzeuge);
//Fahrzeug.ZeigeAnzahlFahrzeuge();
#endregion
#region Lab05 PKW-, Schiff- und Flugzeug-Klasse
////Instanziierung der unterschiedlichen Fahrzeug-Arten und Ausgabe der BeschreibeMich()-Methoden
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Console.WriteLine(pkw1.BeschreibeMich());
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//Console.WriteLine(schiff1.BeschreibeMich());
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1.BeschreibeMich());
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Modul06 Interfaces und Polymorphismus
////Initialisierung einer PKW-Variablen mit einem Beispiel-PKW
//PKW pkw1 = new PKW("BMW", 190, 23000, 5);
////Initialisierung einer Fahrezug- und einer IBewegbar-Variablen mit demselben PKW
////(alle Variablen zeigen auf das selbe Objekt im Speicher, können aber nur au die in der jeweiligen Klasse/Interface definierten Eigenschaften
////und Methoden zugreifen)
//Fahrzeug fz1 = pkw1;
//IBewegbar bewegbaresObjekt = pkw1;
////Demonstration der Zugriffsmöglichkeiten der einzelnen Variablen
//pkw1.BeschreibeMich();
//fz1.Beschleunige(0);
//bewegbaresObjekt.Crash();
////Aufruf einer Beispiel-Funktion (s.u.) welche ein Objekt vom Typ IBewegbar erwartet
//RadAb(pkw1);
#endregion
#region Lab06 IBeladbar
////Instanziierung der Beispiel-Fahrzeuge
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
////Aufruf der BeladeFahrzeuge()-Methode (s.u.)
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
////Ausgabe der BeschreibeMich()-Methode des beladenen Fahrzeugs
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Generische Listen
//List<string> stringListe = new List<string>();
//stringListe.Add("Hallo");
//stringListe.Add("Moin");
//stringListe.Add("Servus");
//stringListe.Add("Guten Tag");
//foreach (var item in stringListe)
//{
// Console.WriteLine(item);
//}
//Console.WriteLine(stringListe[2]);
//List<Fahrzeug> fzListe = new List<Fahrzeug>();
//fzListe.Add(new PKW("BMW", 250, 23000, 5));
//fzListe.Add(new Flugzeug("Boing", 750, 3000000, 9990));
//fzListe.Add(new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
//foreach (var item in fzListe)
//{
// Console.WriteLine(item.Name);
//}
//Dictionary<string, Fahrzeug> dict = new Dictionary<string, Fahrzeug>();
//dict.Add("Mein Auto", new PKW("BMW", 250, 23000, 5));
//dict.Add("Mein Flugzeug", new Flugzeug("Boing", 750, 3000000, 9990));
//if (dict.ContainsKey("Mein Flugzeug"))
// Console.WriteLine(dict["Mein Flugzeug"].Name);
#endregion
#region Lab07_ZufälligeFahrzeuglisten
// Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
// Random generator = new Random();
// Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
// Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
// Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
// Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
// int AnzahlFZs = 10000;
// Schleife zur zufälligen Befüllung von Queue und Stack
// for (int i = 0; i < AnzahlFZs; i++)
// {
// Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
// }
// Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
// for (int i = 0; i<AnzahlFZs; i++)
// {
// Prüfung, ob das Interface vorhanden ist(mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// ...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode(mittels Peek())...
// ((IBeladbar) fzQueue.Peek()).Belade(fzStack.Peek());
// ...sowie Hinzufügen zum Dictionary(mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// ... wenn nein, dann Löschung der obersten Objekte(mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
// }
// Programmpause
// Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
// Schleife zur Ausgabe des Dictionaries
// foreach (var item in fzDict)
// {
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
// }
#endregion
//ArrayLists sind Listen, welche mit Objekten beliebiger Datentypen gefüllt werden können.
ArrayList list = new ArrayList(3);
list.Add(78);
list.Add("Hallo");
list.Add(new PKW());
foreach (var item in list)
{
Console.WriteLine(item);
}
//Vorbereitung
Fahrzeug fz1 = new PKW("BMW", 190, 23000, 5);
Flugzeug flugzeug1 = new Flugzeug("Boing", 990, 300000000, 9999);
Random generator = new Random();
//Bsp für die Verwendung der in der Fahrzeug-Klasse definierten Operatoren
Console.WriteLine(fz1 == fz1);
Console.WriteLine(fz1 == new Flugzeug("Boing", 999, 500000000, 9999));
//Bsp für die Verwendung von IEnumerable
foreach (var item in flugzeug1)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung der Indexer-Property
Console.WriteLine(flugzeug1[1]);
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
int a = generator.NextInclusive(1, 8);
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);
}
static void Main(string[] args)
{
#region Modul04 - OOP
////Instatierung von Fahrzeugen
//Fahrzeug fz = new Fahrzeug("BMW", 270);
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 310);
////Ausgabe der Maximalgeschwindigkeit von fz
//Console.WriteLine(fz.MaxGeschwindigkeit);
////Änderung des Namens von fz1
//fz.Name = "VW";
////Ausgabe der BeschreibeMich()-Methoden der Fahrzeuge
//Console.WriteLine(fz.BeschreibeMich());
//Console.WriteLine(fz1.BeschreibeMich());
////Aufruf der MotorStarten()-Methode
//fz.MotorStarten()
////Neuzuweisung der fz1-Variable auf Objekt in fz-Variable
//fz1 = fz;
////Manueller Aufruf der Garbage Collection
//GC.Collect();
#endregion
#region Lab04 Fahrzeug_Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen
//fz1.MotorStarten();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.MotorStoppen();
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Modul 05 - Vererbung
//PKW pkw1 = new PKW("BMW", 220, 16000, PKW.PKWTreibstoff.Benzin);
//PKW pkw2 = new PKW("BMW", 220, 16000, PKW.PKWTreibstoff.Benzin);
//PKW pkw3 = new PKW("BMW", 220, 16000, PKW.PKWTreibstoff.Benzin);
//PKW pkw4 = new PKW("BMW", 220, 16000, PKW.PKWTreibstoff.Benzin);
//Console.WriteLine(pkw1);
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge);
#endregion
#region Lab05 - PKW-, Schiff, Flugzeug-Klasse
//PKW pkw1 = new PKW("BMW", 250, 23000, PKW.PKWTreibstoff.Benzin);
//Schiff schiff1 = new Schiff("Titanic", 50, 2600000, 900);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 990, 3600000, 9800);
//Console.WriteLine(pkw1.BeschreibeMich());
//Console.WriteLine(schiff1.BeschreibeMich());
//Console.WriteLine(flugzeug1.BeschreibeMich());
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge);
//schiff1.MotorStarten();
//schiff1.Beschleunige(30);
//Console.WriteLine(schiff1.BeschreibeMich());
#endregion
#region Modul06 - Intefaces und Polymorphismus
//PKW pkw1 = new PKW("BMW", 290, 36000, PKW.PKWTreibstoff.Benzin);
//Schiff schiff1 = new Schiff("Titanic", 50, 2600000, 900);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 990, 3600000, 9800);
//Fahrzeug fz1 = pkw1;
//IBewegbar bewegbaresObjekt = pkw1;
//ÄndereName(pkw1);
//ÄndereName(schiff1);
//ÄndereName(flugzeug1);
//RadAb(pkw1);
//RadAb(flugzeug1);
#endregion
#region Lab06 - IBeladbar
//PKW pkw1 = new PKW("BMW", 290, 36000, PKW.PKWTreibstoff.Benzin);
//Schiff schiff1 = new Schiff("Titanic", 50, 2600000, 900);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 990, 3600000, 9800);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(schiff1, flugzeug1);
//BeladeFahrzeuge(pkw1, schiff1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Modul07 - Generische Listen
//List<string> stringliste = new List<string>();
//Console.WriteLine(stringliste.Count);
//stringliste.Add("Eintrag 1");
//stringliste.Add("Eintrag 2");
//stringliste.Add("Eintrag 3");
//stringliste.Add("Eintrag 4");
//stringliste.Add("Eintrag 5");
//Console.WriteLine(stringliste.Count);
//foreach (var item in stringliste)
//{
// Console.WriteLine(item);
//}
//Console.WriteLine(stringliste[2]);
//stringliste.RemoveAt(2);
//foreach (var item in stringliste)
//{
// Console.WriteLine(item);
//}
//List<Fahrzeug> fzListe = new List<Fahrzeug>();
//PKW pkw1 = new PKW("BMW", 290, 36000, PKW.PKWTreibstoff.Benzin);
//fzListe.Add(pkw1);
//fzListe.Add(new Flugzeug("Boing", 3000, 2600000, 9999));
//foreach (var item in fzListe)
//{
// Console.WriteLine(item.Name);
//}
//List<List<string>> mehrdimensionaleListe = new List<List<string>>();
//string eintrag = mehrdimensionaleListe[1][2];
//Dictionary<int, string> dict1 = new Dictionary<int, string>();
//dict1.Add(10, "Hallo");
//dict1.Add(20, "Ciao");
//dict1.Add(30, "Moin");
//Console.WriteLine(dict1[20]);
//foreach (var item in dict1)
//{
// Console.WriteLine(item.Key + ": " + item.Value);
//}
#endregion
#region Lab07 - Zufällige Fahrzeuglisten
////Variablendeklaration und -initialisierung
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
//Random generator = new Random();
//int AnzahlFz = 100000;
////Schleife zur Zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFz; i++)
//{
// switch (generator.Next(1, 4))
// {
// case 1:
// fzQueue.Enqueue(new PKW("BMW", 260, 30000, PKW.PKWTreibstoff.Benzin));
// fzStack.Push(new PKW("BMW", 260, 30000, PKW.PKWTreibstoff.Benzin));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff("Titanic", 60, 26000000, 900));
// fzStack.Push(new Schiff("Titanic", 60, 26000000, 900));
// break;
// case 3:
// fzQueue.Enqueue(new Flugzeug("Boing", 980, 6000000, 10050));
// fzStack.Push(new Flugzeug("Boing", 980, 6000000, 10050));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFz; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
#region Modul10 - Serialisierung und Abspeichern von Fahrzeugen
//List<Fahrzeug> listeZumAbspeichern = new List<Fahrzeug>();
//listeZumAbspeichern.Add(new PKW("BMW", 290, 36000, PKW.PKWTreibstoff.Benzin));
//listeZumAbspeichern.Add(new Flugzeug("Boing", 3000, 2600000, 9999));
//listeZumAbspeichern.Add(new Schiff("Titanic", 60, 6000000, 900));
//Fahrzeug.SpeichereFz(listeZumAbspeichern);
//List<Fahrzeug> geladeneFahrzeugListe = Fahrzeug.LadeFz();
//foreach (var item in geladeneFahrzeugListe)
//{
// Console.WriteLine(item);
//}
#endregion
#region Zusätzliches
//Vorbereitung
Random generator = new Random();
Flugzeug fz = new Flugzeug("Boing", 999, 500000000, 9999);
Flugzeug fz2 = fz;
fz.Passagierliste.Add("Hugo");
fz.Passagierliste.Add("Anna");
fz.Passagierliste.Add("Otto");
//Bsp für die Verwendung der Indexer-Property (siehe Fahrzeugpark.Flugzeug)
Console.WriteLine(fz[2]);
//Bsp für die Verwendung von IEnumerable (siehe Fahrzeugpark.Flugzeug)
foreach (var item in fz)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung von eigenen definierten Operatoren (siehe Fahrzeugpark.Fahrzeug)
Console.WriteLine(fz == fz2);
Console.WriteLine(fz == new Flugzeug("Boing", 999, 500000000, 9999));
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
Console.WriteLine(generator.NextInclusive(12, 45));
#endregion
//Programmpause
Console.ReadKey();
}
static void Main(string[] args)
{
//Ändern des durch COnsole verwendeten Zeichensatzes auf Unicode (damit das €-Zeichen angezeigt werden kann)
Console.OutputEncoding = Encoding.UTF8;
#region Modul4: OOP
////Instanziierung der Fahrzeuge
//Fahrzeug fz1 = new Fahrzeug("BMW", 200);
//Fahrzeug fz2 = new Fahrzeug("BMW", 200);
////Ausgabe von fz1
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
////Veränderung des Namens von fz1
//fz1.Name = "VW";
////Ausgabe der Fahrzeugeigenschaften (fz1 wurde verändert, fz2 nicht)
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
//Console.WriteLine(fz2.Name + ": " + fz2.MaxGeschwindigkeit + "km/h");
////A8sgabe der BeschreibeMich-Methode von fz1
//Console.WriteLine(fz1.BeschreibeMich());
////Neuzuweisung der fz2-Variable auf Objekt in fz1 (beide Variablen zeigen auf dasselbe Objekt)
//fz2 = fz1;
////manueller Aufruf der GarbageCollection
//GC.Collect();
#endregion
#region Lab04 Fahrzeug_Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Lab05 PKW-, Schiff- und Flugzeug-Klasse
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Console.WriteLine(pkw1.BeschreibeMich());
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//Console.WriteLine(schiff1.BeschreibeMich());
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1.BeschreibeMich());
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Modul06 Polymorphismus
//PKW pkw1 = new PKW("BMW", 260, 30000, 3);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 990, 30000000, 8990);
//pkw1.Crash();
//Fahrzeug fz1;
//IBewegbar bewegbaresObjekt;
//fz1 = flugzeug1;
//fz1.Beschleunige(2);
//fz1 = pkw1;
//bewegbaresObjekt = pkw1;
//bewegbaresObjekt.AnzahlRaeder = 5;
//if(bewegbaresObjekt is Flugzeug)
// flugzeug1 = (Flugzeug)bewegbaresObjekt;
#endregion
#region Lab06 IBeladbar
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Modul07 Generische Listen
////Deklaration und Initialisierung einer Liste von Strings
//List<string> Staedteliste = new List<string>();
////Ausgabe der Länge der LIste
//Console.WriteLine(Staedteliste.Count);
////Hinzufügen von Listeneinträgen
//Staedteliste.Add("Frankfurt");
//Staedteliste.Add("Berlin");
//Staedteliste.Add("Köln");
//Staedteliste.Add("München");
//Staedteliste.Add("Hamburg");
//Console.WriteLine(Staedteliste.Count);
////Ausgabe der 4. Listenposition
//Console.WriteLine(Staedteliste[3]);
////Manipulation der 4. Listenposition
//Staedteliste[3] = "Dresden";
////Schleife über die Liste
//foreach (var item in Staedteliste)
//{
// Console.WriteLine(item);
//}
////Löschen des Eintrags 'Köln' (Nachfolgende Einträge rücken nach oben)
//Staedteliste.Remove("Köln");
////Deklaration und Initialisierung eines Dictionarys (Key: Int, Value: String)
//Dictionary<int, string> Dict = new Dictionary<int, string>();
////Hinzufügen von Dictionary-Einträgen
//Dict.Add(1, "Hallo");
//Dict.Add(5, "Moin");
//Dict.Add(15, "Servus");
////Ausgabe des Eintrags mit Key '5'
//Console.WriteLine(Dict[5]);
////Schleife über Dictionary
//foreach (KeyValuePair<int, string> item in Dict)
//{
// Console.WriteLine($"{item.Key}: {item.Value}");
//}
////Deklaration und Initialisierung eines Hastables
//Hashtable ht = new Hashtable();
////Hinzufügen von Einträgen
//ht.Add("Hallo", "Tschüss");
//ht.Add(45, "Moin");
#endregion
#region Lab07 ZufälligeFahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 10000;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
//Erstellung von Bsp-Objekten
Fahrzeug fz1 = new PKW("BMW", 250, 30000, 4);
Fahrzeug fz2 = fz1;
Flugzeug flugzeug1 = new Flugzeug("Boing", 890, 3000000, 9999);
//Bsp für die Verwendung der in der Fahrzeug-Klasse definierten Operatoren
Console.WriteLine(fz1 == fz2);
Console.WriteLine(fz1 == flugzeug1);
//Bsp für die Verwendung von IEnumerable
foreach (var item in flugzeug1)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung der Indexer-Property
Console.WriteLine(flugzeug1[2]);
Random gene = new Random();
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
Console.WriteLine(gene.NextInclusive(1, 5));
Console.ReadKey();
}
static void Main(string[] args)
{
#region Polymorphie Beispiel
Flugzeug flugzeug = new Flugzeug("Lufthansa", 2001, 500, "blau", 22, 11000);
Flugzeug flugzeug1 = new Flugzeug("Fogger Doppedecker", 1912, 50, "Rot", 10, 2000);
PKW pkw1 = new PKW("Ferrarie", 1955, 220, "Rot", 2, 4);
PKW pkw2 = new PKW("Trappi", 1955, 80, "Mausegrau", 4, 4);
PKW pkw3 = new PKW("Mercedez", 2020, 260, "Schwarz", 4, 4);
Schiff schiff = new Schiff("Gorck Fork", 1867, 15, Schiff.SchiffsTreibstoff.Wind, 5);
Yacht yacht = new Yacht("Jeanneau", 1999, 18, Schiff.SchiffsTreibstoff.Diesel, 2, true);
Yacht yacht1 = new Yacht("Black Pearl", 1788, 25, Schiff.SchiffsTreibstoff.Wind, 2, false);
Garage dagobertsGarage = new Garage();
dagobertsGarage.ParkeFahrzeugInGarage(flugzeug);
dagobertsGarage.ParkeFahrzeugInGarage(flugzeug1);
dagobertsGarage.ParkeFahrzeugInGarage(pkw1);
dagobertsGarage.ParkeFahrzeugInGarage(pkw2);
dagobertsGarage.ParkeFahrzeugInGarage(pkw3);
dagobertsGarage.ParkeFahrzeugInGarage(schiff);
dagobertsGarage.ParkeFahrzeugInGarage(yacht);
dagobertsGarage.ParkeFahrzeugInGarage(yacht1);
//Zeige mir mein Inventar der Garage an
dagobertsGarage.WelcheFahrzeugeSindInDerGarage();
dagobertsGarage.DoppeleAlleFahrzeugeDieEsKoennen();
dagobertsGarage.WelcheFahrzeugeSindInDerGarage();
Console.ReadKey();
#endregion
#region Hallo Lambda
List <PKW> pkwListe = new List <PKW>();
pkwListe.Add(pkw1);
pkwListe.Add(pkw2);
pkwListe.Add(pkw3);
pkwListe.Add(new PKW("BMW", 2001, 180, "grau", 3, 3));
pkwListe.Add(new PKW("BMW", 2002, 222, "rot", 4, 4));
pkwListe.Add(new PKW("Mercedez", 2019, 300, "blau", 4, 4));
List <PKW> filterdList = pkwListe.Where(n => n.AnzahlTueren == 4).ToList();
//Labda benutzt das Fluent-Pattern: .LambdaMethode(n=>n.IrgendEineProperty==true).LambdaMethode(n=>n.IrgendEineProperty==true);
List <PKW> filterdList1 = pkwListe.Where(n => n.Marke == "Mercedez" && n.MaxGeschwindigkeit > 100).OrderBy(n => n.Baujahr).ToList();
//PKW resultPKW = pkwListe.Single(n => n.ID == "IregendeineGuid");
//if (resultPKW != null)
//{
// if (resultPKW.ID != Guid.Empty)
// {
// }
//}
#endregion
#region Exception Benutzen
//https://docs.microsoft.com/de-de/dotnet/standard/exceptions/best-practices-for-exceptions
try
{
Console.Write("Eingabe>");
string eingabe = Console.ReadLine();
int a = int.Parse(eingabe);
throw new MeineException();
}
catch (FormatException ex)
{
Console.WriteLine("Du musst eine Zahl eingeben.\n" + ex.Message);
throw;
}
catch (OverflowException ex)
{
Console.WriteLine("Deine Zahl ist zu groß/klein.");
}
catch (MeineException ex)
{
throw;
}
catch (Exception ex)
{
Console.WriteLine("Ein unbekannter Fehler ist aufgetreten");
}
finally
{
Console.WriteLine("Wird immer ausgeführt");
}
StreamWriter sw = null;
try
{
sw = new StreamWriter("zahlen.txt");
for (int i = 0; i < 100; i++)
{
sw.WriteLine(i);
if (i < 50)
{
continue;
}
Console.WriteLine(i);
}
}
catch (Exception ex)
{
//Logdatei beschreiben
throw;
}
finally
{
sw.Close();
}
#endregion
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
#region Modul04 - OOP-Programmierung
////Instanzierung von Fahrzeugen
//Fahrzeug fz = new Fahrzeug("BMW", 270);
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 310);
////Ausgabe der Maximalgeschwindigkeit von fz
//Console.WriteLine(fz.MaxGeschwindigkeit);
////Änderung des Namens von fz1
//fz.Name = "VW";
////Ausgabe der BeschreibeMich()-Methoden der Fahrzeuge
//Console.WriteLine(fz.BeschreibeMich());
//Console.WriteLine(fz1.BeschreibeMich());
////Neuzuweisung der fz1-Variable auf Objekt in fz-Variable
//fz1 = fz;
////Manueller Aufruf der Garbage Collection
//GC.Collect();
#endregion
#region Lab04 - Fahrzeug-Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Modul05 - Vererbung
//PKW pkw1 = new PKW("BMW", 190, 23000);
//Console.WriteLine(pkw1.BeschreibeMich());
//Console.WriteLine(pkw1);
//Console.WriteLine(Fahrzeug.AnzahlFahrzeuge);
#endregion
#region Lab05 - PKW-, Schiff- und Flugzeug-Klasse
//PKW pkw1 = new PKW("BMW", 250, 23000);
//Console.WriteLine(pkw1.BeschreibeMich());
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//Console.WriteLine(schiff1.BeschreibeMich());
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1.BeschreibeMich());
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Modul06 - Polymorphismus
//PKW pkw = new PKW("BMW", 200, 24000);
//Fahrzeug fahrzeug = pkw;
//IBewegbar bewegbaresObjekt = pkw;
//RadAb(pkw);
#endregion
#region Lab06 IBeladbar
//PKW pkw1 = new PKW("BMW", 250, 23000);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Modul07 - Generische Listen
//PKW pkw1 = new PKW("BMW", 250, 23000);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//List<Fahrzeug> fahrzeugListe = new List<Fahrzeug>();
//fahrzeugListe.Add(pkw1);
//fahrzeugListe.Add(flugzeug1);
//fahrzeugListe.Add(schiff1);
//fahrzeugListe.Add(new PKW("VW", 180, 23999));
//foreach (var item in fahrzeugListe)
//{
// Console.WriteLine(item.Name);
//}
//fahrzeugListe[1].Name = "Airbus";
//Console.WriteLine(fahrzeugListe.Count);
#endregion
#region Lab07 - Zufällige Fahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 10;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
//Vorbereitung
Random generator = new Random();
Flugzeug fz = new Flugzeug("Boing", 999, 500000000, 9999);
Flugzeug fz2 = fz;
Flugzeug flugzeug1 = new Flugzeug("Boing", 980, 3000000000, 9990);
flugzeug1.PassagierListe.Add("Hugo");
flugzeug1.PassagierListe.Add("Anna");
flugzeug1.PassagierListe.Add("Otto");
flugzeug1.PassagierListe.Add("Maria");
//Bsp für die Verwendung der Indexer-Property (vgl. Flugzeug-Klasse)
Console.WriteLine(flugzeug1[2]);
//Bsp für die Verwendung von IEnumerable (vgl. Flugzeug-Klasse)
foreach (var item in flugzeug1)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung der in der Fahrzeug-Klasse definierten Operatoren
Console.WriteLine(fz == fz2);
Console.WriteLine(fz == new Flugzeug("Boing", 999, 500000000, 9999));
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
Console.WriteLine(generator.NextInclusive(12, 45));
//Programmpause
Console.ReadKey();
}
static void Main(string[] args)
{
//Ändern des durch Console verwendeten Zeichensatzes auf Unicode (damit das €-Zeichen angezeigt werden kann)
Console.OutputEncoding = Encoding.UTF8;
#region Modul04: OOP
////Instanzierung der Fahrzeuge
//Fahrzeug fz1 = new Fahrzeug("BMW", 200);
//Fahrzeug fz2 = new Fahrzeug("Audi", 180);
////Ausgabe von fz1
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
////Veränderung des Namens von fz1
//fz1.Name = "Opel";
////Ausgabe der Fahrzeugeigenschaften (fz1 wurde verändert, fz2 nicht)
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
//Console.WriteLine(fz2.Name + ": " + fz2.MaxGeschwindigkeit + "km/h");
////Ausgabe der BeschreibeMich-Methode von fz1
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Lab04: Fahrzeug_Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich() + "\n");
////Diverse Methodenausführungen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich() + "\n");
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich() + "\n");
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich() + "\n");
#endregion
#region Modul05: Vererbung
//PKW pkw1 = new PKW("BMW", 210, 26000, 5);
//Console.WriteLine(pkw1.BeschreibeMich());
//Console.WriteLine(pkw1);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//pkw1 = new PKW("BMW", 210, 26000, 5);
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Lab05: PKW-, Schiff- und Flugzeug-Klasse
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Console.WriteLine(pkw1.BeschreibeMich());
//pkw1.Hupe();
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//Console.WriteLine(schiff1.BeschreibeMich());
//schiff1.Hupe();
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1.BeschreibeMich());
//flugzeug1.Hupe();
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Modul06: Interfaces und Polymorphismus
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Fahrzeug fz1 = pkw1;
//IBewegbar bewegbaresObjekt = pkw1;
//bewegbaresObjekt.Crash();
//MontiereNeuesRad(pkw1);
//BenenneFahrzeugUm("Opel", pkw1);
#endregion
#region Lab06: IBeladbar
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
//schiff1.Entlade();
#endregion
#region Modul07: Generische Listen
////Deklaration und Initialisierung einer Liste von Strings
//System.Collections.Generic.List<string> Städteliste = new List<string>();
////Hinzufügen von Listeneinträgen
//Städteliste.Add("Berlin");
//Städteliste.Add("Hamburg");
//Städteliste.Add("München");
//Städteliste.Add("Köln");
//Städteliste.Add("Düsseldorf");
////Ausgabe der Länge der Liste
//Console.WriteLine(Städteliste.Count);
////Ausgabe der 4. Listenposition
//Console.WriteLine(Städteliste[3]);
////Manipulation der 5. Listenposition
//Städteliste[4] = "Dresden";
//Console.WriteLine(Städteliste[4]);
////Schleife über die Liste
//foreach (var stadt in Städteliste)
//{
// Console.WriteLine(stadt);
//}
////Löschen des Eintrags 'München' (Nachfolgende Einträge rücken nach oben)
//Städteliste.Remove("München");
//List<Fahrzeug> Fahrzeugliste = new List<Fahrzeug>();
//Fahrzeugliste.Add(new PKW("BMW", 250, 23000, 5));
//Fahrzeugliste.Add(new Flugzeug("Boing", 750, 3000000, 9990));
//Fahrzeugliste.Add(new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
//foreach (var fz in Fahrzeugliste)
//{
// Console.WriteLine(fz.BeschreibeMich());
//}
////Deklaration und Initialisierung eines Dictionarys (Key: String, Value: Int)
//Dictionary<string, int> Einwohnerzahlen = new Dictionary<string, int>();
////Hinzufügen von Dictionary-Einträgen
//Einwohnerzahlen.Add("Berlin", 3500000);
//Einwohnerzahlen.Add("Hamburg", 2500000);
//Einwohnerzahlen.Add("Leipzig", 60000);
////Ausgabe des Eintrags mit Key 'Leipzig'
//Console.WriteLine(Einwohnerzahlen["Leipzig"]);
////Ändern des Eintrags mit dem Key 'Leipzig'
//Einwohnerzahlen["Leipzig"] = 70000;
////Schleife über Dictionary
//foreach (var item in Einwohnerzahlen)
//{
// Console.WriteLine(item.Key + ": " +item.Value);
//}
//Dictionary<string, Fahrzeug> Dict2 = new Dictionary<string, Fahrzeug>();
//Dict2.Add("Hugo", new PKW("BMW", 250, 23000, 5));
//Dict2.Add("Anna", new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
//Console.WriteLine(Dict2["Anna"].BeschreibeMich());
//Dictionary<Fahrzeug, List<string>> Passagiere = new Dictionary<Fahrzeug, List<string>>();
//Passagiere.Add(new PKW("BMW", 250, 23000, 5), Städteliste);
////Deklaration und Initialisierung eines Hastables + Erstellung und Abruf von Einträgen (nicht-genereisches Dictionary nach dem Hash-Speicherprinzip)
//Hashtable ht = new Hashtable();
//ht.Add("Hallo", 450);
//ht.Add(78.5, new PKW("VW", 260, 250020, 4));
//Console.WriteLine(ht["Hallo"]);
////Deklaration und Initialisierung eines HashSets (generische Liste nach dem Hash-Speicherprinzip)
//HashSet<int> hs = new HashSet<int>();
//hs.Add(23);
#endregion
#region Lab07 ZufälligeFahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 1000;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Erzwingen eines Durchlaufs der GarbageCollcetion (Löscht alle nicht-referenzierten Objekte aus dem RAM)
//GC.Collect();
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
//Erstellung von Bsp-Objekten
PKW pkw1 = PKW.ErzeugeZufälligenPKW("");
PKW pkw2 = PKW.ErzeugeZufälligenPKW("");
//Ausgabe der ToString-Funktion des PKWs (wird in Fahrzeugklasse überschrieben)
Console.WriteLine(pkw1);
//Bsp für die Verwendung der in der Fahrzeug-Klasse definierten Operatoren (vgl. Fahrzeugpark.Fahrzeug)
Console.WriteLine(pkw1 == pkw2);
Console.WriteLine(pkw1 == pkw1);
Flugzeug flug1 = new Flugzeug($"Boing", 800, 3600000, 9999);
//Bsp für die Verwendung von IEnumerable (vgl. Fahrzeugpark.Flugzeug)
foreach (var item in flug1)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung der Indexer-Property (vgl. Fahrzeugpark.Flugzeug)
Console.WriteLine(flug1[2]);
Random gene = new Random();
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
gene.NextInclusive(1, 10);
}
static void Main(string[] args)
{
//Ändern des durch Console verwendeten Zeichensatzes auf Unicode (damit das €-Zeichen angezeigt werden kann)
Console.OutputEncoding = Encoding.UTF8;
#region Modul04: OOP
////Instanzierung der Fahrzeuge
////volle Pfadangabe bei Objekt/Variablenaufruf
//Fahrzeugpark.Fahrzeug fz1 = new Fahrzeugpark.Fahrzeug("BMW", 250);
////Benutzung der using-Anweisung
//Fahrzeug fz2 = new Fahrzeug("VW", 190);
//Aufruf des paraeterlosen Konstruktors
//Fahrzeug fz3 = new Fahrzeug();
////Ausgabe von fz1
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
////Veränderung des Namens von fz1
//fz1.Name = "Opel";
////Ausgabe der Fahrzeugeigenschaften (fz1 wurde verändert, fz2 nicht)
//Console.WriteLine(fz1.Name + ": " + fz1.MaxGeschwindigkeit + "km/h");
//Console.WriteLine(fz2.Name + ": " + fz2.MaxGeschwindigkeit + "km/h");
////Ausgabe der BeschreibeMich-Methode von fz1
//Console.WriteLine(fz1.BeschreibeMich());
////Neuzuweisung der fz2-Variable auf Objekt in fz1 (beide Variablen zeigen auf dasselbe Objekt)
//fz2 = fz1;
////manueller Aufruf der GarbageCollection
//GC.Collect();
#endregion
#region Lab04: Fahrzeug_Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich());
#endregion
#region Modul05: Vererbung
////Bsp-Objekt-Instanzierung
//PKW pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
//pkw1 = new PKW("BMW", 190, 23000, 4);
////Aufruf der ToString()-Methode
//Console.WriteLine(pkw1);
////Aufruf der Hupe()-Methode
//pkw1.Hupe();
////Ausgabe von statischer Eingenschaft/Methode
//Console.WriteLine(Fahrzeug.AnzahlErstellterFahrzeuge);
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Lab05: PKW-, Schiff- und Flugzeug-Klasse
////Instanzierung eines Bsp-PKWs
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Console.WriteLine(pkw1.BeschreibeMich());
//pkw1.Hupe();
////Instanzierung eines Bsp-Schiffs
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//Console.WriteLine(schiff1.BeschreibeMich());
//schiff1.Hupe();
////Instanzierung eines Bsp-Flugzeugs
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1.BeschreibeMich());
//flugzeug1.Hupe();
////Ausgabe der statischen Methode der Fahrzeugklasse
//Console.WriteLine(Fahrzeug.ZeigeAnzahlFahrzeuge());
#endregion
#region Modul06: Interfaces und Polymorphismus
////Instanzierung von Bsp-Objekt
//PKW pkw1 = new PKW("BMW", 190, 23000, 4);
////Aufruf der Interface-Methode
//pkw1.Crash();
////Zuweisung neuer Variablen (anderer Variablentyp) mit dem PKW-Objekt
////-> Variablentyp definiert 'Sichtbarkeit' der Eigenschaften
//Fahrzeug fz1 = pkw1;
//IBewegbar bewegbaresObjekt = pkw1;
////BSP: Variablentyp = Fahrzeug | Laufzeittyp (= Typ des Objekts) = PKW
//Fahrzeug fz2 = new PKW("VW", 190, 25000, 3);
////Prüdung, ob in Fahrzeug-Variable ein PKW-Objekt liegt...
//if (fz2 is PKW)
//{
// //... wenn ja, dann Cast in PKW und Zuweisung zu PKW-Variable
// PKW pkw2 = (PKW)fz2;
//}
////Aufruf der BSP-Funktion (s.u.)
//MontiereNeuesRad(pkw1);
#endregion
#region Lab06: IBeladbar
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Modul07: Generische Listen
////Deklaration und Initialisierung einer Liste von Strings
//List<string> Städteliste = new List<string>();
////Hinzufügen von Listeneinträgen
//Städteliste.Add("Berlin");
//Städteliste.Add("Köln");
//Städteliste.Add("Hamburg");
//Städteliste.Add("Nürnberg");
//Städteliste.Add("München");
////Ausgabe der Länge der Liste
//Console.WriteLine(Städteliste.Count);
////Ausgabe der 3. Listenposition
//Console.WriteLine(Städteliste[2]);
////Manipulation der 3. Listenposition
//Staedteliste[2] = "Dresden";
//Console.WriteLine(Staedteliste[2]);
////Schleife über die Liste
//foreach (var item in Städteliste)
//{
// Console.WriteLine(item);
//}
////Löschen des Eintrags 'Köln' (Nachfolgende Einträge rücken nach oben)
//Staedteliste.Remove("Köln");
////Bsp für Fahrzeug-Liste
//List<Fahrzeug> Fahrzeugliste = new List<Fahrzeug>();
//Fahrzeugliste.Add(new PKW("BMW", 190, 23000, 4));
//Fahrzeugliste.Add(new PKW("BMW", 190, 23000, 4));
//Fahrzeugliste.Add(new PKW("BMW", 190, 23000, 4));
//Fahrzeugliste.Add(new PKW("BMW", 190, 23000, 4));
//Fahrzeugliste.Add(new PKW("BMW", 190, 23000, 4));
//foreach (var item in Fahrzeugliste)
//{
// Console.WriteLine(item);
//}
//Fahrzeugliste.RemoveAt(3);
////Deklaration und Initialisierung eines Dictionarys (Key: Int, Value: String)
//Dictionary<int, string> Dict = new Dictionary<int, string>();
////Hinzufügen von Dictionary-Einträgen
//Dict.Add(1, "Hallo");
//Dict.Add(202, "Ciao");
//Dict.Add(3185, "Hi");
////Ausgabe des Eintrags mit Key '202'
//Console.WriteLine(Dict[202]);
////Deklaration und Initialisierung eines Hastables + Erstellung und Abruf von Einträgen (nicht-genereisches Dictionary nach dem Hash-Speicherprinzip)
//Hashtable ht = new Hashtable();
//ht.Add("Hallo", 450);
//ht.Add(78.5, new PKW("VW", 260, 250020, 4));
//Console.WriteLine(ht["Hallo"]);
////Schleife über Dictionary
//foreach (var item in Dictionary1)
//{
// Console.WriteLine(item.Key + ": " + item.Value);
//}
////Deklaration und Initialisierung eines Hastables + Erstellung und Abruf von Einträgen (nicht-genereisches Dictionary nach dem Hash-Speicherprinzip)
//Hashtable ht = new Hashtable();
//ht.Add("Hallo", 450);
//ht.Add(78.5, new PKW("VW", 260, 250020, 4));
//Console.WriteLine(ht["Hallo"]);
////Deklaration und Initialisierung eines HashSets (generische Liste nach dem Hash-Speicherprinzip)
//HashSet<int> hs = new HashSet<int>();
//hs.Add(23);
#endregion
#region Lab07 ZufälligeFahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 10000;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.SchiffsTreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
//Erstellung von Bsp-Objekten
PKW pkw1 = PKW.ErzeugeZufälligenPKW("");
PKW pkw2 = PKW.ErzeugeZufälligenPKW("");
pkw2.Name = pkw1.Name;
Console.WriteLine(pkw1.Name);
Console.WriteLine(pkw2.Name);
//Bsp für die Verwendung der in der Fahrzeug-Klasse definierten Operatoren
Console.WriteLine(pkw1 == pkw2);
Console.WriteLine(pkw1 != pkw2);
Flugzeug flug1 = new Flugzeug("Boing", 800, 30000000, 9999);
//Bsp für die Verwendung von IEnumerable
foreach (var item in flug1)
{
Console.WriteLine(item);
}
//Bsp für die Verwendung der Indexer-Property
Console.WriteLine(flug1[2]);
Random gene = new Random();
//Bsp für die Verwendung einer Erweiterungsmethode (s.u.)
Console.WriteLine(gene.NextInclusive(1, 5));
Console.ReadKey();
}
static void Main(string[] args)
{
#region Klassen & static
Console.WriteLine("\n ### Klassen & statische Methoden ###");
Class1 class1 = new Class1();
class1.Void();
Class1.StaticVoid();
#endregion
#region Polymorphismus
Console.WriteLine("\n ### Fahrrad & Polymorphismus ###");
Transportmittel fahrrad1 = new Fahrrad("Nextbike", 400.00, 50, 2, 0);
Fahrrad fahrrad2 = new Fahrrad("Lidlbike", 300.00, 45, 2, 0);
Console.WriteLine("\n # Overrides #");
Console.WriteLine(fahrrad1.BeschreibeMich());
Console.WriteLine(fahrrad2.BeschreibeMich());
Console.WriteLine("\n # Overloads #");
fahrrad1.Beschleunigen(5);
fahrrad2.Beschleunigen(5);
#endregion
#region Interfaces
Console.WriteLine("\n # Interfaces & Klassenverschachtelung #");
bool kannBeladenWerden;
kannBeladenWerden = FahrzeugBeladen(new Schiff("Marina", 200000.00, 300, Schiff.SchiffsTreibstoff.Diesel), new PKW("BMW", 20000.00, 250, 5, 4, 2000));
Console.WriteLine($"Können Schiffe PKWs transportieren?: {kannBeladenWerden}");
kannBeladenWerden = FahrzeugBeladen(new Fahrrad("Fordbike", 5000.00, 60, 2, 4444), new PKW("BMW", 20000.00, 250, 5, 4, 2000));
Console.WriteLine($"Können Fahrräder PKWs transportieren?: {kannBeladenWerden}");
#endregion
#region Generics
Console.WriteLine("\n ### Generische Datenstrukturen ###");
Queue <Transportmittel> FahrzeugSchlange = new Queue <Transportmittel>();
Stack <Transportmittel> FahrzeugStack = new Stack <Transportmittel>();
Dictionary <Transportmittel, Transportmittel> FahrzeugDictionary = new Dictionary <Transportmittel, Transportmittel>();
Random random = new Random();
//FahrzeugSchlange und Stack mit 10 zufällig erzeugten Fahrzeugtypen befüllen
for (int i = 0; i < 10; i++)
{
Transportmittel neuesFahrzeug = null;
switch ((Fahrzeugtypen)random.Next(3))
{
case Fahrzeugtypen.Flugzeug: neuesFahrzeug = new Flugzeug("Boing 474", 10000000, 800, 200, 6, 0); break;
case Fahrzeugtypen.PKW: neuesFahrzeug = new PKW("Opel Astra", 20000, 190, 4, 4, 0); break;
case Fahrzeugtypen.Schiff: neuesFahrzeug = new Schiff("Titanik", 100000000, 200, Schiff.SchiffsTreibstoff.Dampf); break;
default: Console.WriteLine("Ungültiger Flugzeugtyp!"); break;
}
if (neuesFahrzeug != null)
{
FahrzeugSchlange.Enqueue(neuesFahrzeug);
FahrzeugStack.Push(neuesFahrzeug);
}
}
//Namen der FahrzeugSchlangen-Elemente ausgeben
foreach (var item in FahrzeugSchlange)
{
Console.WriteLine(item);
}
Console.WriteLine("----------------");
//Namen der FahrzeugStack-Elemente ausgeben
foreach (var item in FahrzeugStack)
{
Console.WriteLine(item);
}
Console.WriteLine("----------------");
for (int i = 0; i < 10; i++)
{
Transportmittel newElementFromQueue = FahrzeugSchlange.Dequeue();
Transportmittel newElementFromStack = FahrzeugStack.Pop();
if (FahrzeugBeladen(newElementFromQueue, newElementFromStack))
{
FahrzeugDictionary.Add(newElementFromQueue, newElementFromStack);
}
}
Console.WriteLine("----------------");
foreach (var item in FahrzeugDictionary)
{
Console.WriteLine($"Beladbares Objekt {item.Key} hat {item.Value} beladen.");
}
#endregion
Console.ReadKey();
}
static void Main(string[] args)
{
#region Modul04_OOP-Klassen
//Fahrzeug fahrzeug1 = new Fahrzeug("BMW", 260);
//Console.WriteLine(fahrzeug1.BeschreibeMich());
//Fahrzeug fahrzeug2 = new Fahrzeug("VW", 240);
//Console.WriteLine(fahrzeug2.BeschreibeMich());
//fahrzeug2.MaxGeschwindigkeit = 310;
//Console.WriteLine(fahrzeug2.BeschreibeMich());
//Console.WriteLine(fahrzeug1.BeschreibeMich());
#endregion
#region Lab04_Fahrzeug-Klasse
////Deklaration einer Fahrzeug-Variablen und Initialisierung mittels einer Fahrzeug-Instanz
//Fahrzeug fz1 = new Fahrzeug("Mercedes", 190, 23000);
////Ausführen der BeschreibeMich()-Methode des Fahrzeugs und Ausgabe in der Konsole
//Console.WriteLine(fz1.BeschreibeMich());
////Diverse Methodenausführungen
//fz1.StarteMotor();
//fz1.Beschleunige(120);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.Beschleunige(300);
//Console.WriteLine(fz1.BeschreibeMich());
//fz1.StoppeMotor();
//Console.WriteLine(fz1.BeschreibeMich());
////Neubelegung der Fahrzeug-Variablen
//fz1 = new Fahrzeug("BMW", 250, 26000);
//Console.WriteLine(fz1.BeschreibeMich());
////Manueller Aufruf der Garbage-Collection
//GC.Collect();
#endregion
#region Modul/Lab05_Vererbung
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Console.WriteLine(pkw1);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.Schiffstreibstoff.Dampf);
//Console.WriteLine(schiff1);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Console.WriteLine(flugzeug1);
//Console.WriteLine(Fahrzeug.ZähleFahrzeuge());
#endregion
#region Modul06_Interfaces und Polymorphismus
//PKW pkw1 = new PKW("BMW", 260, 36000, 5);
//pkw1.AnzahlTüren = 3;
//Fahrzeug fahrzeug1 = pkw1;
//fahrzeug1.Hupe();
//IBewegbar bewegbaresObjekt = pkw1;
//bewegbaresObjekt.BaueUnfall();
//RadAb(pkw1);
#endregion
#region Lab06_IBeladbar
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.Schiffstreibstoff.Dampf);
//BeladeFahrzeuge(pkw1, flugzeug1);
//BeladeFahrzeuge(flugzeug1, schiff1);
//BeladeFahrzeuge(schiff1, pkw1);
//Console.WriteLine("\n" + schiff1.BeschreibeMich());
#endregion
#region Modul07_Generische Listen
//PKW pkw1 = new PKW("BMW", 250, 23000, 5);
//Flugzeug flugzeug1 = new Flugzeug("Boing", 750, 3000000, 9990);
//Schiff schiff1 = new Schiff("Titanic", 40, 3500000, Schiff.Schiffstreibstoff.Dampf);
//List<Fahrzeug> fzListe = new List<Fahrzeug>() { pkw1, schiff1 };
//fzListe.Add(pkw1);
//fzListe.Add(flugzeug1);
//fzListe.Add(schiff1);
//Console.WriteLine(fzListe.Count);
//for (int i = 0; i < fzListe.Count; i++)
//{
// Console.WriteLine(fzListe[i].Name);
//}
#endregion
#region Lab07_Zufällige Fahrzeuglisten
////Deklaration der benötigten Variablen und und Initialisierung mit Instanzen der benötigten Objekte
//Random generator = new Random();
//Queue<Fahrzeug> fzQueue = new Queue<Fahrzeug>();
//Stack<Fahrzeug> fzStack = new Stack<Fahrzeug>();
//Dictionary<Fahrzeug, Fahrzeug> fzDict = new Dictionary<Fahrzeug, Fahrzeug>();
////Deklaration und Initialisierung einer Variablen zur Bestimmung der Anzahl der Durchläufe
//int AnzahlFZs = 30;
////Schleife zur zufälligen Befüllung von Queue und Stack
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Würfeln einer zufälligen Zahl im Switch
// switch (generator.Next(1, 4))
// {
// //Erzeugung von Objekten je nach zufälliger Zahl
// case 1:
// fzQueue.Enqueue(new Flugzeug($"Boing_Q{i}", 800, 3600000, 9999));
// fzStack.Push(new Flugzeug($"Boing_S{i}", 800, 3600000, 9999));
// break;
// case 2:
// fzQueue.Enqueue(new Schiff($"Titanic_Q{i}", 40, 3500000, Schiff.Schiffstreibstoff.Dampf));
// fzStack.Push(new Schiff($"Titanic_S{i}", 40, 3500000, Schiff.Schiffstreibstoff.Dampf));
// break;
// case 3:
// fzQueue.Enqueue(PKW.ErzeugeZufälligenPKW($"_Q{i}"));
// fzStack.Push(PKW.ErzeugeZufälligenPKW($"_S{i}"));
// break;
// }
//}
////Schleife zur Prüfung auf das Interface und Befüllung des Dictionaries
//for (int i = 0; i < AnzahlFZs; i++)
//{
// //Prüfung, ob das Interface vorhanden ist (mittels Peek(), da die Objekte noch benötigt werden)...
// if (fzQueue.Peek() is IBeladbar)
// {
// //...wenn ja, dann Cast in das Interface und Ausführung der Belade()-Methode (mittels Peek())...
// ((IBeladbar)fzQueue.Peek()).Belade(fzStack.Peek());
// //...sowie Hinzufügen zum Dictionary (mittels Pop()/Dequeue(), um beim nächsten Durchlauf andere Objekte an den Spitzen zu haben)
// fzDict.Add(fzQueue.Dequeue(), fzStack.Pop());
// }
// else
// {
// //... wenn nein, dann Löschung der obersten Objekte (mittels Pop()/Dequeue())
// fzQueue.Dequeue();
// fzStack.Pop();
// }
//}
////Programmpause
//Console.ReadKey();
//Console.WriteLine("\n----------LADELISTE----------");
////Schleife zur Ausgabe des Dictionaries
//foreach (var item in fzDict)
//{
// Console.WriteLine($"'{item.Key.Name}' hat '{item.Value.Name}' geladen.");
//}
#endregion
//Ausgabe eines durch eine Formatangabe und Kulturänderung manipulierten Strings
Console.WriteLine(565656.05.ToString("C", CultureInfo.CreateSpecificCulture("en-US")));
//Änderung der Anzeige-Kultur der Applikation
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
//Bsp für eine Anwendung des IEnumerable-Interfaces (vgl. Flugzeug)
Flugzeug zeug = new Flugzeug("Boing", 990, 36000000, 9990);
foreach (var item in zeug)
{
Console.WriteLine(item);
}
//Bsp für eine Anwendung einer Erweiterungsmethode (s.u.)
Random gene = new Random();
gene.NextInclusive(12, 45);
//Programmpause
Console.ReadKey();
}
