Abstrakte Klasse und Schnittstelle in C#

View more categories:

1- Die Vorstellung

Im diesem Dokument gebe ich die Hinweise über die Interface und die Abstract Classe. Gleichzeitig analysiere ich die Gleichheit und den Unterschied von ihnen..
Zuerst brauchen Sie ein Projekt mit dem Name von AbstractClassInterface um mit den Beispiele durchzuführen.
Stellen Sie es als das Default Projekt.

2- Die Abstrakte Klasse (Abstract Class)

Abstract class (die abstrakte Klasseg).Sehen Sie bitte ein Beispiel über solche Klasse
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{
   // Eine Klasse hat mindesten eine abstrakte Methode, 
   // abstrakt erklären müssen.
   public abstract class ClassA
   {

       // Das ist eine abstrakte Methode
       // Sie hat keinen Körper.
       // 'access modifier' von der Methode ist  public
       // (access modifier: Der Zugangmodifizierer).
       public abstract void DoSomething();

       // 'access modifier' der Methode ist  protected
       protected abstract String DoNothing();

      
       protected abstract void Todo();
   }

   // Das ist eine abstrakte Methode
   // Sie wird abstrakt erklärt obwohl sie keine abstrakten Methode hat
   public abstract class ClassB
   {

   }
}
Die Merkmale einer abstrakten Klasse sind:
  1. Es wird mit dem Schlusselwort  abstract.angemeldet
  2. Es kann  0, 1 oder viele abstrakte Methode anmelden.
  3. Sie können ein Objekt direkt aus einer abstrakten Klasse nicht erstellen.

3- Zum Beispiel: Die abstrakte Klasse 

Sehen Sie das folgende Beispiel:
AbstractJob.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{
    // Die Klasse hat mindesten eine abstrakte Methode, 
    // muss abstrakt erklärt werden
    public abstract class AbstractJob
    {

        public AbstractJob()
        {

        }

        // Das ist eine abstrakte Methode
        // Sie hat keinen Körper (body)
        // Diese Methode gibt den Name der Aufgabe zurück.
        public abstract String GetJobName();

        // Das ist eine abstrakte Methode. Diese Methode hat keinen Körper (body)
        public abstract void DoJob();

        // Das ist eine normale Methode (nicht abstrakt)
        public void StopJob()
        {
            Console.WriteLine("Stop");
        }
    }
}
JavaCoding.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{
    public class JavaCoding : AbstractJob
    {

        public JavaCoding()
        {
        }

        // Die Durchführung der abstrakten Methode, die in der Vaterklasse erklärt wird.
        // Sie muss den Körper (body) hat 
        // (den Schlüsselwort 'override' brauchen).
        public override void DoJob()
        {
            Console.WriteLine("Coding Java...");
        }

        // Die Durchführung der abstrakten Methode der Vaterklasse
        public override String GetJobName()
        {
            return "Java Coding";
        }

        public void TestExample()
        {
            Console.WriteLine("Testing Example...");
        }
    }

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

namespace AbstractClassInterface
{
    class CSharpCoding : AbstractJob
    {
        public CSharpCoding()
        {
        }

        // Die Durchführung der abstrakten Methode, die in Vaterklasse erklärt wird.
        // Sie muss den Körper haben
        // (den Schlusselwort 'override' brauchen).
        public override void DoJob()
        {
            Console.WriteLine("Coding CSharp...");
        }

        // Die Durchführung der abstrakten Methode der Vaterklasse
        public override String GetJobName()
        {
            return "CSharp Coding";
        }

        public void RunningExample()
        {
            Console.WriteLine("Running Example...");
        }
    }
}
ManualJob.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{

    // ManualJob - (Eine Job bezeichnen)
    // The Vaterklasse (AbstractJob) hat 2 abstrakte Methode.
    // Diese Klasse führt nur eine Methode der Vaterklasse durch.
    // Deshalb muss es zwanghaft als 'abstract' erklärt werden.
    public abstract class ManualJob : AbstractJob
    {

        public ManualJob()
        {

        }

        // Die Durchführung der abstrakten Methode, 
        // die in der Vaterklasse erklärt wird.
        // (den Schlusselwort 'override' brauchen).
        public override String GetJobName()
        {
            return "Manual Job";
        }

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

namespace AbstractClassInterface
{

    // Diese Klasse erbt aus der abstrakten Klasse ManualJob.
    // BuildHouse erklärt 'abstract' nicht
    // Deshalb soll sie alle restlichen abstrakten Methode durchführen
    public class BuildHouse : ManualJob
    {

        public BuildHouse()
        {

        }

        // Die abstrakten Methode der Vaterklasse durchführen  
        // (Den Schlüsselwort 'override' benutzen brauchen).
        public override void DoJob()
        {
            Console.WriteLine("Build a House");
        }

    }

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

namespace AbstractClassInterface
{
    public class JobDemo
    {

        public static void Main(string[] args)
        {
            // Ein Objekt  AbstractJob vom Constructor der Klasse JavaCoding.
            AbstractJob job1 = new JavaCoding();

            // Die Aufruf nach der Methode DoJob().
            job1.DoJob();

            // Die Methode  GetJobName() ist abstrakt in der Klasse AbstractJob
            // Aber sie wird in einer Klasse durchgeführt. 
            // Deshalb können Sie sie aufrufen.
            String jobName = job1.GetJobName();

            Console.WriteLine("Job Name 1= " + jobName);


            // Ein Objekt AbstractJob aus Constructor der Klasse CSharpCoding erstellen
            AbstractJob job2 = new CSharpCoding();

            // Die Aufruf nach der Methode DoJob().
            job2.DoJob();

            String jobName2 = job2.GetJobName();

            Console.WriteLine("Job Name 2= " + jobName2);

            // Ein Objekt AbstractJob aus Constructor der Klasse BuildHouse erstellen.
            AbstractJob job3 = new BuildHouse();

            job3.DoJob();

            String jobName3 = job3.GetJobName();

            Console.WriteLine("Job Name 3= " + jobName2);


            Console.ReadLine();
        }
    }

}
Das Ergebnis durchführen

4- Die Überblick von Interface

Wir kennen, dass eine Klasse nur aus einer anderen Klasse ausgeweitert werden kann.
// Die Klasse B ist die Subklasse von A oder anders gesagt, B erweitert aus A (extends) 
// CSharp erlaubt nur, eine Klasse aus einer einzigen Klasse erweitert wird.
public class B : A  
{
  // ....
}

// Falls Sie nicht bestimmen, aus welcher Klasse die Klasse erweitert.
// CSharp versteht selbst, diese Klasse aus der Klasse Objekt erweitert
public class B
{

}

// Die folgende Erklärung und die oben gemeinte Erklärung sind gleich
public class B : Object
{

}
Aber eine Klasse kann aus vielen Interface ausgeweitert werden
// Eine Klasse kann nur aus einer einzigen Klasse erweitern 
// aber kann aus vieler Interface erweitern 
public class Cat : Animal, CanEat, CanDrink
{

     // ....
}
Die Eigenschaften der Interface in CSharp sind
  1. Interface hat modifier  public oder internal, wenn sie internal als Default nicht schreibt.
  2. Interface kann die Field nicht definieren.
  3. Ihre Methode sind abstract und public und hat keinen Funktionskörper. Aber bei der Anmeldung der Methode dürfen Sie public oder abstract.nicht schreiben
  4. Interface hat keinen Constructor

5- Die Struktur einer Interface

Eine interface im  CSharp kann modifier   public oder  internal anmelden. Und bei der Nicht-Anmeldung kann man selbst   internal als Default verstehen. Interface mit modifier public kann irgendwo benutzt werden. und die Interface mit modifier  internal kann nur die interne Assembly verwendet werden.

Ein Assembly ist das Produkt zur Kompilierung Ihrer Code, oft ist es ein DLL, aber EXE kann auch ein Assembly. Es ist die kleinste Einheit der Implementierung für alle .NET Projekt.

Assembly enhaltet konkret die .NET Code in MSIL (Microsoft Intermediate language ), die zur Computercode (Native code) in der ersten Implementierung im PC kompiliert ("JITted" - durch den Kompilier Just-In-Time) . Das ist die kompilierte Code, die im Assembly gespeichert und für die nächsten Aufrufe wiederbenutzt wird 

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

namespace AbstractClassInterface
{

    // Das ist eine Interface, die 'access modifier' nicht erklärt wird.
    // Nach dem Default ist ihr  'access modifier'  'internal'.
    // Sie wird in der Assembly.
     interface NoAccessModifierInterface
    {

    }

}
Die Methode in Interface sind public und abstrakt. Sie hat keinen Körper aber Sie können bei der Definition der Methode  public oder  abstract nicht schreiben
CanMove.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{

    // Interface definiert die beweglichen Dinge.
    public interface CanMove
    {

        // Die Methode in Interface sind public und abstrakt (public abstract)
        // (Aber Sie dürfen public and abstract hier nicht schreiben).
        void Run();

        // Zurückgeben.
        void Back();

        // Die Laufensgeschwindigkeit zurückgeben
        int GetVelocity();

    }

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

namespace AbstractClassInterface
{

    // Interface definiert die trinkbaren Dinge
    public interface CanDrink
    { 

          void Drink(); 

    }

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

namespace AbstractClassInterface
{

    // Interface definiert die essbaren Dinge
    public interface CanEat
    {

          void Eat(); 
    }

}

6- Die Klasse zur Interface-Durchführung

Wenn eine Klasse eine Interface implementiert,  müssen Sie alle Methode der Interface wieder anmelden oder durchführen.
  1. Wenn Sie eine Methode von Interface implementieren, sollen Sie die Inhalt für die Methode schreiben und die Methode als Public anmelden.
  2. Wenn Sie eine Methode von Interface nicht implementieren, sollen Sie sie in der Klasse mit dem Schlüsselswort 'public abstract' anmelden und dürfen Sie keine Inhalt der Methode schreiben
Sehen Sie das Beispiel, die Klasse Animal implementiert die Interface  CanMove.
Animal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{

    // Animal (Eine Klasse bezeichnet eine Tier Klasse)
    // Sie erweitert aus der Klasse Objekt (obwohl nicht klar geschrieben).
    // und implementiert (implements) interface CanMove.
    // Interface CanMove hat 3 abtrakte Methode
    // Die Klasse implementiert eine Methode von  CanMove.
    // Deshalb muss es  'abstract'.
    // Die restlichen Methode werden 'public abstract' erklärt.
    public abstract class Animal : CanMove
    {

        // Die Durchführung von der Methode Run() der Interface CanMove.
        // Sie brauchen die Inhalt der Methode schreiben.
        // Modifier muss public sein.
        public void Run()
        {
            Console.WriteLine("Animal run...");
        }

        // Wenn die Klasse eine Methode von Interface durchführt, 
        // sollen Sie sie als eine abstrakte Methode wieder schreiben .
        // (immer 'public abstract')
        public abstract void Back(); 

        public abstract int GetVelocity();

    }


}
Die Klasse  Cat erbt von der Klasse  Animal und gleichzeitig führt sie 2 Interface  CanDrink, CanEat.durch
Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AbstractClassInterface
{

    // Die Klasse Cat erweitert aus der Klasse Animal und führt 2 Interface CanEat, CanDrink.
    public class Cat : Animal, CanEat, CanDrink
    {

        private String name;

        public Cat(String name)
        {
            this.name = name;
        }

        public String getName()
        {
            return this.name;
        }

        // Die abstrakte Methode von Animal durchführen.
        // ('override' klar schreiben ).
        public override void Back()
        {
            Console.WriteLine(name + " cat back ...");
        }

        // Die abstrakte Methode von Animal durchführen.
        // ('override' klar schreiben )
        public override int GetVelocity()
        {
            return 110;
        }

        // Die Methode der Interface CanEat durchführen    
        public void Eat()
        {
            Console.WriteLine(name + " cat eat ...");
        }

        // Die Methode der Interface CanDrink durchführen    
        public void Drink()
        {
            Console.WriteLine(name + " cat drink ...");
        }

    }

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

namespace AbstractClassInterface
{
    public class Mouse : Animal, CanEat, CanDrink
    {

        // Die Durchführung der abstrakten Methode der Klasse  Animal.
        // (den Schlüsselwort 'override' haben müssen).
        public override void Back()
        {
            Console.WriteLine("Mouse back ...");
        }

        // Die Durchführung der abstrakten Methode der Klasse Animal.
        public override int GetVelocity()
        {
            return 85;
        }

        // Die Durchführung der abstrakten Methode der interface CanDrink.
        public void Drink()
        {
            Console.WriteLine("Mouse drink ...");
        }

        // Die Durchführung der abstrakten Methode der interface CanEat.
        public void Eat()
        {
            Console.WriteLine("Mouse eat ...");
        }

    }

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

namespace AbstractClassInterface
{

    public class AnimalDemo
    {

        public static void Main(string[] args)
        {

            // Ein Objekt CanEat erstellen
            // Ein Objekt als CanEat erklären
            // Aber es ist in der Praxis Cat.
            CanEat canEat1 = new Cat("Tom");

            // Ein Objekt als CanEat erklären CanEat
            // Aber es ist in der Praxis Mouse.
            CanEat canEat2 = new Mouse();

            // Das Polymorphism zeigt klar hier an.
            // CSharp kennt immer das pratische Typ eines Objekt.
            // ==> Tom cat eat ...
            canEat1.Eat();

            // ==> Mouse eat ...
            canEat2.Eat();

            bool isCat = canEat1 is Cat;// true

            Console.WriteLine("catEat1 is Cat? " + isCat);

            // Prüfen, ob 'canEat2' die Maus ist oder nicht?.
            if (canEat2 is Mouse)
            {
                // Cast
                Mouse mouse = (Mouse)canEat2;

                // Die Methode auf die Methode Drink() (aus der CanDrink erben).
                mouse.Drink();
            }

            Console.ReadLine();
        }
    }

}
Das Ergebnis von der Durchführung des BEispiel

View more categories: