[原创]c#类之学习摘要

类
－－－
成员：
    常量
    字段
    方法
    特性
    事件
    索引器
    操作符
    实例构造器
    析构器
    静态构造器
    嵌套的类型声明
=================

c#中类的定义：
class myClass
{
//class members
}

定义好了一个myClass类之后，就可以实例化这个类了（对象），默认情况下，
类的定义是内部的，也就是说只能在这个定义了该类的工程里使用，关键词为：
internal , 上诉定义的myClass类也可以如下显式定义：

internal class myClass
{
//class members
}
若想让其他工程也可以使用这个类的话，就要加上一个 public 关键词。
例如：
public class myClass
{
//class members
}

除了上诉的 internal , public 的类访问修饰符，还可以定义类为抽象类和密封类。
关键词为： abstract ,sealed 。其中 abstract 类 能被继承，无法实例化！
sealed 类能被实例化，但无法继承。例如：
//抽象类 可以是公共的，也可以是内部的 internal
public abstract class myClass
{
//class members
}
//密封类 可以是公共的，也可以是内部的 internal
public sealed class myClass
{
//class members
}

也可以在类定义的时候指定为继承类，例如：
public class myClass1:myClass
{
//class members
}
但是，要注意的是，C#，只能是单继承，即只有一个基类，但可以继承多个接口。当
一个类继承的基类是抽象类的时候，必须在这个类的内部执行抽象类的所有成员，除非
类本身也是个抽象类。
有一点，需要说明一下，.net的编译器不允许派生类的可访问性比基类还高，也就说，
public 类 无法继承 internal 类的！因为 public >internal (访问性)。

上诉的：
class myClass
{
//class members
}
这个定义的类，没有显式的继承一个基类，实际上，这样定义的类隐式的都是继承System.Object
这个类的，System.Object是所有类的根，是所有类的基类。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

接口如何定义
    与申明类的方式相似 ，使用关键词 interface  例如：
    interface ImyClassInterface
    {
    // interface members
    }

    注意:访问修饰符中， abstract 和 sealed 无法在接口定义中使用！
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

构造函数和析构函数
    例如：
class myClass
{
//构造函数
public myClass()
{
}
}

这个构造函数是 public 的，所以这个类的实例就是对象可以使用这个构造函数进行创建

若是这样：
class myClass
{
//析构函数
private myClass()
{
}
}

那么这个类的实例是无法使用这个构造函数进行创建的！

当一个类是一个派生类的时候，调用构造函数和析构函数的顺序如下：
例如：

using System;
namespace namespace1
{
    class myClass
    {
    public myClass()
        Console.WriteLine("调用了myClass构造函数！");
    ~myClass()
       Console.WriteLine("调用了myClass析构函数");    
    }
    class myClass1:myClass
    {
    public myClass1()
      Console.WriteLine("调用了myClass1构造函数！");
    ~myClass1()
      Console.WriteLine("调用了myClass1析构函数");
    }

    class cls
    {
    static void Main()
    {
    myClass1 clas1=new myClass1();
    }
    
    在这个例子中，首先调用的是基类的myClass 的构造函数，然后才调用自身的构造函数，
    但调用析构函数的时候，是先调用自身的析构函数，在调用基类的析构函数，也就是说，
    构造函数和析构函数是配对的！
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