C#基础系列第三篇

前言： 完全是我在学习过程中记录的笔记，只不过分享一下让很多刚开始学习.net编程的人能够很快的学会C#语言

1. 访问修饰符(1)

(1)用在类型上面

     1)public  表示在任何地方都能够被访问

     2)internal 表示只能在当前项目中被访问

 (2)用在成员上面(字段方法等)

     1)public 可以在任何地方被访问

     2)private

     3)protected

     4)internal 表示只能在当前程序集完全公开

     5)protected internal

 (3)图示说明5个访问修饰符的关系

1. 访问级别约束

(1) 子类的访问级别不能比父类的高

            class MyBase

            {

            }

            public class MySub:MyBase

            {

            }

            //这样写是错误的

(2) 字段和属性的访问级别不能高于对应成员的访问级别

            class MyField

            {

            }

            public class MyClass

            {

                   MyField m;

                   public MyField M

                   {

                          get{return m;}

                          set{m=value;}

                   }

            }

            //这样写是错误的

(3) 方法的访问级别不能高于参数与返回值的访问级别

        class MyInternal

           {

           }

           public class MyClass

           {

                  public MyInternal Func(MyInternal f)

                  {

                  }

           }

           //这样写是错误的

 (4)"可访问性不一致"的错误

 (5)不允许访问不可访问的成员 //写代码遵循这句话

1. 静态方法

(1) 语法：

            public static 返回类型 方法名(参数名)

            {

                   //过程

            }

(2) 静态方法通过类名进行调用

             class MyStatic

            {

                   public static string GetString(string str)

                   {

                          return "$" + str + "$";

                   }

            }

            class Program

            {

                   static void Main(string[] args)

                   {

                          string Name = MyStatic.GetString("韩迎龙");

                          Console.WriteLine(Name);

                   }

            }

     (3)静态方法，静态字段等都称为静态成员

            1)静态成员属于类

            2)实例成员属于当前对象

                class WindowsPhone

                   {

                          public static int num;

                          public WindowsPhone()

                          {

                                 num++;

                          }

                          string sim;

                          public string Sim

                          {

                                 get { return sim; }

                                 set { sim = value; }

                          }

                   }

                   class Program

                   {

                          //静态属于所有该类的对象，是类的一个成员，而实例成员只属于当前的实例

                          static void Main(string[] args)

                          {

                                 for (int i = 0; i < 100; i++)

                                 {

                                        new WindowsPhone();

                                 }

                                 WindowsPhone windows = new WindowsPhone();

                                 windows.Sim = "232434343";

                                 Console.WriteLine(windows.Sim);

                                 Console.WriteLine(WindowsPhone.num);

                          }

                   }

     (4)静态成员和实例成员的使用

            1)静态成员

                   ->在静态方法中，可以访问静态成员

                   ->在静态方法中，不可以直接访问实例成员

                   ->调用前初始化

            2)实例成员

                   ->在实例方法中，可以直接访问静态成员

                   ->在实例方法中，可以直接访问实例成员

                   ->实例化对象时初始化

     (5)如果一个类里面的成员全是静态的，那么可以将这个类写静态的

            static class MyClass

            {

                   //成员

            }

     (6)静态类的成员必须都是静态的

            static class MyClass

            {

                   public static int GetNum()

                   {

                          return new Random().Next();

                   }

            }

            class Program

            {

                   static void Main(string[] args)

                   {

                          int num= MyClass.GetNum();

                          Console.WriteLine(num);

                   }

            }

1. 静态成员

(1) 给字段的赋值都是由构造方法完成的，即使写字段的时候，对其进行初始化，也是有构造方法赋值的

     (2)如果调试的时候，回先执行字段的初始化过程，在进入到构造函数的。

            class MyClass

            {

                   public static int numStatic = 20;

                   //在构造方法里面赋值的

                   int num = 10;

                   public MyClass()

                   {

                         

                   }

            }

            class Program

            {

                   static void Main(string[] args)

                   {

                          new MyClass();

                   }

            }

            //断点调试先执行int num = 10;，在执行构造方法

     (3)静态字段的赋值也是由静态构造方法完成的

            1)语法：

                   static 类名()

                   {

                          //赋值过程

                   }

            2)静态构造方法只能这样写

            3)静态构造方法不允许手动调用，由系统自动调用

            4)当程序第一次访问该类的时候(无论是静态还是非静态)

            5)静态构造方法只被调用一次

                   class MyClass

                   {

                          public static int numS;

                          static MyClass()

                          {

                                 numS = 10;

                          }

                          int numI;

                          public MyClass()

                          {

                                 numI = 20;

                          }

                   }

                   class Program

                   {

                          static void Main(string[] args)

                          {

                                 //第一种情况 访问实例成员

                                 new MyClass();

                                 new MyClass();

                                 //第二种  访问静态成员

                                 MyClass.numS = 40;

                          }

                   }

                   //在静态构造方法前面加断点执行

 (4)构造方法的默认值

            1)构造方法就是为字段赋值用的，如果没有显示的提供赋值，那么会有默认值

                   ->数值类型  0

                   ->字符类型  /0

                   ->字符串类型 null

                   ->bool类型 false

 (5)静态成员只有在第一次访问的时候进行初始化，但是会一直保留在内存中

            1)对于静态字段容易造成内存的溢出

                   class Program

                   {

                          static List<string> list = new List<string>();

                          static void Main(string[] args)

                          {

                                 while (true)

                                 {

                                        list.Add("123232435343");

                                 }

                          }

                   }

1. 静态类的继承问题

(1) 静态类不允许被继承,静态类只能继承自object

     (2)继承(多态)与静态是两个互斥的概念

     (3)静态类不能实现任何接口

     (4)sealed关键字

            1)密封类(密闭类)，表示不能别继承

            2)string就是密封类

            3)可以使用重写方法不再被重写

     (5)静态类的本质

            1)查看IL代码 ：abstract+sealed

            2)不允许实例化 abstract

            3)不允许被继承 sealed

     (6)举例说明：

            class MyClass1

            {

            }

            sealed class MyClass2

            {

            }

            class MySub : MyClass1

            {

            }

            class MySub2:MyClass2  //这样写是错误的

            {    

            }