Vererbung und Polymorphismus in C#

View more categories:

1- Die Vorstellung

Inheritance und Polymorphism- das ist ein sehr wichtigen Begriff  im   CSharp. Und Sie müssen es beherrschen

2- Die Klasse, Objekt und Constructor

Sie sollen explizit die Klasse, den Constructor und das Objekt verstehen bevor Sie die Inheritance in   CSharp lernen beginnen. Wir schauen eine Klasse  Person, die die Person mit der betreffende Information bezeichnet
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class Person
    {
        //  name - der Name der Person
        public String Name;

        // bornYear - der Geburtsjahr
        public int BornYear;

        // Das Geburtsort
        public String PlaceOfBirth;

        // Constructor  hat 3 Parameter
        // Das Zweck liegt in die Initialization der Wert für die Felder der Person.
        // Den Name, den Geburtsjahr und das Geburtsort bestimmen.
        public Person(String Name, int BornYear, String PlaceOfBirth)
        {
            this.Name = Name;
            this.BornYear = BornYear;
            this.PlaceOfBirth = PlaceOfBirth;
        }

        // Constructor hat 2 Parameter
        // Das Zweck ist für die Erstellung der Wert für 2 Felder Name und Geburtsjahr von Person
        // Das Geburtsort wird nicht initialisiert
        public Person(String Name, int BornYear)
        {
            this.Name = Name;
            this.BornYear = BornYear;
        }

    }
}
PersonDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class PersonDemo
    {

        static void Main(string[] args)
        {

            // Das Objekt: Thomas Edison.
            // wird durch Constructor mit 2 Parameter von der Klasse Person erstellt.
            Person edison = new Person("Thomas Edison", 1847);

            Console.WriteLine("Info:");
            Console.WriteLine("Name: " + edison.Name);
            Console.WriteLine("Born Year: " + edison.BornYear);
            Console.WriteLine("Place Of Birth: " + edison.PlaceOfBirth);

            // Das Objekt: Bill Gates
            // wird durch Constructor mit 3 Parameter der Klasse Person.
            Person billGates = new Person("Bill Gate", 1955, "Seattle, Washington");

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

            Console.WriteLine("Info:");
            Console.WriteLine("Name: " + billGates.Name);
            Console.WriteLine("Born Year: " + billGates.BornYear);
            Console.WriteLine("Place Of Birth: " + billGates.PlaceOfBirth);

            Console.ReadLine();
        }
    }
}
PersonDemo laufen:

Der Unterschied von der Klasse, Constructor und Objekt:

Die Klasse  Person bezeichnet eine Klasse von der Person. Sie ist etwas abstrakt aber sie hat die Information, wie in dem obengemeinten Beispiel, die Information vom Name, Geburtsjahr, Geburtsort 
Constructor.
  • Constructor hat immer den gleichen Name der Klasse
  • Eine Klasse kann einen oder mehreren Constructor.
  • Constructor kann den oder keinen Parameter haben. Constructor, der keinen Parameter hat, ist das Default Constructor.
  • Constructor wird benutzt um ein Objekt der Klasse zu erstellen
Deshalb ist die Klasse  Person abstrakt, aber wenn sie Sie oder mich zeigt, sind sie 2 Objekte von der Klasse  Person. Und Constructor ist eine besonde Methode zur Erstellung des Objekt. Constructor wird die Wert in die Felder der erstellten Objekte übertragen
Das ist die Illustrator darüber, wie die Felder der Klasse die Wert übertragen werden wenn Sie ein Objekt aus Constructor erstellen

3- Die Inheritance im CSharp

Wir brauchen einige Klasse zur Teilnahme an der Beispiele.
  • Animal: Ein Tier bezeichnent.
  • Duck: Eine Subklasse von Animal.
  • Cat: Eine Subklasse vonAnimal
  • Mouse: Eine Subklasse von Animal.
