C#基础已经学了七天了，随着知识点的深化，脑子里开始混乱了，总觉得好像会但实际又不会，我想这也许就是人的大脑记忆的缺陷，今天学着用画知识体系结构的方法来巩固这七天来所学的知识，发现还是挺有用的，继续坚持！

接下来就是今天所学的知识了：

类成员

1、访问修饰符：用于指定声明的成员或类型的可访问性。
   public：访问不受限制。
   protected：访问仅限于包含类或从包含类派生的类型，只能发生在继承中间。
   internal：访问仅限于当前的程序集。
   private：访问仅限于本类型，例：在一个程序集中定义的私有类，在程序集的其他的类中就不可以访问了。
   protected internal：访问仅限于当前程序集或从包含类派生的类型，在一个程序集中可以访问，在继承中也可以访问 (在当前程序集内，没有继承关系也可以访问，这是protected不可以的，在继承中也可以适用)。

注：
     1）一个自定义类型的成员（类型的成员，如类中的方法、字段）或类型（结构体、接口、类）只能有一个访问修饰符， 但使用protected internal组合时除外；
     2）命名空间不允许使用访问修饰符，命名空间没有访问权限。
     3）枚举的访问修饰符都是public但是微软都定义好了，所以不用写出来。
     4）在命名空间中定义的类是顶级类，如果不加任何访问修饰符，则默认是public或internal
            
2、 构造函数包括：
            静态构造函数：发生在第一个对象在实例化的时候，如果不new就不会实例化，初始化类中的静态字段。

私有构造函数：当一个类的构造函数定义为private时在类的外部就不能对其实例化。

实例化构造函数：是实例化对象的时候执行的，一个对象在实例化时只执行一个实例化构造函数，实例化构造函数只要能生成重载，就可以有多少实例化构造函数。

注:构造函数与类名相同且无返回值，不带参数的构造函数称为“默认构造函数”。无论何时，只要使用 new 运算符实例化对象，并且不为 new 提供任何参数，就会调用默认构造函数。

析构函数：只能有一个，以~B( )形式出现，当整个对象被释放的时候调用析构函数，一般没有特殊要求不要定义析构函数。

总之:构造函数与析构函数的区别：
                1）构造函数是在对象实例化的时候调用，只要类是非static，系统在运行时就自动为类添加一个构造函数， 而析构函数是对象释放的时候调用的，并且不能在结构中定义析构函数；
                2）构造函数的作用是初始化类中的数据，而析构函数是在对象释放的时候释放类中的数据，无法调用析构函数， 它是被自动调用的，析构函数不能有访问修饰符，也不能有参数；
                3）构造函数可以有多种，也可以重载，析构函数只能有一个。

单例模式：
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = A.CreatA();//通过调用A类的方法CreatA()来实例化类
            A a1 = A.CreatA();
            A a2 = A.CreatA();//无论实例化多少次都是一样的，a、a1、a2都是一样的
            if (a.Equals(a1))
            {
                Console.WriteLine("我们是一样的！");
            }//判断两个对象a1和a是否是完全一致的
        }     
       
    }
    class A
    {
        static A i;//定义一个类型为A的变量i实现单例模式，只能实例化一个对象
        private A()
        {
          
        }//定义一个私有的构造函数，在类的外部就无法对其实例化
       public  static  A  CreatA()
        {
            if (i == null)
            {
                i = new A();//本次实例化的时候就对i赋值，下次在实例化的时候判断i，i不为空就不会重新实例化，即单例模式
                return i;
            }
            else
            {
                return i;
            }
        }//为类写一个方法，方法返回值是A,方法的作用是在类内部实例化类
    }   
}

namespace ConsoleApplication9
{
    class Program
    {
        static void Main(string[] args)
        {

b b1 = new b();
            b b2 = new b();
            b1.a();
            b2.a();
        }
    }
    class b
    {
        public int i = 10;
        public b()
        {
            Console.WriteLine("我是构造函数");
        }
        public void a()
        {
            Console.WriteLine(i);
        }
        ~b( )
        {
            Console.WriteLine("我是析构函数");
        }
    }
}

