第9章 定义类

9.1 c#中的类定义
c#使用class关键字来定义类
class MyClass
{
//class members
}
ps:默认情况下，类声明为内部的，可以使用internal访问修饰符关键字来显式指定这一点
internal class MyClass
{
//class members
}
这个类和上面定义的类的效果是一样的


另外，类可以是公共的：
public class MyClass
{
//class members
}


抽象的（不能实例化，只能继承，可以有抽象成员）
public abstract class MyClass
{
//class members
}
其中MyClass是一个公共的抽象类，也可以是内部抽象类


密封的（不能继承）
public sealed class MyClass
{
//class members
}
其中MyClass是一个公共的密封类，也可以是内部密封类


类的继承（：）c#中只能继承一个基类
public class MyClass:MyBase
{
//class members
}
如果继承了一个抽象类，那么就必须继承所有的抽象成员（除非派生类也是抽象的）


编译器不允许派生类的可访问性高于基类（就是说你的基类是internal的，你派生出public很明显是不对的，因为万一你用到基类的成员呢？）
如下列代码不能编译
internal class MyBase
{
//class members
}


public class MyClass:MyBase
{
//class members
}


接口也是用冒号继承，如果指定了基类，他必须紧跟在冒号后面，才是接口。如果没有指定基类，则接口跟在冒号后面。必须使用逗号来分隔基类名和接口名
例子：
①、添加一个接口
public class MyClass:IMyInterface
{
//class members
}


这样声明无效
public class MyClass:IMyInterface,MyBase //基类应该紧跟在冒号后面
{
//class members
}
正确
public class MyClass:MyBase,IMyInterface
{
//class members
}


②指定多个接口
public class MyClass:MyBase,IMyInterface,IMySecondInterface
{
//class members
}


接口的定义
interface IMyInterface
{
//Interface members
}
与类一样，public和internal的使用方法是一样的
public interface IMyInterface
{
//Interface members
}
但是，不能使用abstract 和sealed(这和接口是矛盾的，自己想想)


接口可以多继承
public interface IMyInterface:IMyBaseInterface,IMyBaseInterface2
{
//Interface members
}
ps:接口不是类，所以没有继承System.Object


9.3 构造函数和析构函数
在c#中定义类时，常常不需要定义相关的构造函数和析构函数，因为在编写代码时，如果没有提供他们，编译器会自动添加他们。但是，如果有必要，可以提供
自己的构造函数和析构函数，以便初始化对象和清理对象。
例子：
class MyClass
{
public MyClass()
{
//Constructor code.
}
}
构造函数与类同名，而且如果没有参数的话（就会成为默认的构造函数）


当把默认的构造函数修饰为private，就无法实例这个类了，如
class MyClass
{
private MyClass()
{
//Constructor code.//无法new这个函数
}
}


通过提供参数，添加非默认的构造函数
class MyClass
{
public MyClass()
{
//Default constructor code.
}
public MyClass(int myInt)
{
//Nondefault constructor code(uses myInt).
}
}
//就是new的时候可以选择new哪个函数


析构函数：在.NET中析构函数称为Finalize(),但这不是我们用于声明析构函数的名称：
class MyClass
{
~MyClass()
{
//Destrouctor body.
}
}
当进行垃圾回收时，就执行析构函数中的代码，释放资源。在调用这个析构函数后，还将隐式地调用基类的析构函数，包括System.Object根类中的Finalize()调用
这样定义构造函数可以让.NET Framework确保调用Finalize()


构造函数的执行序列
概念：无论怎么继承基类，各个类之间的构造函数顺序应该是：从System.Object.Object()开始，因为你实例化一个类，考虑到当前成员可能用到基类的一些
成员，所以应该调用上一层的父类的构造函数。
默认的执行顺序是调用不带参数的构造函数，但是如果碰到要指定调用有参数的可以使用base
如：
public class MyBaseClass
{
public MyBaseClass()
{
}
public MyBaseClass(int i)
{
}
}


public class MyDerivedClass:MyBaseClass
{
public MyDerivedClass()
{
}
public MyDerivedClass(int i)
{
}
public MyDerivedClass(int i,int j)
{
}
}
默认执行顺序
System.Object.Object()的构造函数
MyBaseClass.MyBaseClass()的构造函数
MyDerivedClass.MyDerivedClass()的构造函数


public class MyBaseClass
{
public MyBaseClass()
{
}
public MyBaseClass(int i)
{
}
}


public class MyDerivedClass:MyBaseClass
{
public MyDerivedClass()
{
}
public MyDerivedClass(int i)
{
}
public MyDerivedClass(int i,int j):base(i)
{
}
}
MyDerivedClass myObj=new MyDerivedClass(4,8);
执行顺序
System.Object.Object()的构造函数
MyBaseClass.MyBaseClass(int i)的构造函数
MyDerivedClass.MyDerivedClass(int i,int j)的构造函数


ps:base关键字指定.NET实例化过程使用基类中具有指定参数的构造函数


this:理解，其实无论是base还是this关键字，结果都是指定上一个构造函数，但是base是指定基类的，而this是指定本类的（因为：都可以理解为继承）
public class MyBaseClass
{
public MyBaseClass()
{
}
public MyBaseClass(int i)
{
}
}


public class MyDerivedClass:MyBaseClass
{
public MyDerivedClass():this(5,6)
{
}
public MyDerivedClass(int i)
{
}
public MyDerivedClass(int i,int j):base(i)
{
}
}


MyDerivedClass myObj=new MyDerivedClass();
System.Object.Object()的构造函数
MyBaseClass.MyBaseClass(int i)的构造函数
MyDerivedClass.MyDerivedClass(int i,int j)的构造函数
MyDerivedClass.MyDerivedClass()的构造函数


9.6 接口和抽象类（区别）
相似：
①、抽象类和接口都包含自己的成员
②、接口和抽象类都不能实例化
③、但可以声明接口和抽象类，然后把继承了这个接口或者抽象类的对象赋值给声明的接口和抽象类变量，就可以调用这个声明对象的成员。


区别：
①、只能继承一个基类，但是可以继承无数个接口
②、抽象类可以有抽象成员（没有代码体）和非抽象成员（有代码体或者虚拟的），而接口的成员都是没有代码体的
③、接口成员时公共的，抽象类可以是私有的、受保护的、内部的。
接口不能包含字段、构造函数、析构函数、静态成员或常量（因为接口根本不是类）

什么情况下用接口，什么情况下用抽象类
抽象类是用在对一些对象的抽象化，而接口则是对一个功能方法的提取，并且可以是不同的类型
如：
抽象类：电脑--》①、笔记本、台式
电视--》①、液晶电视、普通电视
这个时候就应该使用抽象类了
但是，有一个功能叫看综艺节目，我既可以在电脑上看，也可以在电视看，你只要继承这个接口，并且实现这个看综艺节目接口成员的方法，不管你什么类都可以
看这个时候就应该用接口了。


9.7 结构类型
结构是值类型，类是引用类型


9.8 浅度和深度复制
复制引用称为浅度复制，完全复制称为深度复制