[C# Tutorial] C# Encapsulation

C# Encapsulation

Encapsulation is defined as "enclosing one or more items in a physical or logical package". In object-oriented programming methodology, encapsulation is used to prevent access to implementation details.

Abstraction and encapsulation are relevant features of object-oriented programming. Abstraction allows visualization of relevant information, and encapsulation enables programmers to achieve the desired level of abstraction.

encapsulation is implemented using access modifiers. An access modifier defines the scope and visibility of a class member. The access modifiers supported by C# are as follows:

Public

Private

Protected

Internal

Protected internal

Public access modifier

Public access modifier allows a class to expose its member variables and member functions to other functions and objects. Any public member can be accessed by outside classes.

The following example illustrates this:

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

When the above code is compiled and executed, it produces the following results:

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

In the above example, The member variables length and width are declared public, so they can be accessed by the function Main() using an instance r of the Rectangle class.

Member functions Display() and GetArea() can also directly access these variables without passing instances of the class.

The member function Display() is also declared as public, so it can also be accessed by Main() using an instance r of the Rectangle class.

Private access modifier

Private access modifier allows a class to hide its member variables and member functions from other functions and objects. Only functions within the same class can access its private members. Even instances of a class cannot access its private members.

The following example illustrates this:

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

When the above code is compiled and executed, it produces the following results:

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

In the above example, The member variables length and width are declared private, so they cannot be accessed by the function Main().

Member functions AcceptDetails() and Display() can access these variables.

Since the member functions AcceptDetails() and Display() are declared public, they can be accessed by Main() using an instance r of the Rectangle class.

Protected access modifier

Protected access modifier allows a subclass to access the member variables and member functions of its base class. This helps with inheritance. We will discuss this in detail in the inheritance chapter. Discuss this in more detail.

Internal access modifier

Internal access specifier allows a class to expose its member variables and member functions to other functions and objects in the current program. In other words, any member with the internal access modifier can be accessed by any class or method defined within the application in which the member is defined.

The following example illustrates this:

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

When the above code is compiled and executed, it produces the following results:

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

In the above example, please note the member function GetArea( ) is declared without any access modifiers. If no access modifier is specified, the default access modifier of the class member is used, which is private.

Protected Internal access modifier

Protected Internal access modifier allows a class to hide its member variables and member functions from other class objects and functions outside of subclasses within the same application . This is also used to implement inheritance.

The above is the content of C# encapsulation in [c# tutorial]. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!