c# 中内部类的简单介绍

最近在看java一方面的书籍，看到一个很奇怪的问题，java类中还可以再定义一个类，这种结构非常特殊！后来才发现我知识浅薄了，原来C#中也有内部类，之前都一直没有注意过这个语法结构！

使用内部类有这样几个好处: 

（1）抽象外部类的某一状态下的行为，隐藏实现，通过修改该内的访问修饰符，可以设置仅有外部类可以访问该类

（2）扩展了命名空间，可以将外部类的类名作为内部类的一个命名空间(这里只是相当于，但不是真正的命名空间)

（3）内部类可以当作外部类的一个扩展，可以活的更好的封装。

 上面的这些特点胡乱的总结了一下，可能有些词不达意，下面有些具体例子:

 

1.内部类的定义:

嵌套类：在一个类中定义另外一个类，主要分为静态嵌套类和非静态嵌套类(又称之为"内部类") 

内部类的定义结构:(1)在一个类中直接定义类(2)在一个方法中定义类(3)匿名内部类

 

2.外部类访问内部类

 1  namespace  GameStatistical.Test.InnerClass
 2  {
 3       public   class  Person
 4      {
 5           public   class  Student
 6          {
 7               public   static   int  age;
 8               internal   static   int  height;
 9               private   static   string  sex;
10 
11               public   virtual   void  Show()
12              {
13                  Console.WriteLine( " 年龄: " + age);
14                  Console.WriteLine( " 身高: " + height);
15              }
16 
17               internal   void  Display()
18              {
19                  Console.WriteLine( " internal " );
20                  Console.WriteLine( " 年龄: "   +  age);
21                  Console.WriteLine( " 身高: "   +  height);
22              }
23          }
24 
25 
26           public   void  Show()
27          {
28              Student.age  =   21 ;
29              Student.height  =   75 ;
30              Student student  =   new  Student();
31              student.Show();
32              student.Display();
33          }
34      }
35  }

 

该段代码定义了一个外部类Person 和一个内部类Student， 其中内部类Student中使用了各种修饰符修饰的变量和方法，从上面的例子可以看出外部类只能够访问嵌套类中修饰符为public、internal的字段、方法、属性。

调用外部类的 Show（）方法运行得到如下结果:

 

 

3.内部类访问外部类

 1  namespace  GameStatistical.Test.InnerClass
 2  {
 3       public   class  Person1
 4      {
 5           private   string  name;
 6 
 7           public   string  Name
 8          {
 9               get  {  return  name; }
10               set  { name  =  value; }
11          }
12           private   string  sex;
13 
14           public   string  Sex
15          {
16               get  {  return  sex; }
17               set  { sex  =  value; }
18          }
19 
20           public   void  Show1()
21          {
22              Console.WriteLine( this .name  +   " ==> "   +   this .sex);
23          }
24 
25           private   static   void  Show2()
26          {
27              Console.WriteLine( " ===================> " );
28          }
29 
30           internal   void  Show3()
31          {
32              Console.WriteLine( this .name  +   " ==> "   +   this .sex);
33          }
34 
35 
36 
37           public   class  Student
38          {
39               public   void  SetPer( string  name,  string  sex)
40              {
41                  Person1 p  =   new  Person1();
42                  p.name  =  name;
43                  p.sex  =  sex;
44 
45                  p.Show3();
46                  p.Show1();
47              }
48 
49          }
50      }
51  }

 

这段代码同样定义了一个外部类Person1 和一个内部类Student,内部类中的SetPer（）调用了外部类中的方法，写这段代码我们可以发现 嵌套类可以访问外部类的方法、属性、字段而不受访问修饰符的限制

 

4.内部类的继承

 1  namespace  GameStatistical.Test.InnerClass
 2  {
 3       public   class  Person
 4      {
 5           public   class  Student
 6          {
 7               public   static   int  age;
 8               internal   static   int  height;
 9               private   static   string  sex;
10 
11               public   virtual   void  Show()
12              {
13                  Console.WriteLine( " 年龄: " + age);
14                  Console.WriteLine( " 身高: " + height);
15              }
16 
17               internal   void  Display()
18              {
19                  Console.WriteLine( " internal " );
20                  Console.WriteLine( " 年龄: "   +  age);
21                  Console.WriteLine( " 身高: "   +  height);
22              }
23          }
24 
25 
26           public   void  Show()
27          {
28              Student.age  =   21 ;
29              Student.height  =   75 ;
30              Student student  =   new  Student();
31              student.Show();
32              student.Display();
33          }
34      }
35  }

 

  内部类继承，上面的内部类定义了父类，其中public virtual void Show() 使用virtual 修饰，可以用于子类重写这个方法，看内部类继承子类是否能够重写这个方法。

 1  namespace  GameStatistical.Test.InnerClass
 2  {
 3       public   class  SubPerson:Person
 4      {
 5           public   class  SubStudent : Student
 6          {
 7               public   override   void  Show()
 8              {
 9                   base .Show();
10              }
11          }
12      }
13  }

 

  上面的代码重写了Show() 这个方法，说明内部类的继承可以通过

 

5.反射内部类

对于这段代码，是从其他网站看到的，反射内部类我们不能直接通过 "." 操作符直接来操作，而是通过 "+" 操作符。前面也提到过内部类也是一种有效的管理命名空间的方法，这里也是普通类和内部类的一点区别

反射内部类 

Activator.CreateInstance("GameStatistical.Test.InnerClass", "GameStatistical.Test.InnerClass.ReflectionPerson+Student"); 

  反射普通类

Activator.CreateInstance("GameStatistical.Test.InnerClass", "GameStatistical.Test.InnerClass.ReflectionPerson.Student"); 

 

 

在实际操作中，内部类好像使用的比较少，这里也只是非常简单的介绍，作为一个知识点总结起来。