最近很多小伙伴都在问C#封装public访问修饰符和c#访问修饰符这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展12、类成员访问修饰符public/private/product

最近很多小伙伴都在问C#封装public访问修饰符和c# 访问修饰符这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展12、类成员访问修饰符public/private/producted/readonly、6 包，单例模式，访问修饰符（public、protected，private）Object String、C# 类中访问修饰符的优先级与用法（public, internal, protected, private）、C#学习日记21----封装 与 访问修饰符等相关知识，下面开始了哦！

• C#封装public访问修饰符（c# 访问修饰符）
• 12、类成员访问修饰符public/private/producted/readonly
• 6 包，单例模式，访问修饰符（public、protected，private）Object String
• C# 类中访问修饰符的优先级与用法（public, internal, protected, private）
• C#学习日记21----封装 与 访问修饰符

C#封装public访问修饰符（c# 访问修饰符）

namespace RectangleApplication {

   class Rectangle {
      //member variables
      public double length;
      public double width;

      public double GetArea() {
         return length * width;
      }

      public void display() {
         Console.WriteLine(Length: {0}, length);
         Console.WriteLine(Width: {0}, width);
         Console.WriteLine(Area: {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();
      }
   }
}

12、类成员访问修饰符public/private/producted/readonly

1、private 类的私有成员

private 类的私有成员，只能在内部访问，在外部访问不到，无法被继承，我们可以将不需要被外部修改的定义为私有的

私有成员，只能在内部访问，在外部访问不到

private 可以在类的内部访问私有成员，不能再外部访问，但是在外部可以访问这个getType，从而访问到type，方法也是默认public公开的

私有成员无法被继承

 2、protected受保护的

和private类似，也是私有成员，只能在内部访问，外部无法访问，但是可以被继承

可以被继承，但是只能在内部访问

可以继承，但是外面访问不到，想要访问protected，可以放在方法里面在调用方法

 3、readonly 只读的，不能被修改的，相当于常量const，如果被修改就会报错，写在修饰符第二位

4、构造函数结合类的访问修饰符进行简写处理：

也可以进行混合编写

 总结：

1.public 默认公开

2.private 私有的，只能内部访问，不能外部访问（就是不能再外面被点出来），不能被继承

3.protected 受保护的，只能内部访问，不能外部访问，可以被继承

4.private 和 protected 如果想在外部被访问，可以放在一个公开的方法里面被引用

5.readonly 只读的，相当于常量const，初始化就赋值，一旦赋值就不能被修改，如果修改就会报错，放在public/private/protected后面

6 包，单例模式，访问修饰符（public、protected，private）Object String

public class SingletonTest
{
	public static void main(String[] args)
	{
		Singleton singleton = Singleton.getInstance();
		Singleton singleton2 = Singleton.getInstance();

		System.out.println(singleton == singleton2);
	}
}


class Singleton
{
	private static Singleton singleton;
	
	private Singleton()
	{
		
	}

	public static Singleton getInstance()
	{
		if(singleton == null)
		{
			singleton = new Singleton();
		}

		return singleton;
	}


}

1）   对于原生数据类型来说，比较的是左右两边的值是否相等。

2）   对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两 边的引用地址是否相同。

19.   java.lang.Object 类。java.lang 包在使用的时候无需显式导入，编译时由编译器自动帮助我们导入。

20. API  （Application Programming Interface），应用编程接口。

21. 当打印引用时，实际上会打印出引用所指对象的 toString()方法的返回值，因为每个 类都直接或间接地继承自 Object，而 Object 类中定义了 toString()，因此每个类都有 toString()这个方法。

public static void main(String[] args)
	{
		Object object = new Object();

		System.out.println(object);
		System.out.println(object.toString());
}

22. 关于进制的表示：16 进制，逢 16 进一，16 进制的数字包括：0～9，A,B,C,D,E,F，

23.equals()方法，该方法定义在Object类当中，因此Java中的每个类都具有该方法， 对于Object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引

用是否一致，即这两个引用是否指向的是同一个对象。

对于Object类的equals()方 法来说，它等价于==。

<span>Java源码</span>

<span>public boolean equals(Object obj) {
        return (this == obj);
    }</span>

24.对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。（首先判断是否长度一致，然后按字符比较）

Java String 源码
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

25. 对于 String 对象的相等性判断来说，请使用 equals()方法，而不要使用==。

26. String 是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新 的String 对象，而不是向原有的 String 对象追加内容。

*************************************String Pool（字符串池）**********************************

28. String s = “aaa”;（采用字面值方式赋值）

1)   查找 String Pool 中是否存在“aaa”这个对象，如果不存在，则在 String Pool 中创建 一个“aaa”对象，然后将 String  Pool 中的这个“aaa”对象的地址返回来，赋给引

用变量 s，这样 s 会指向 String Pool 中的这个“aaa”字符串对象

2)   如果存在，则不创建任何对象，直接将 String Pool 中的这个“aaa”对象地址返回来， 赋给s 引用。

