Schnelles Lernen C# für Anfänger

// Die Erklärung der Benutzung von namespace System .
// (d.h alle Klasse ,.. in dieser namespace benutzen können).
using System;

static void Main(string[] args)
{
    // Print text to the console window.
    Console.WriteLine("Hello CSharp");

    // Wait for the user to enter something and press Enter before ending the program.
    Console.ReadLine();
}

// Die Erklärung der Benutzung von System namespace
// (es enthaltet die Klasse Console).
using System;

// Und Sie können die Klasse Console:
Console.WriteLine("Hello CSharp");

// Wenn Sie die Benutzung von System namespace nicht erklären.
// Aber Sie die Klasse Console benutzen möchten, sollen Sie länger schreiben:
System.Console.WriteLine("Hello CSharp");

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace O7planning.CSharp
{
   class MyClass
   {
       static void Main(string[] args)
       {
           Console.WriteLine("Hello from MyClass");
           Console.ReadLine();
       }
   }
}

// Eine Variable erklären
// Data Type: Das Datenstyp
// Variable Name : der Name der Variable .
<Data Type> <Variable name>;

// Eine Variable erklären und die Wert anweisen.
<Data Type> <Variable name> = <value>;

// Die Konstanste erklären (constants)
const <Data Type> <Variable name> = <value>;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class VariableExample
    {   
        static void Main(string[] args)  
        {
            // Eine Konstante mit dem Typ vom int erklären.
            // Sie können die Wert für Konstante anweisen.
            const int MAX_SCORE = 100;

            // Eine Variabel mit dem Typ vom int erklären.
            int score = 0;

            // Die neue Wert für die Variable score anweisen
            score = 90;

            // Ein String erklären (string).
            string studentName = "Tom";

            // Die Wert der Variable auf dem Bildschirm Console ausdrucken.
            Console.WriteLine("Hi {0}", studentName);
            Console.WriteLine("Your score: {0}/{1}", score, MAX_SCORE);

            // Warten darauf, der Benutzer etwas eingibt und drücken auf Enter vor dem Ende des Programm.
            Console.ReadLine();
        }
       

    }
}

// Die Syntax
// condition: Die Bedingung zur Prüfung.
if ( condition )  
{
	// Hier etwas machen.
}

// Zum Beispiel 1:
if ( 5 < 10 )
{
  Console.WriteLine( "Five is now less than ten");
}

// Zum Beispiel 2:
if ( true )
{
  Console.WriteLine( "Do something here");
}

// Achten Sie, dass am meisten ein Befehl implementiert wird
// Das Programm prüft die Bedingungen vom oben nach hinten
// Beim Treffen der richtigen Bedingung wird das Befehl implementiert
// Die restlichen Bedingungen werden ignoriert 
...

// Wenn Condition1 richtig ist, dann  ..
if (condition1 )  
{
	 // Etwas machen wenn condition1 richtig ist (true).
}
// Umgekehrt wenn Condition2 richtig ist, dann ...
else if(condition2 )  
{
	// Hier etwas machen wenn condition2 richtig ist (condition1 ist false).
}
// Umgekehrt wenn conditonN richtig ist, dann ...
else if(conditionN )  
{
	 // Hier etwas machen wenn condition N richtig ist 
	 // (alle Bedingungen oben sind false).
}
// Umgekehrt (wenn alle Bedingungen oben false sind).
else  {
	 // etwas machen.
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class IfElseExample
    {
        static void Main(string[] args)
        {
            // Ein Zahl mit dem Typ von int erklären, die Ihr Alter bezeichnet.
            int age;

            Console.WriteLine("Please enter your age: \n");

            // Eine Variable erklären um die Text vom Benutzer zu speichern.
            string inputStr = Console.ReadLine();

            // Int32  ist eine Klasse in namespace System.
            // Die static Methode Parse der Klasse Int32 benutzen um ein String 
            // zu einer Zahl umzuwandeln und in die Variable age anzuweisen.
            // (Achtung: Wenn 'inputStr' kein Zahlstring ist, kann es den Fehler des Programm hier machen).
            age = Int32.Parse(inputStr);

            Console.WriteLine("Your age: {0}", age);

            // Prüfen, wenn das Alter kleiner als 80 ist, dann ...
            if (age < 80)
            {
                Console.WriteLine("You are pretty young");
            }

            // Umgekehrt wenn das Alter in Raum 80 - 100 liegt, dann ...
            else if (age >= 80 && age <= 100)
            {
                Console.WriteLine("You are old");
            }
            // Umgekehrt (die restlichen Fällen)
            else
            {
                Console.WriteLine("You are verry old");
            }

            Console.ReadLine();
        }
    }
}