Wie gewusst wird der Constructor der Klasse benutzt um ein Objekt zu erstellen und die Wert für die Felder zu übertragen.
Constructor der Subklasse ruft nie auf ein Constructor der Vaterklasse auf um die Wert einer Vaterklasse zu initializieren danach initialisiert sie die Wert für ihre Felder 
Zum Beispiel
Animal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    public abstract class Animal
    {
        // Das ist der Feld Name .
        // Zum Beispiel die Katze Tom, die Maus Jerry.
        public string Name;

        // Der Default-Constructor .
        public Animal()
        {
            Console.WriteLine("- Animal()");
        }

        public Animal(string Name)
        {
            // Die Wert für die Felder Name anweisen
            this.Name = Name;
            Console.WriteLine("- Animal(string)");
        }

        // Move(): Den Tier bewegen.
        // virtual: erlauben, die Klasse auf die Methode zu überschreiben (override) .
        public virtual void Move()
        {
            Console.WriteLine("Animal Move");
        }

        public void Sleep()
        {
            Console.WriteLine("Sleep");
        }

    }
}
Cat ist die Subklasse, die aus der Klasse  Animal erbt. Sie hat auch ihre Felder
Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    public class Cat : Animal
    {

        public int Age;
        public int Height;

        // Das ist ein Constructor mit 3 Parameter von der Klasse Cat.
        // base(name) verwenden um nach dem Constructor der Vaterklasse Animal(string) aufzurufen.
        // Die Felder der Vaterklasse werden die Wert angewiesen
        // Danach werden die Felder der Klasse die Wert angewiesen.
        public Cat(string name, int Age, int Height)
            : base(name)
        {
            this.Age = Age;
            this.Height = Height;
            Console.WriteLine("- Cat(string,int,int)");
        }

        // Constructor ruft auf dem Default Constructor (ohne Parameter) der Vaterklasse.
        public Cat(int Age, int Height)
            : base()
        {
            this.Age = Age;
            this.Height = Height;
            Console.WriteLine("- Cat(int,int)");
        }

        public void Say()
        {
            Console.WriteLine("Meo");
        }

        // Die Methode Move() der Vaterklasse cha (Animal) überschreiben.
        // Die Methode wieder aufschreiben um die Bewegungsverhalten der Katze zu bezeichnen
        public override void Move()
        {
            Console.WriteLine("Cat Move ...");
        }
    }
}
CatTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class CatTest
    {
        static void Main(string[] args)
        {

            Console.WriteLine("Create Cat object from Cat(string,int,int)");

            // Ein Objekt Cat aus dem Constructor mit 3 Parameter initializieren
            // Der Feld Name von Animal wird die Wert "Tom" übertragen
            // Der Feld Age von Cat wird die Wert 3 übertragen
            // Der Feld Heigt von Cat wird die Wert von 20 übertragen.
            Cat tom = new Cat("Tom",3, 20);

            Console.WriteLine("------");
            
            Console.WriteLine("Name = {0}", tom.Name);
            Console.WriteLine("Age = {0}", tom.Age);
            Console.WriteLine("Height = {0}", tom.Height);

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

            // Die Aufruf auf die Methode, die aus der Klasse Animal geerbt wird.
            tom.Sleep();

            // Die Aufruf auf die Methode Say() (der Klasse Cat)
            tom.Say();


            Console.ReadLine();
        }
    }
}
Das Ergebnis der Durchführung von  CatTest:
Was passiert wenn Sie ein Objekt aus einem Constructor initializieren? Wie ruft es auf einen Constructor der Vaterklasse auf ? Schauen Sie die folgende Illustration
Mit der obengemeinten Illustration sehen Sie, dass die Aufruf vom Constructor der Vaterklasse wird immer vor der Aufruf vom Constructor der Subklasse gemacht. Sie wird die Wert für die Felder der Vaterklasse zuerst und dann die Felder von der Subklasse 
Wenn Sie ein Constructor schreiben und nicht klar zeigen, auf welchem Constructor von der Vaterklasse er basiert (base). wird   CSharp default verstehen, dass der Constructor basiert auf dem Default-Constructor der Vaterklasse 
// Constructor  zeigt nicht, auf welchem Constructor der Vaterklasse der basiert (base)
public Cat(int Age, int Height)
{

}

// Er ist äquivalent mit :
public Cat(int Age, int Height) : base()
{

}
Ein Constructor kann auf einen anderen Constructor in der gleichen Klasse durch die Benutzung von  :this aufrufen.
private int Weight;

// Default Constructor (Kein Parameter).
// Er ruft auf constructor Mouse(int) auf.
public Mouse()    : this(100)
{
}

// Das ist der Constructor mit einem Parameter.
// nicht klar zeigen :base
// d.h er basiert auf dem Default-Constructor der Vaterklasse 
public Mouse(int Weight)
{            
   this.Weight = Weight;
}
Mouse.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    public class Mouse : Animal
    {

        private int Weight;

        // Default Constructor (Kein Parameter).
        // Die Aufruf auf Mouse(int)
        public Mouse()
            : this(100)
        {
        }

        // Constructor hat einen Parameter.
        // Und nicht klar schreiben :base
        // d.h er basiert auf dem Default-Constructor der Vaterklasse 
        public Mouse(int Weight)
        {            
            this.Weight = Weight;
        }

        // Constructor hat 2 Parameter
        public Mouse(String name, int Weight)
            : base(name)
        {
            this.Weight = Weight;
        }

        public int GetWeight()
        {
            return Weight;
        }

        public void SetWeight(int Weight)
        {
            this.Weight = Weight;
        }

 
    }
}
Den Operator  'is' benutzen damit Sie prüfen können, ob ein Objekt das Typ von einer Klasse ist oder nicht. Schauen Sie das folgende Beispiel 
IsOperatorDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class IsOperatorDemo
    {
        static void Main(string[] args)
        {
            // Ein Objekt Animal initializieren
            // Animal ist eine abstrakte Klasse
            // Deshalb können Sie ein Objekt aus Constructor von Animal nicht erstellen 
            Animal tom = new Cat("Tom", 3, 20);

            Console.WriteLine("Animal Sleep:");

            // Die Aufruf auf die Methode Sleep() von Animal
            tom.Sleep();

            // Den Operator 'is' benutzen um zu prüfen, ob ein Objekt ein Typ ist oder nicht 
            bool isMouse = tom is Mouse;// false

            Console.WriteLine("Tom is mouse? " + isMouse);

            bool isCat = tom is Cat; // true
            Console.WriteLine("Tom is cat? " + isCat);

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

            Console.ReadLine();
        }
    }
}
Das Beispiel machen

Cast im CSharp

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

namespace InheritancePolymorphism
{
    class CastDemo
    {
        static void Main(string[] args)
        {
            // Die Aufruf auf die Methode, sie gibt ein Random Tier zurück.
            Animal animal = GetRandomAnimal();

            if (animal is Cat)
            {
                Console.WriteLine("Your animal is Cat");

                // Cast zum Objekt Cat.
                Cat cat = (Cat)animal;

                // Und in dem Feld Height vom Objekt Cat zugreifen.
                Console.WriteLine("Cat height: " + cat.Height);
            }
            else if (animal is Mouse)
            {
                Console.WriteLine("Your animal is Mouse");

                // Cast zum Objekt Mouse machen.
                Mouse mouse = (Mouse)animal;

                // Und die Aufruf auf einer Methode der Klasse Mouse.
                Console.WriteLine("Mouse weight: " + mouse.GetWeight());
            }

            Console.ReadLine();
        }

        // Method gibt random ein Tier zurück.
        public static Animal GetRandomAnimal()
        {
            // Die Random Zahl zwischen 0 und 9 (0,...9) zurückgeben
            int random = new Random().Next(0, 10);

            Console.WriteLine("random = " + random);

            Animal animal = null;
            if (random < 5)
            {
                Console.WriteLine("Create a Cat");
                animal = new Cat("Tom", 3, 20);
            }
            else
            {
                Console.WriteLine("Create a Mouse");
                animal = new Mouse("Jerry", 5);
            }
            return animal;
        }
    }
}
Das Beispiel machen

4- Polymorphism im CSharp

Polymorphism heißt die Vielgestaltigkeit. Im objektsorientierte Programmiersmodell wird das Polymorphism wie "eine Interface aber mehre Funktion" bezeichnet.

Polymorphism kann static oder dynamisch sein. Im static Polymorphism wird die Auswirkung mit einer Funktion bei der Zeitpunkt der Kompile bestimmt. Im dynamischen Polymorphism wird es bei run-tim entschiedet 
Sie haben eine Asiatische Katze (AsianCat),Sie können es als eine Katze oder ein Tier nennen. Das ist ein Aspekt des Polymorphism.

Oder ein anderes Beispiel: In Ihr Lebenslauf wird geschrieben, dass Sie ein Asien sind und in der Praxis sind Sie eine Vietnamese. Und dann kann ich sagen, Sie sind ein Erdling

Das folgende Beispiel zeigt Ihnen die Verhalten zwischen die Erklärung und die Praxis
PolymorphismCatDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class PolymorphismCatDemo
    {
        static void Main(string[] args)
        {
            // Sie erklären ein Objekt Animal (Tier).
            // Durch die Erstellung durch Constructor der Klasse Cat.
            // ** Das Objekt 'tom' als Animal erklärt
            // Deshalb kann es nur die Methode von Animal aufrufen.
            Animal tom = new Cat("Tom", 3, 20); 

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

            // - Move() ist die Methode, die in der Klasse Animal definiert.
            // - Move() wird in der Klasse Cat überschrieben (override) .
            // 'tom' ist in der Praxis eine Katze, obwohl es als Animal erklärt wird.
            // ==> Es ruft die Methode Move(), die in der Klasse Cat definiert wird.
            tom.Move(); // ==> Cat Move.


            Console.ReadLine();
        }
    }
}
Sie haben 2 Optionen um eine in der Vaterklasse definierte Methode durch die Verwendung von  override oder  new wiederzuschreiben. Und sie sind unterschiedlich. Schauen Sie die folgende Illustration an
Duck.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
   class Duck : Animal
   {

       public Duck(string name)
           : base(name)
       {
           Console.WriteLine("- Duck(string)");
       }


       public new void Move()
       {
           Console.WriteLine("Duck Move..");
       }
   }
}
InheritanceDuckDemo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InheritancePolymorphism
{
    class InheritanceDuckDemo
    {
        static void Main(string[] args)
        {
            // Sie erklären ein Objekt Animal aber Sie erstellen es durch Constructor der Klasse Duck.
            Animal donald = new Duck("Donald");

            // Die Aufruf auf die Methode Sleep() (in der Klasse Animal defniert).
            donald.Sleep();

            // - Move() ist die Methode, die in der Klasse Animal definiert wird.
            // - Move() wird mit dem Schlüsselwort 'new' in der Klasse Duck  " wiedersgechrieben" 
            //   ('new' Move() wird für die Objekte, die als Duck oder die Subklasse der Duck benutzt .
            // 'donald' wird als  'Animal', nicht 'Duck' erklärt.
            donald.Move(); // ==> Animal Move.


            Console.ReadLine();
        }
    }
}
Das Beispiel

View more categories: