封装:
被定义为"把一个或多个项目关闭在一个物理的或许逻辑的包中"。在面向对象顺序设计要领论中，封装是为了防备对完成细节的接见。也就是把内里完成的细节包起来，如许很庞杂的逻辑经由包装以后给他人运用就很轻易，他人不须要相识内里是怎样完成的，只需传入所须要的参数就可以获得想要的效果。封装运用接见修饰符 来完成。一个接见修饰符 定义了一个类成员的局限和可见性。
接见修饰符:
在 类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----封装 与 接见修饰符的内容，更多相关内容请关注ki4网（www.ki4.cn）！
