Journal d'apprentissage C# 21 ----Encapsulation et modificateurs d'accès

Encapsulation :

est défini comme « enfermer un ou plusieurs éléments dans un package physique ou logique ». Dans la méthodologie de programmation orientée objet, l'encapsulation est utilisée pour empêcher l'accès aux détails de l'implémentation. C'est-à-dire que les détails de l'implémentation sont résumés, de sorte que la logique très complexe puisse être facilement utilisée par d'autres après avoir été empaquetée. D'autres n'ont pas besoin de comprendre comment elle est implémentée et peuvent obtenir les résultats souhaités en la transmettant simplement. les paramètres requis. L'encapsulation est implémentée à l'aide de modificateurs d'accès. Un modificateur d'accès définit la portée et la visibilité d'un membre de la classe.

Modificateurs d'accès :

Dans la déclaration et la définition de la classe, j'ai brièvement présenté les modificateurs d'accès, ce qui n'est pas très spécifique. Nous étudierons ici les modificateurs d'accès dans. profondeur. ;

Il existe 5 modificateurs d'accès en C# : public, privé, protégé, interne, protégé interne ;

modificateur public

Le modificateur d'accès public permet à une classe de Ses variables membres et fonctions membres sont exposées à d’autres fonctions et objets. Tout membre public est accessible aux classes extérieures. (L'accès aux membres n'est pas restreint, les sous-classes sont autorisées et les objets sont autorisés)

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());  
        }  
    }  
}

Résultats de sortie :

Dans l'exemple ci-dessus, l'étudiant Tous les membres sont accessibles de type public, donc son objet instancié peut accéder à tous les membres.

modificateur privé

Le modificateur d'accès privé permet à une classe de masquer ses variables membres et ses méthodes membres à ses objets. Seules les méthodes d’une même classe peuvent accéder à ses membres privés. Même une instance d'une classe ne peut pas accéder à ses membres privés (aucun accès par ses sous-classes ou objets n'est autorisé).

Nous utiliserons l'exemple ci-dessus :

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 方法  
        }  
    }  
}

Comme il existe des restrictions d'accès privées à la variable Méthode chinoise et mathématique Total dans la classe d'élève, elle n'est pas accessible via l'objet stu

modificateur protégé

Le modificateur d'accès protégé permet à une sous-classe d'accéder aux variables membres et aux fonctions membres de sa classe de base. Cela aide à l’héritage. (L'accès aux objets n'est pas autorisé, l'accès aux méthodes dans la classe est autorisé et l'accès aux sous-classes est autorisé)

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();  
              
        }  
    }  
}

modificateur interne

Le modificateur d'accès interne permet à une classe d'accéder à ses variables membres et méthodes membres Exposées à d'autres méthodes et objets dans l'assembly actuel (projet actuel). En d’autres termes, tout membre doté du modificateur d’accès interne est accessible par n’importe quelle classe ou méthode définie dans l’assembly (projet) dans lequel le membre est défini.

Pour apprendre le modificateur interne, il faut d'abord apprendre à utiliser Vs2010 pour créer plusieurs projets et la méthode de référence entre projets :

Créez d'abord un fichier projet : nommez-le Test_internal

Après avoir cliqué sur OK, recherchez le gestionnaire de solution :

Cliquez avec le bouton droit sur la solution "Test_internal " "(1 projet) --->Ajouter--->Nouveau projet---->visual C#--->Console; Dans la colonne de nom, nous le nommons Class_internal OK ; (assemblages)

En fait, le nom que nous avons entré ci-dessus est le nom de l'espace de noms que nous avons défini. Ouvrez le code Class_internal L'espace de noms. est l'espace de noms Class_internal, et l'espace de noms de Test_internal est l'espace de noms Test_internal. Nous utilisons l'espace de noms using dans un projet pour référencer le contenu d'un autre projet, mais avant cela, nous devons ajouter le chemin du projet référencé dans la liste "Référence". 🎜>

Cliquez avec le bouton droit sur "Référence" --->Ajouter une référence--->Projet. Recherchez le nom du projet à référencer dans la liste des noms de projet. Ici, nous sélectionnons Class_internal. Cliquez sur OK. Class_internal apparaîtra dans la liste de références

Nous ouvrons. le programme dans Class_internal .cs édite le code suivant

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)  
        {   
          
        }  
    }  
     
}

puis édite le code suivant dans Test_internal :

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保护类型  
             
        }  
    }  
}

Nous utilisons des types d'accès internes et publics dans Class_internal, et dans un autre projet Test_internal uniquement Accès au type d'accès public. C'est interne

modificateur interne protégé

Le modificateur d'accès interne protégé permet à une classe de masquer ses variables membres et ses fonctions membres des autres objets et fonctions de classe en dehors des sous-classes au sein de la même application (projet). (Je ne comprends pas très bien) En d'autres termes, il possède à la fois les propriétés protected et internal. L'accès protégé est limité aux sous-classes et est accessible par héritage dans un autre assembly (le projet Internal restreint l'accès à d'autres projets). . Les deux restrictions sur la superposition, les types protégés ne sont pas accessibles dans un autre projet via des sous-classes héritées.

Ce qui précède est le contenu du C# Learning Diary 21 ----Encapsulation et modificateurs d'accès Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn. )!