3、字段是用来存储数据的，是类中唯一用来存储数据的，其他的都是来执行功能的，不建议把字段定义成公有的，这样保证了数据的安全性， 想要外部访问字段，要定义一个方法来进行限制。

回忆一个知识点：1)变量 常量 只读字段（只能在类里出现，readonly）：变量与只读字段是非静态的，可以直接用对象名.变量名或只读字段访问； 常量是静态的，属于类，用类名.常量访问。
           2)如果在变量前加static变为静态成员就可以直接用类名加点访问。
           3)只读字段是该对象中的常量，在该对象中一成不变；而常量是在整个类中都不会改变。

属性：用来封装类中的数据，属性是一个或两个代码块，表示一个 get 访问器和/或一个 set 访问器。
       get访部器体与方法体相似,它必须返回属性类型的值。执行 get 访问器相当于读取字段的值。
       set 访问器类似于返回类型为 void 的方法。它使用称为 value 的隐式参数，此参数的类型是属性的类型。

注：属性中只有get表示该字段是只读字段，只有set表示是只写字段，既有get又有set表示该字段是可读可写字段， 与字段不同，属性不作为变量来分类。因此，不能将属性作为 ref 参数或 out参数传递。

例：
   class Program
    {     
        int age=22;//定义一个整型字段age，默认值是22
        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                if (value  > 0 && value  < 150)
                {
                    age = value;
                }//如果为age赋的值在0-150之间就允许赋值，否则抛出异常
                else
                {
                    throw new Exception ("年龄超过范围了！！！");
                }
            }
        }//属性Age用来操作age在内部设置其值的赋值条件
        static void Main(string[] args)
        {
            try
            {
                Program p = new Program();
                p.Age = 200;//调用Age属性操作age设置其值为200，此时会返回错误提示
                Console.WriteLine(p.Age);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }//获取异常信息

}     
     
    }

4、索引器：索引器类似于属性，不同的是他们的访问器采用参数，使用索引器可以用于类似于数组的方式为对象建立索引， 将对象本身当成序列，获取下标值。

注：索引器的索引下标不同于集合中的索引，没有固定格式，可以不为int，也可以有很多个（即索引器可以有多个形参）。例如：
   
     class Program
    {    
             
        static void Main(string[] args)
        {
            E a=new E ();
            a[0] = "aaaaa";//利用索引器获取arr中的值，直接用对象加下标访问
            Console.WriteLine(a[0]);

a[1.0] = 1111;//利用索引器获取 Dictionary<double, int> di中的值，下标是double类型的
            Console.WriteLine(a[1.0]);

Console.WriteLine(a[1,1]);//利用索引器获取二维数组array的第二行第二列的值，其索引是两个int类型的
           
        }     
     
    }
    class E
    {
        string[] arr = new string[] { "1","j","d"};
        public string this[int i]
        {
            get
            {
                return arr[i];
            }
            set
            {
                arr[i] = value;
            }

}//int类型作为索引

Dictionary<double, int> di = new Dictionary<double, int>();
        public int this[double d]
        {
            get
            {
                return di[d];
            }
            set
            {
                di[d] = value;
            }
        }//定义一个索引器，其索引是double类型

int[,] array = new int[,] { {1,2,3},{3,4,5}};
        public int this[int a,int b]
        {
            get
            {
                return array [a,b];
            }
            set
            {
                array[a, b] = value;
            }
        }//定义一个索引器，其索引是两个int类型

}

Equals 与“==”之间的区别：1）如果被比较的两个相同对象都是值类型，则二者返回的都是true                                
                                int a = 1;
                                int b = 1;
                                Console.WriteLine(a==b);
                                Console.WriteLine(a.Equals(b));
                           2）如果被比较的两个相同对象都是引用类型，则二者返回的都是false
                                object o = "1";
                                object b = "2";
                                Console.WriteLine(o==b);
                                Console.WriteLine(o.Equals(b));
                           3）如果被比较的两个相同对象是由值类型转换为引用类型，则“==”返回false，“Equals”返回true
                                object o = 1;
                                object b = 1;
                                Console.WriteLine(o==b);
                                Console.WriteLine(o.Equals(b));