// Den Schlüsselwort 'switch' benutzen um die Wert einer Variable zu prüfen.
switch ( <variable> )
{
  case value1:
      // Hier etwas machen wenn die Wert der Variable value1 ist
      break;
  case value2:
      // Hier etwas machen wenn die Wert der Variable value2 ist
      break;

  ...
	
  default:
     // Die restlichen Fällen
     break;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class BreakExample       
    {
        static void Main(string[] args)
        {
            // Vorschlagen, der Benutzer eine Option wählen.
            Console.WriteLine("Please select one option:\n");

            Console.WriteLine("1 - Play a game \n");
            Console.WriteLine("2 - Play music \n");
            Console.WriteLine("3 - Shutdown computer \n");

             
            // Eine Variable Option erklären
            int option;

            // Der vom Benutzer eingegebene String
            string inputStr = Console.ReadLine();

            // String zur integer umwandeln
            option = Int32.Parse(inputStr);

            // Die Wert von 'option' prüfen.
            switch (option)
            {

                case 1:
                    Console.WriteLine("You choose to play the game");
                    break;
                case 2:
                    Console.WriteLine("You choose to play the music");
                    break;
                case 3:
                    Console.WriteLine("You choose to shutdown the computer");
                    break;
                default:
                    Console.WriteLine("Nothing to do...");
                    break;
            }

            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class BreakExample2
    {
        static void Main(string[] args)
        {
            // Die Variable erklären und die Wert 3 anweisen.
            int option = 3;

            Console.WriteLine("Option = {0}", option);

            // Die Wert von 'option' prüfen.
            switch (option)
            {

                case 1:
                    Console.WriteLine("Case 1");
                    break;

                // Falls option = 2,3,4,5, dann mach gleich 
                case 2: 
                case 3: 
                case 4: 
                case 5:
                    Console.WriteLine("Case 2,3,4,5!!!");
                    break;
                default:
                    Console.WriteLine("Nothing to do...");
                    break;
            } 

            Console.ReadLine();
        }
    }
}

// initialize variable: eine Variable initializieren
// condition: Die Bedingung.
// updates new value for variable: die Wert für Variable update.
for (initialize variable ; condition ; updates new value for variable )
{
	// Das Befehlsblock durchführen wenn die Bedingung richtig ist (true).
}

// Zum Beispiel 1:
// Eine Variable  x erstellen und die Wert 0 anweisen.
// Die Prüfungsbedingung ist  x < 5
// Wenn x < 5 richtig ist, wird das Befehl durchgeführt.
// Nach jeder Iteration wird die Wert von x in 1 erhöht.
for (int  x = 0;  x < 5 ; x = x + 1)
{
	// Hier etwa machen wenn x < 5 richtig ist (true).
}


// Zum Beispiel 2:
// Eine Variable  x erstellen und die Wert ist 2.
// Die Prüfungsbedingung ist  x < 15
// Wenn x < 15 richtig ist, wird das Befehl durchgeführt.
// Nach jeder Iteration wird die Wert von x in 3 erhöht.
for (int  x = 2;  x < 15 ; x = x + 3)
{
	// Hier etwa machen wenn x < 15 richtig ist (true).
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ForLoopExample
    {
        static void Main(string[] args)
        {
            Console.WriteLine("For loop example"); 

            // Eine Variable x erstellen und die Wert 2 anweisen
            // Die Bedingung zur Prüfung ist x < 15
            // Wenn x < 15 richtig ist, wird das Befehlsblock implementiert
            // Nach jeder Iteration wird die Wert x automatisch in 3 erhöht.
            for (int x = 2; x < 15; x = x + 3)
            {
                Console.WriteLine( );
                Console.WriteLine("Value of x = {0}", x); 
            } 

            Console.ReadLine();
        }
    }
}

// condition: die Bedingung
while (condition)  
{
	 // Wenn  'condition' richtig ist, wird das Befehlsblock durchgeführt.
}

// Eine Variable x erstellen.
int x = 2;

while ( x < 10)
{
    // Hier etwas machen wenn  x < 10 richtig ist.
    ...
    	
    // Die neue Wert für die Variable x update
    x = x + 3;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class WhileLoopExample
    {
        static void Main(string[] args)
        {
           
            Console.WriteLine("While loop example");
 
            // Eine Variable x erstellen und die Wert 2 anweisen.
            int x = 2;

            // Die Bedingung ist x < 10.
            // Wenn x < 10 richtig ist, wird das Befehl implementiert.
            while (x < 10)
            {
                Console.WriteLine("Value of x = {0}", x);

                x = x + 3; 
            } 

            Console.ReadLine();
        }
    }
}

// Die Eigenschaft von der Schleife 'do-while' ist, 
// dass sie das Befehlsblock mindesten einmal implementiert.
// Nach jeder Iteration prüft sie wieder die Bedingungen.
// Wenn die Bedingung ist richtig, wird das Befehlsblock weiter implementiert.
do {
    // Hier etwas machen.
} while (condition); 
// Achtung: Brauchen Sie das Semikolon (;) hier.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class DoWhileLoopExample
    {
        static void Main(string[] args)
        { 

            Console.WriteLine("Do-While loop example"); 

            // Eine Variable x erstellen und die Wert 2 anweisen
            int x = 2;

            // Das Befehlsblock mindesten einmal implementieren
            // Nach jeder Iteration wird es die Bedingungen wieder prüfen.
            // Wenn die Bedingung richtig ist, wird das Befehl weiter durchgeführt 
            do
            {
                Console.WriteLine("Value of x = {0}", x);

                x = x + 3; 

            } while (x < 10);
            // Achtung: Das Semikolon hier brauchen
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class LoopBreakExample
    {
        static void Main(string[] args)
        { 
            Console.WriteLine("Break example");

            // Eine Variable x erstellen und die Wert 2 anweisen.
            int x = 2;

            while (x < 15)
            {

                Console.WriteLine("----------------------\n");
                Console.WriteLine("x = {0}", x);

                // Prüfen, wenn  x = 5  ist, aus der Schleife austreten.
                if (x == 5)
                {
                    break;
                }
                // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                x++;
                Console.WriteLine("x after ++ = {0}", x);

            }

            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class LoopContinueExample
    {
        static void Main(string[] args)
        { 

            Console.WriteLine("Continue example");

            // Eine Variable x erstellen und die Wert 2 anweisen
            int x = 2;

            while (x < 7)
            {

                Console.WriteLine("----------------------\n");
                Console.WriteLine("x = {0}", x);

                //  Der Operator % ist die Division zur Restaufnahme.
                // Wenn x gerade ist, ignorier die Befehle unter 'continue',
                // und mach die neue Iteration weiter (wenn die Bedingung richtig ist) 
                if (x % 2 == 0)
                {
                    // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                    x++;
                    continue;
                }
                else
                {
                    // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                    x++;
                }
                Console.WriteLine("x after ++ = {0}", x);

            }

            Console.ReadLine();
        }
    }
}

// Way 1:
// Declare an array of int, specifies the elements.
int[] years = { 2001, 2003, 2005, 1980, 2003 };

// Way 2:
// Declare an array of floats, specifying the number of elements.
// (3 elements).
float[] salaries = new float[3];

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayExample1
    {
        static void Main(string[] args)
        {
            // Die Option 1:
            // Ein Array erklären, die Wert für die Element bestimmen.
            int[] years = { 2001, 2003, 2005, 1980, 2003 };

            // Length ist ein Property eines Array. Es gibt die Elemente des Array zurück.
            Console.WriteLine("Element count of array years = {0} \n", years.Length);

            // Die Schleife for benutzen um die Elemente des Array auszudrucken.
            for (int i = 0; i < years.Length; i++) {
                Console.WriteLine("Element at {0} = {1}", i, years[i]);
            }

            // Die Option 2:
            // Ein Array mit 3 Elemente erklären
            float[] salaries = new float[3];

            // Die Wert für die Elemente anweisen.
            salaries[0] = 1000;
            salaries[1] = 1200;
            salaries[2] = 1100;

            Console.ReadLine();
        }
    }
}

// Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären 
// Die Wert für die Elemente bestimmen.
int[,] a =   new int[,]  {
    {1 , 2 , 3,  4,   5} ,
    {0,  3,  4,  5,   7},
    {0,  3,  4,  0,   0}
};

// Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären.
// Die Wert für die Elemente nicht bestimmen
int[,] a = new int[3,5];

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayExample2
    {
        static void Main(string[] args)
        {
            // Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären.
            // Die Wert von Element bestimmen.            
            int[,] a =   { 
                          { 1, 2, 3, 4, 5 },
                          { 0, 3, 4, 5, 7 },
                          { 0, 3, 4, 0, 0 } 
                          };

            // Die Schleife for benutzen um die Elemente des Array auszudrucken.
            for (int row = 0; row < 3; row++) {
                for (int col = 0; col < 5; col++) {
                    Console.WriteLine("Element at [{0},{1}] = {2}", row, col, a[row,col]);
                }
                Console.WriteLine("-------------");
            }

            // Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären
            // Die Elemente werden die Wert nicht angewiesen
            int[,] b = new int[3, 5];

            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayOfArrayExample
    {
        static void Main(string[] args)
        {
            // Ein Array mit 3 Elemente erklären.
            // Ein Element ist ein anderes Array.
            string[][] teams = new string[3][];

            string[] mu = { "Beckham","Giggs"};
            string[] asenal = { "Oezil", "Szczęsny", "Walcott" };
            string[] chelsea = {"Oscar","Hazard","Drogba" };

            teams[0] = mu;
            teams[1] = asenal;
            teams[2] = chelsea;

            // Die Schleife for benutzen um die Elemente des Array auszudrucken
            for (int row = 0; row < teams.Length; row++)
            {
                for (int col = 0; col < teams[row].Length ; col++)
                {
                    Console.WriteLine("Element at [{0}],[{1}] = {2}", row, col, teams[row][col]);
                }
                Console.WriteLine("-------------");
            }
 

            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class Person
    { 
        // Das ist ein Feld (field) .
        // Den Name speichern.
        public string Name;

        // Das ist ein Constructor.
        // Er ist für die Erstellung des Objekt benutzt.
        // Constructor hat einen Parameter.
        // Constructr hat immer den gleichen Name der Klasse.
        public Person(string persionName)
        {
            // Die Wert von Parameter für den Feld name anweisen.
            this.Name = persionName;
        }

        // Das ist die Methode, die das String Typ zurückgibt
        public string GetName()
        {
            return this.Name; 
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace HelloCSharp
{
    class PersonTest
    {
        static void Main(string[] args)
        {
            // Ein Objekt der Klasse Person erstellen.
            // Dieses Objekt aus Constructor der Klasse Person initializieren.
            Person edison = new Person("Edison");

            // Die Klasse Person hat die Methode GetName().
            // Das Objekt benutzen um die Methode GetName(): aufzurufen
            String name = edison.GetName();
            Console.WriteLine("Person 1: " + name);

            // Ein Objekt der Klasse Person erstellen.
            // Dieses Objekt aus Constructor der Klasse Person initializieren..
            Person billGate = new Person("Bill Gates");

            // Die Klasse Person hat den Feld 'name' public.
            // Sie können das Objekt benutzen um in dem Feld 'name' zuzugreifen.
            String name2 = billGate.Name;
            Console.WriteLine("Person 2: " + name2);

            Console.ReadLine();
        } 
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class FieldSample
    {
        // Das ist ein static Feld (static field).
        public static int MY_STATIC_FIELD = 100;

        // Das ist ein normaler Feld
        public string MyValue;

        // Das ist ein Constructor der Klasse FieldSample.
        public FieldSample(string value)
        {
            this.MyValue = value;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class FieldSampleTest
    {
        static void Main(string[] args)
        {   
            // Die Wert vom static Feld ausdrucken.
            // Für den static Feld sollen Sie durch den Name der Klasse zugreifen
            Console.WriteLine("FieldSample.MY_STATIC_FIELD= {0}", FieldSample.MY_STATIC_FIELD);

            // Sie können die Wert des static Feld ändern.
            FieldSample.MY_STATIC_FIELD = 200;

            Console.WriteLine(" ------------- "); 

            // Das erste Objekt erstellen.
            FieldSample obj1 = new FieldSample("Value1");

            // Der nicht-static Feld sollen Sie durch Objekt zugreifen.
            Console.WriteLine("obj1.MyValue= {0}",  obj1.MyValue);  

            // Das zweite Objekt erstellen:
            FieldSample obj2 = new FieldSample("Value2");

           
            Console.WriteLine("obj2.MyValue= {0}" , obj2.MyValue);

            // Sie können die Wert des Feldes ändern.
            obj2.MyValue = "Value2-2";

            Console.ReadLine();
        }
     
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HelloCSharp
{
    class ConstFieldExample
    {
        // Ein Feld Konstante, seine Wert wird bei der Kompilierung bestimmt.
        // Sie können die neue Wert für den Feld const nicht anweisen.
        // Achtung: Der Feld const ist immer static.
        public const int MY_VALUE = 100;
 
        // Ein static Feld und readonly.
        // Seine Wert wird schon bereit angewiesen oder nur einmal im Constructor angewiesen.
        public static readonly DateTime INIT_DATE_TIME1 = DateTime.Now;

        // Ein readonly und none-static Feld
        // Seine Wert wird schon bereit angewiesen oder nur einmal im Constructor angewiesen
        public readonly DateTime INIT_DATE_TIME2 ;

        public ConstFieldExample()
        {
            // Seine Wert wird einmal bei dem ersten Laufen angewiesen
            INIT_DATE_TIME2 = DateTime.Now;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class MethodSample
    {
        public string text = "Some text";

        // Ein Default Constructor.
        // D.h hat Constructor keinen Parameter
        public MethodSample()
        {

        }

        // Das ist eine Methode, dessen Rückgabetyp String ist.
        // Diese Methode hat keinen Parameter.
        public string GetText()
        {
            return this.text;
        }

        // Das ist eine Methode mit einem String Parameter.
        // Diese Methode gibt void zurück (oder nichts zurückgeben sogenannt.)
        public void SetText(string text)
        {
            // this.text: die Referenz auf dem Feld text machen um mit dem Parameter text zu unterscheiden.
            this.text = text;
        }

        // Das ist eine static Methode.
        // Das Typ int zurückgeben und hat 3 Parameter
        public static int Sum(int a, int b, int c)
        {
            int d = a + b + c;
            return d;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class MethodSampleTest
    {
        static void Main(string[] args) 
        { 
            // Das Objekt MethodSample erstellen
            MethodSample obj = new MethodSample();

            // Die Methode GetText() aufrufen.
            // Die nicht-static Methode sollen durch das Objekt aufgeruft werden.
            String text = obj.GetText();
 
            Console.WriteLine("Text = " + text);

            // Die Methode SetText(string) aufrufen
            // Die nicht-static Methode sollen durch das Objekt aufgeruft werden.            
            obj.SetText("New Text");
 
            Console.WriteLine("Text = " + obj.GetText());

            // Die nicht-static Methode sollen durch den Name der Klasse aufgeruft werden.
            int sum = MethodSample.Sum(10, 20, 30);
 
            Console.WriteLine("Sum  10,20,30= " + sum);

            Console.ReadLine();
       }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    // Eine Klasse Animal (Tier) illustrieren
    class Animal
    {
        public Animal()
        {

        }

        public void Move()
        {
            Console.WriteLine("Move ...!");
        }
      
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class Cat : Animal
    {
      
        public   void Say()
        {
            Console.WriteLine("Meo");
        } 

        // Eine Methode der Klasse Cat
        public void Catch()
        {
            Console.WriteLine("Catch Mouse");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    // Der Ant
    class Ant : Animal
    {
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class AnimalTest
    {

        static void Main(string[] args)
        {
            // Ein Objekt Cat erklären.
            Cat tom = new Cat();

            // Prüfen, ob 'tom' ein Objekt Animal ist oder nicht.
            // Es ist klar true.
            bool isAnimal = tom is Animal;

            // ==> true
            Console.WriteLine("tom is Animal? " + isAnimal);

            // Die Methode Catch aufrufen
            tom.Catch();

            // Die Methode Say() vom Cat aufrufen.
            // ==> Meo
            tom.Say();

            Console.WriteLine("--------------------");

            // Ein Objekt Animal erklären.
            // Das Objekt durch den Constructor von Cat initializieren.
            Animal tom2 = new Cat();

            // Die Methode Move() aufrufen
            tom2.Move();

            Console.WriteLine("--------------------");

            // Ein Objekt Ant erstellen.
            Ant ant = new Ant();

            // Die Methode Move(), die aus Animal geerbt wird
            ant.Move();

            Console.ReadLine();
        }
    }
}