String str3 = "bbb";
String str4 = "bbb";
System.out.println(str3 == str4);

29. String s = new String(“aaa”);

1)   首先在 String Pool 中查找有没有“aaa”这个字符串对象，如果有，则不在 String Pool 中再去创建“aaa”这个对象了，直接在堆中（heap）中创建一个“aaa”字符串对象，然后将堆中的这个“aaa”对象的地址返回来，赋给 s 引用，导致 s 指向了堆中 创建的这个“aaa”字符串对象。

2)     如果没有，则首先在 String Pool 中创建一个“aaa“对象，然后再在堆中（heap）创 建一个”aaa“对象，然后将堆中的这个”aaa“对象的地址返回来，赋给 s 引用， 导致 s 指向了堆中所创建的这个”aaa“对象。

<strong><span>String s = "hello";
String s1 = "hel";
String s2 = "lo";

System.out.println(s == s1 + s2); //相当于比较两个对象的地址

System.out.println("----------------");

System.out.println(s == "hel" + "lo");//相当于比较字符串池中是否存在hello</span></strong>

intern()方法  寻找池中对象 

package testPackage;
class Test {
    public static void main(String[] args) {
        String hello = "Hello", lo = "lo";
        System.out.print((hello == "Hello") + " ");
        System.out.print((Other.hello == hello) + " ");
        System.out.print((other.Other.hello == hello) + " ");
        System.out.print((hello == ("Hel"+"lo")) + " ");
        System.out.print((hello == ("Hel"+lo)) + " ");
        System.out.println(hello == ("Hel"+lo).intern());
    }
}
class Other { static String hello = "Hello"; }

true true true true false true

C# 类中访问修饰符的优先级与用法（public, internal, protected, private）

首先：类成员的访问级别是以类的访问级别为上限的！ 也就是类的访问级别低时，类成员的访问级别高也无法突破类的访问级别

public级别，作用域是这个解决方案（）

internal级别，作用域是整个装配集（Assembly）

protected级别，作用域是整个解决方案（）中以它自己的类为基类以及它的派生类

private级别，作用域是它自己的类内部（class）

以下的例子中把人可以操作的和人不可以操作的通过修饰类型进行划分（人可以操作的有加油加速这种动作，而人不能凭借意念随便修改发动机转速等）

public class Vehicle
{

封装的字段，属性和函数：（这些都不允许随便被赋值，直接用private封装，用只读属性来调用现实）

        protected int _rpm;// 发动机转速，也应该封装成属性，但是为了演示protected的效果我把他写成protected修饰的字段，protected一般是给方法用的，比如下面的Burn函数。

        private int _fuel;//油量

        private int _speed//速度
        {
            get{ return _rpm / 100;}
        }

//耗油(发动机的事情),我既不想把Burn方法暴露给外界引发错误调用，又想让我的子类Car访问,使用protected
        protected void Burn(int a)
        {
            _fuel = _fuel - a;
        }

/暴露出来的函数：/

        //加油（人的事情）
        public void Refuel()
        {
            _fuel = 100;
        }

        //加速_汽车通用_1000（人的事情）
        public virtual void Accelerate()
        {
            Burn(1);
            _rpm += 1000;
        }

        //看速度表（人的事情）
        public void ShowSpeed()
        {
            Console.WriteLine(Speed);
        }

        //看油表（人的事情）
        public void ShowFeul()
        {
            Console.WriteLine(_fuel);
        }

}

小轿车类

    public class Car : Vehicle 
    {
        //加速_轿车专用_1500（人的事情）
        public override void Accelerate()
        {
            Burn(1);
            _rpm += 1500;
        }
    }

跑车类

    public class RaceCar : Car
    {
        //涡轮增压_跑车特有_3000（人的事情）
        public void TurBoAccelerate()
        {
            Burn(2);
            _rpm += 3000;
        }
    }

公交车类 这里又有protected的一个特性，只有在通过派生类类型发生访问时，基类的受保护成员在派生类中才是可访问的 换句话说，就是以出现protected的类为基类，派生出的类，在这个类内部才可以用protected修饰的字段，属性和方法。

    public class Bus : Vehicle
    {
        public void SlowAccelerate()
        {
            Burn(1);
            _rpm += 500;//这里可以使用_rpm
        }
        static void Main(string[] args)
        {
            Bus bus = new Bus();
            bus._rpm = 10000;‘//这里可以使用_rpm
            bus.Burn(1);//这里可以使用Burn()
        }
    }

但是如果在其他类中，比如：

    class Program
    {
        static void Main(string[] args)
        {
            Bus bus = new Bus();
            bus.Burn(1);//这句话无法编译通过
            bus._rpm = 10000;//这句话无法编译通过
            
        }
    }

虽然还是派生类的实例对象，但是不在派生类中，所以protected修饰的字段和属性是无法执行的。

C#学习日记21----封装 与 访问修饰符

封装:

       被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。也就是把里面实现的细节包起来，这样很复杂的逻辑经过包装之后给别人使用就很方便，别人不需要了解里面是如何实现的，只要传入所需要的参数就可以得到想要的结果。封装使用访问修饰符 来实现。一个访问修饰符 定义了一个类成员的范围和可见性。

访问修饰符:

            在 类class的声明与定义  中我简略的介绍了访问修饰符，不是很具体，这里我们深入学习访问修饰符；

              在C#中访问修饰符有5个public、private、protected、internal、protected internal;

public修饰符

         public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。(不限制对成员的访问，子类可以，对象也可以)

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

输出结果：

在上面的例子中student中的所有成员都是public类型访问，所以他的实例化对象 stu 能够访问所有成员。

private修饰符

Private 访问修饰符允许一个类将其成员变量和成员方法对他的对象进行隐藏。只有同一个类中的方法可以访问它的私有成员。即使是类的实例也不能访问它的私有成员 (不允许他的子类或对象访问)。

我们将上面的例子利用下：

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

由于在student类中对变量 Chinese、Math 方法 Total 有private 访问限制，所以无法通过对象stu 访问

protected修饰符

Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。（不允许对象访问，允许类中的方法访问，允许子类访问）

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

internal修饰符

Internal 访问修饰符允许一个类将其成员变量和成员方法暴露给当前程序集中(当前项目)的其他方法和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的程序集（项目）内的任何类或方法访问。

要学习internal修饰符，我们就得先学习使用Vs2010创建多个工程以及工程与工程的引用方法：

先创建一个工程文件：命名为 Test_internal

点击确定后，找到解决方案管理器：

右键 解决方案“Test_internal”(1个项目) --->添加--->新建项目---->visual C#--->控制台; 在名称栏中我们命名为Class_internal 确定；这样我们就创建了2 个项目（程序集）

其实我们上面输入的名称就是我们定义的命名空间的名称，打开代码Class_internal的命名空间是 namespace Class_internal, Test_internal 的命名空间是namespace Test_internal,我们在一个工程里通过using 命名空间来引用另一个工程的内容，不过在此之前我们还得 在 “引用” 列表中添加被引用的工程路径：

右键 “引用”--->添加引用--->项目。 在项目名称列表中找到要引用的项目名称这里我们选 Class_internal 单击确定，引用列表中就会多出 Class_internal 引用成功

我们打开Class_internal中的program.cs编辑以下代码

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

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

 我们在Class_internal中使用internal与public访问类型，在另一个项目Test_internal中只能访问到public访问类型。这就是internal

protected internal修饰符

                      Protected Internal 访问修饰符允许一个类将其成员变量和成员函数对同一应用程序内(项目)的子类以外的其他的类对象和函数进行隐藏。（不太明白） 换句话说就是同时拥有protected 与 internal的性质，protected访问限制在子类，能够在另一个程序集（项目）中通过继承方式访问到，internal是限制其他项目的访问，两个限制叠加，protected类型在另一个项目中不能通过继承的子类访问到。

以上就是C#学习日记21----封装 与 访问修饰符的内容。

关于C#封装public访问修饰符和c# 访问修饰符的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于12、类成员访问修饰符public/private/producted/readonly、6 包，单例模式，访问修饰符（public、protected，private）Object String、C# 类中访问修饰符的优先级与用法（public, internal, protected, private）、C#学习日记21----封装 与 访问修饰符的相关信息，请在本站寻找。