C#-Lerntagebuch 21 ----Kapselung und Zugriffsmodifikatoren

Einkapselung:

ist definiert als „Einschluss eines oder mehrerer Artikel in einem physischen oder logischen Paket“. In der objektorientierten Programmiermethodik wird die Kapselung verwendet, um den Zugriff auf Implementierungsdetails zu verhindern. Das heißt, die Implementierungsdetails werden zusammengefasst, sodass die sehr komplexe Logik nach dem Packen problemlos von anderen verwendet werden kann. Andere müssen nicht verstehen, wie sie implementiert ist, und können durch einfaches Übergeben die gewünschten Ergebnisse erzielen die erforderlichen Parameter. Die Kapselung wird mithilfe von Zugriffsmodifikatoren implementiert. Ein Zugriffsmodifikator definiert den Umfang und die Sichtbarkeit eines Klassenmitglieds.

Zugriffsmodifikatoren:

In der Deklaration und Definition der Klasse habe ich die Zugriffsmodifikatoren kurz vorgestellt, was nicht sehr spezifisch ist. Hier werden wir die Zugriffsmodifikatoren untersuchen Tiefe. ;

Es gibt 5 Zugriffsmodifikatoren in C#: öffentlich, privat, geschützt, intern, geschützt intern;

öffentlicher Modifikator

Der öffentliche Zugriffsmodifikator ermöglicht einer Klasse Seine Mitgliedsvariablen und Mitgliedsfunktionen werden anderen Funktionen und Objekten zugänglich gemacht. Auf jedes öffentliche Mitglied können externe Klassen zugreifen. (Der Zugriff auf Mitglieder ist nicht eingeschränkt, Unterklassen sind erlaubt und Objekte sind erlaubt)

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class student  
    {  
        public int Chinese=80;  
        public int Math=67;  
        public int English=45;  
         //定义一个方法  
        public int total()  
        {  
            int sum = 0;  
            sum = Chinese + Math + English;  
            return sum;  
        }  
    }  
    class teacher  
    {  
        static void Main(string[] args)  
        {  
            student stu = new student();  //实例化一个对象  
            Console.WriteLine("Chinese = {0}\nMath = {1}\nEnglish = {2}\nTotal = {3}",stu.Chinese,stu.Math,stu.English,stu.total());  
        }  
    }  
}

Ausgabeergebnisse:

Im obigen Beispiel Student Auf alle Mitglieder kann öffentlich zugegriffen werden, sodass sein instanziiertes Objekt Stu auf alle Mitglieder zugreifen kann.

Private-Modifikator

Der Private-Zugriffsmodifikator ermöglicht einer Klasse, ihre Mitgliedsvariablen und Mitgliedsmethoden vor ihren Objekten zu verbergen. Nur Methoden innerhalb derselben Klasse können auf ihre privaten Mitglieder zugreifen. Selbst eine Instanz einer Klasse kann nicht auf ihre privaten Mitglieder zugreifen (der Zugriff durch ihre Unterklassen oder Objekte ist nicht zulässig).

Wir verwenden das obige Beispiel:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class student  
    {  
        private int Chinese=80;  
        private int Math=67;  
        public int English=45;  
  
        private int total()  
        {  
            int sum = 0;  
            sum = Chinese + Math + English;  
            return sum;  
        }  
    }  
    class teacher  
    {  
        static void Main(string[] args)  
        {  
            student stu = new student();  
            int Chinese = stu.Chinese;     //出错了,不可访问（private）  
             
            int English = stu.English;   //可以访问 （public）  
  
            int total = stu.total();  // 不可访问 private 方法  
        }  
    }  
}

Da es in der Schülerklasse private Zugriffsbeschränkungen für die Variablen Chinesisch und Mathematikmethode Total gibt, kann nicht über das Objekt stu < auf sie zugegriffen werden 🎜>

geschützter Modifikator

Der geschützte Zugriffsmodifikator ermöglicht einer Unterklasse den Zugriff auf die Mitgliedsvariablen und Mitgliedsfunktionen ihrer Basisklasse. Das hilft bei der Vererbung. (Objektzugriff ist nicht zulässig, Methodenzugriff in der Klasse ist zulässig und Unterklassenzugriff ist zulässig)

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class student  
    {  
        //定义protected 类型保护  
        protected int Chinese=80;  
        protected int Math=67;  
        protected int English=45;  
  
        protected int total()  
        {  
            int sum = 0;  
            sum = Chinese + Math + English;  
            return sum;  
        }  
    }  
    class teacher:student  //teacher 继承student类  
    {  
        static void Main(string[] args)  
        {  
            teacher teac = new teacher();   //创建子类 teacher 对象  
            //全部成功访问  
            int Chinese = teac.Chinese;      
             
            int English = teac.English;    
  
            int total = teac.total();  
              
        }  
    }  
}

interner Modifikator

Der interne Zugriffsmodifikator ermöglicht einer Klasse das Hinzufügen ihrer Mitgliedsvariablen und Mitgliedsmethoden, um sie anderen Methoden und Objekten in der aktuellen Assembly (aktuelles Projekt) zugänglich zu machen. Mit anderen Worten: Auf jedes Mitglied mit dem internen Zugriffsmodifikator kann von jeder Klasse oder Methode zugegriffen werden, die in der Assembly (Projekt) definiert ist, in der das Mitglied definiert ist.

Um den internen Modifikator zu lernen, müssen wir zunächst lernen, mit Vs2010 mehrere Projekte zu erstellen und auf Projekte zu verweisen:

Erstellen Sie zunächst eine Projektdatei: Nennen Sie sie Test_internal

Nachdem Sie auf OK geklickt haben, suchen Sie den Lösungsmanager:

Rechtsklick auf die Lösung „Test_internal“ "(1 Projekt) --->Hinzufügen--->Neues Projekt---->visual C#--->Console; In der Namensspalte nennen wir es Class_internal OK; auf diese Weise erstellen wir 2 Projekte ( Assemblies)

Tatsächlich ist der Name, den wir oben eingegeben haben, der Name des von uns definierten Namespace. Öffnen Sie den Code. Class_internal Der Namespace ist Namespace Class_internal, und der Namespace von Test_internal ist Namespace Test_internal, um auf den Inhalt eines anderen Projekts zu verweisen, aber vorher müssen wir den referenzierten Projektpfad in die „Referenz“-Liste einfügen >

Klicken Sie mit der rechten Maustaste auf „Referenz“--->Referenz hinzufügen--->Projekt. Suchen Sie den Projektnamen, auf den verwiesen werden soll. Klicken Sie hier, um „Class_internal“ in der Referenzliste anzuzeigen.

Bearbeiten Sie im Programm in Class_internal .cs den folgenden Code

und bearbeiten Sie dann den folgenden Code in Test_internal:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Class_internal  
{  
    public class student  
    {  //定义2个 internal 访问类型与一个public访问类型  
        internal int Chinese=80;  
        internal int Math=70;  
        public int English=56;  
      //定义一个internal 访问类型方法  
        internal int Total()  
        {  
            int sum = 0;  
            sum = Chinese + Math + English;  
            return sum;  
        }  
        static void Main(string[] args)  
        {   
          
        }  
    }  
     
}

Wir verwenden interne und öffentliche Zugriffstypen in Class_internal und in einem anderen Projekt Nur Test_internal Zugriff auf den öffentlichen Zugriffstyp. Das ist intern

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using Class_internal;  //引用命名空间  
  
namespace Test_internal  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            student stu = new student();  //实例化一个student类型  
            int Chinese = stu.Chinese;   //出错了，internal 保护类型无法在这个项目中访问  
            int Math = stu.Math;  //出错，同上  
            int English = stu.English;  // 成功访问public保护类型  
             
        }  
    }  
}

geschützter interner Modifikator

Der geschützte interne Zugriffsmodifikator ermöglicht einer Klasse, ihre Mitgliedsvariablen und Mitgliedsfunktionen vor anderen Klassenobjekten und Funktionen außerhalb von Unterklassen innerhalb derselben Anwendung (Projekt) zu verbergen. (Ich verstehe es nicht ganz) Mit anderen Worten, es hat die Eigenschaften geschützt und intern zugleich. Der geschützte Zugriff ist auf Unterklassen beschränkt und kann durch Vererbung in einer anderen Assembly (Projekt) aufgerufen werden. Intern schränkt den Zugriff auf andere Projekte ein Auf die beiden Einschränkungen für Overlay-geschützte Typen kann in einem anderen Projekt nicht über geerbte Unterklassen zugegriffen werden.

Das Obige ist der Inhalt von C# Learning Diary 21 ---- Kapselung und Zugriffsmodifikatoren. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn). )!