[Tutoriel C#] Encapsulation C#

Encapsulation C#

Le packaging est défini comme « l'inclusion d'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.

L'abstraction et l'encapsulation sont des fonctionnalités pertinentes de la programmation orientée objet. L'abstraction permet la visualisation d'informations pertinentes et l'encapsulation permet aux programmeurs d'atteindre le niveau d'abstraction souhaité.

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. Les modificateurs d'accès pris en charge par C# sont les suivants :

Public

Privé

Protégé

Interne

Protégé interne

Modificateur d'accès public

Le modificateur d'accès public permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets. Tout membre public est accessible aux classes extérieures.

L'exemple suivant illustre ceci :

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        public double length;
        public double width;

        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }//end class Rectangle    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
			r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

长度： 4.5
宽度： 3.5
面积： 15.75

ci-dessus Dans le cas de , les variables membres length et width sont déclarées publiques, elles sont donc accessibles par la fonction Main() en utilisant l'instance r de la classe Rectangle.

Les fonctions membres Display() et GetArea() peuvent également accéder directement à ces variables sans utiliser d'instances de classe.

La fonction membre Display() est également déclarée publique, elle est donc également accessible par Main() en utilisant une instance r de la classe Rectangle.

Modificateur d'accès privé

Le modificateur d'accès privé permet à une classe de masquer ses variables membres et ses fonctions membres des autres fonctions et objets. Seules les fonctions au sein de la même classe peuvent accéder à ses membres privés. Même les instances d'une classe ne peuvent pas accéder à ses membres privés.

L'exemple suivant illustre ceci :

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        private double length;
        private double width;

        public void Acceptdetails()
        {
            Console.WriteLine("请输入长度：");
            length = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入宽度：");
            width = Convert.ToDouble(Console.ReadLine());
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }//end class Rectangle    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

请输入长度：
4.4
请输入宽度：
3.3
长度： 4.4
宽度： 3.3
面积： 14.52

ci-dessus Dans le cas de , les variables membres length et width sont déclarées comme privées, elles ne sont donc pas accessibles par la fonction Main().

Les fonctions membres AcceptDetails() et Display() peuvent accéder à ces variables.

Étant donné que les fonctions membres AcceptDetails() et Display() sont déclarées publiques, elles sont accessibles par Main() en utilisant une instance r de la classe Rectangle.

Modificateur d'accès 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. Nous en discuterons en détail dans le chapitre sur l'héritage. Discutez-en plus en détail.

Modificateur d'accès interne

Le spécificateur d'accès interne permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets du programme 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’application dans laquelle le membre est défini.

L'exemple suivant illustre ceci :

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        internal double length;
        internal double width;
        
        double GetArea()
        {
            return length * width;
        }
       public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }//end class Rectangle    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

长度： 4.5
宽度： 3.5
面积： 15.75

Dans l'exemple ci-dessus, veuillez noter la fonction membre GetArea () est déclaré sans aucun modificateur d'accès. Si aucun modificateur d'accès n'est spécifié, le modificateur d'accès par défaut du membre de classe est utilisé, qui est privé.

Modificateur d'accès 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. Ceci est également utilisé pour implémenter l’héritage.

Ce qui précède est le contenu de [tutoriel c#] Encapsulation C# Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !