C#类基础

一. C#中的类定义：修饰、继承、接口

修饰符关键字：

1. 使用 class 来声明类，默认情况下只有在当前项目中才可以进行访问

    使用 internal(访问修饰符) 来显式的指定这一点（没有必要）。

class MyClass{
    // Class Members
}

//显式指定
internal class MyClass{
    // Class Members
}

2. 使用 public(访问修饰符) 来修饰类，可被其他项目中的代码访问。

public class MyClass{
    // Class Members
}

3. 使用 abstract 来修饰类，指定类是抽象的，不能实例化，只能继承，可存在抽象对象，与访问修饰符可共用，与 sealed 互斥。

public abstract class MyClass{
    // Class Members，may be abstract
}

4.使用 sealed 来修饰类，指定类是密封的，不能继承，与访问修饰符可共用，与 abstract 互斥。

public sealed class MyClass{
    // Class Members
}

继承： 

主要有以下规则：

1. 只能存在一个基类；

2. 继承抽象类必须实现所继承的所有抽象成员，除非派生类也是抽象的；

3. 派生类的可访问性低于基类，编译器要求；

4. 基类位于继承列表第一项，接口跟在后面；

//基类
public class MyBase{
    // Class Members
}

//派生类
internal class MyClass : MyBase , IMyInterface{
    // Class Members
}

接口：

和类声明方式类似，使用 interface 关键字。

使用 public 和 internal 访问修饰符关键字，不能使用 abstract 和 sealed 关键字。

public interface IMyInterface{
    // Interface Members
}

二. System.Object

Object 类 (System) | Microsoft Docs

所有类的基类，所以所有类均可访问该类中受保护和公共成员，可使用以下方法：

方法	返回类型	虚拟	静态	说明
Object()	N/A	否	否	构造函数
~Object()	N/A	否	否	析构函数
Equals(object)	bool	是	否	查看对象参数是否引用同一个对象（对象为引用类型）进行比较
Equals(object, object)	bool	否	是	对两个对象进行比较，使用了Equals(object)函数，Object p1 = p2.Copy()
ReferenceEquals(object, object)	bool	否	是	比较传入的两个对象是不是同一个实例的引用，Object p1 = Object p2
ToString()	string	是	否	返回对应对象实例的字符串
MemberwiseClone()	object	否	否	创建新对象并复制成员
GetType()	System.Type	否	否	返回System.Type类型的对象
GetHashCode()	int	是	否	对象的散列函数

三. 构造函数和析构函数

如果有自己特殊的需求，可以提供自己的构造函数和析构函数，便于初始化和清理对象。

构造函数用于创建对象实例：

//简单构造函数
class MyClass{
    public MyClass(){
        //Constructor code
    }
}

//私有构造函数，仅包含静态成员的类使用，不允许创建对象实例
class MyClass{
    private MyClass(){
        //Constructor code
    }
}

//参数构造函数，依据自己的需求
class MyClass{
    public MyClass(){
        //Constructor code
    }

    public MyClass(int val){
        //Constructor code，uses val
    }

}

析构函数用于清除对象：

//简单析构函数，隐式调用基类析构函数
class MyClass{
    ~MyClass(){
        //Destructor code
    }
}

构造函数执行顺序为从基类到派生类，从Object()，MyBase()，MyClass()顺序而下执行。

可通过Base调用不同的基类构造函数: Object() — MyBase(int i) — MyCalss(int i, int j)

public class MyBase{
    public MyBase(){
        //Contructor code
    }
    public MyBase(int i){
        //Contructor code
    }
}

public class MyClass : MyBase{
    public MyClass(){
        //Contructor code
    }
    public MyClass(int i){
        //Contructor code
    }
    public MyClass(int i, int j) : Base(i) {
        //Contructor code
    }
}

可通过this调用非默认构造函数: Object() — MyBase(int i) — MyCalss(int i, int j) — MyCalss()

public class MyBase{
    public MyBase(){
        //Contructor code
    }
    public MyBase(int i){
        //Contructor code
    }
}

public class MyClass : MyBase{
    public MyClass() : this(i, j) {
        //Contructor code
    }
    public MyClass(int i, int j) : Base(i) {
        //Contructor code
    }
}