继承
密封类
密封类（关键字sealed）是不允许其它类继承的，类似Java中的final关键字。
public sealed class SealedClassName
{
//...
}
初始化顺序
子类初始化顺序如下：
- 初始化类的实例字段；
- 调用基类的构造函数；
- 调用子类的构造函数。
using System; namespace Study
{
class Program
{
static void Main(string[] args)
{
new C(); Console.ReadKey();
}
} public class A
{
public A()
{
Console.WriteLine("A 类构造函数被调用。");
}
} public class B : A
{
public B()
{
Console.WriteLine("B 类构造函数被调用。");
}
} public class C : B
{
public C()
{
Console.WriteLine("C 类构造函数被调用。");
}
}
}
结果如下：
A 类构造函数被调用。
B 类构造函数被调用。
C 类构造函数被调用。
带参数的构造函数
Java中使用super调用父类的构造函数，而C#中则使用base，同时写法也稍微有点不同，如下：
using System; namespace Study
{
class Program
{
static void Main(string[] args)
{
new C(); Console.ReadKey();
}
} public class A
{
public A(int a, int b)
{
Console.WriteLine("A 类构造函数被调用。");
Console.WriteLine(a + ":" + b);
}
} public class B : A
{
public B(int name1, int name2) : base(name1, name2)
{
Console.WriteLine("B 类构造函数被调用。");
}
} public class C : B
{
public C() : base(, )
{
Console.WriteLine("C 类构造函数被调用。");
}
}
}
输出如下：
A 类构造函数被调用。
:
B 类构造函数被调用。
C 类构造函数被调用。
方法多态
子类重写父类的方法使用virtual和override实现。
1 using System;
2
3 namespace Study
4 {
5 class Program
6 {
7 static void Main(string[] args)
8 {
9 new C().func();
10
11 Console.ReadKey();
12 }
13 }
14
15 public class A
16 {
17 public virtual void func()
18 {
19 Console.WriteLine("A 类的 func 方法调用。");
20 }
21 }
22
23 public class B : A
24 {
25 public override void func()
26 {
27 Console.WriteLine("B 类的 func 方法调用。");
28 }
29 }
30
31 public class C : B
32 {
33 public override void func()
34 {
35 base.func();
36 Console.WriteLine("C 类的 func 方法调用。");
37 }
38 }
39 }
输出如下：
B 类的 func 方法调用。
C 类的 func 方法调用。
阻止重写方法
如果不希望虚方法被重写，可以使用sealed关键字。
1 public sealed override void func()
2 {
3 //...
4 }
新成员方法隐藏老成员方法
使用new关键字可以隐藏非虚的老成员方法。
1 using System;
2
3 namespace Study
4 {
5 class Program
6 {
7 static void Main(string[] args)
8 {
9 C c = new C();
10 c.func();
11 ((B)c).func();
12 ((A)c).func();
13
14 Console.ReadKey();
15 }
16 }
17
18 public class A
19 {
20 public void func()
21 {
22 Console.WriteLine("A 类的 func 方法调用。");
23 }
24 }
25
26 public class B : A
27 {
28 public new void func()
29 {
30 Console.WriteLine("B 类的 func 方法调用。");
31 }
32 }
33
34 public class C : B
35 {
36 public new void func()
37 {
38 Console.WriteLine("C 类的 func 方法调用。");
39 }
40 }
41 }
输出如下：
C 类的 func 方法调用。
B 类的 func 方法调用。
A 类的 func 方法调用。
接口
C#中不允许多重继承，但接口可以多重继承。
接口声明
声明一个接口的写法如下：
public interface ICustom
{
}
C#中接口规则：
- 定义的方法不需要添加public等限定符，默认的所有方法都是public的；
- 可以包含方法、属性、事件和索引器；
- 不可以包含字段、运算符重载、构造函数和析构函数；
- 也不可以包含静态相关的所有定义；
类实现接口
实现接口的写法与继承一致：
using System; namespace Study
{
class Program
{
static void Main(string[] args)
{
ICustom custom = new Custom();
custom.name = "A";
custom.MoveTo(, ); Console.ReadKey();
}
} public interface ICustom
{
string name { set; get; } void MoveTo(float x, float y);
} public class Custom : ICustom
{
public string name { get; set; } public void MoveTo(float x, float y)
{
Console.WriteLine("Custom \"" + name + "\" move to: " + x + ", " + y);
}
}
}
输出如下：
Custom "A" move to: ,
接口的隐式实现和显式实现
如果在实现接口时没有指明该方法是属于哪个接口的话，称为隐式实现，如上面的例子。如果指明了方法是来自哪个接口则称为显式实现。
C#中的隐式实现与Java和AS3的使用一致，就不多讲，下面主要说一下接口的显式实现。
using System; namespace Study
{
class Program
{
static void Main(string[] args)
{
Custom custom = new Custom();
custom.name = "A";
(custom as ICustomA).MoveTo(, );
(custom as ICustomB).MoveTo(, ); Console.ReadKey();
}
} public interface ICustomA
{
string name { set; get; } void MoveTo(float x, float y);
} public interface ICustomB
{
string name { set; get; } void MoveTo(float x, float y);
} public class Custom : ICustomA, ICustomB
{
public string name { get; set; } void ICustomA.MoveTo(float x, float y)
{
Console.WriteLine("ICustomA \"" + name + "\" move to: " + x + ", " + y);
} void ICustomB.MoveTo(float x, float y)
{
Console.WriteLine("ICustomB \"" + name + "\" move to: " + x + ", " + y);
}
}
}
运行结果如下：
ICustomA "A" move to: ,
ICustomB "A" move to: ,
显示接口总结：
- 显示接口一般用于多个接口实现时，存在同名方法但需要不同的处理时。
- 我们发现如果使用显示的接口，需要将对象转换为对应的接口对象才能调用到对应的接口方法。
- 显示实现接口时不能写public在前方。
- 显示实现的接口不能由类直接访问，必须转换为对应的接口对象才行。
抽象类
C#中，抽象类使用与Java中一致，我们写一个例子来验证即可。
using System; namespace Study
{
class Program
{
static void Main(string[] args)
{
Custom custom = new Custom();
custom.name = "A";
custom.MoveTo(, ); Console.ReadKey();
}
} public abstract class AbstractCustom
{
public string name { set; get; } public abstract void MoveTo(float x, float y);
} public class Custom : AbstractCustom
{
public override void MoveTo(float x, float y)
{
Console.WriteLine("Custom \"" + name + "\" move to: " + x + ", " + y);
}
}
}
运行结果如下：
Custom "A" move to: ,
抽象类总结：
- 抽象类也是类，所以不能多重继承；
- 抽象类不能实例化，可以包含抽象方法，抽象方法不能实现；
- 抽象方法为虚方法；
- 非抽象子类必须实现抽象方法；