C#继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Point
{
protected int X { get; set; }
protected int Y { get; set; }
public Point(int x, int y)
{
X = x;
Y = y;
}
}

class Circle : Point
{
protected int R { get; set; }
public Circle(int x, int y, int r = 1) : base(x, y)
{
R = r;
}
}

C#只支持单继承,一个类只能继承自一个直接基类

protected

protected:外部不能访问,但在一系列派生类中可以访问

构造函数

创建一个派生类时,(由于派生类含有基类的属性或方法所以)会先调用基类的构造函数,然后再调用派生类的构造函数

先有系统调用派生类的构造函数,在派生类构造函数执行之前,派生类会调用基类的构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*测试*/
using System;

namespace Test
{
class Program
{
static void Main(string[] args)
{
C c = new C();
}

}

class A
{
public A()
{
Console.WriteLine("Constructing A");
}
}

class B : A
{
public B()
{
Console.WriteLine("Constructing B");
}
}

class C : B
{
public C()
{
Console.WriteLine("Constructing C");
}

}

}

object类

所有C#类的祖先

带有7个公共接口

继承中的new && base

1
2
3
4
public new void Show() //**隐藏**父类的show()函数
{
base.Show(); //子类调用父类函数
}

重写ToString

使用Console.WriteLine(A1)输出类A1时,调用A1.ToString()

不重写输出对象所属类的全名

1
2
3
4
public override string ToString()
{
return String.Format("{0} {1} {2}", a, b, c);
}

C#多态

简单的理解:就是对同一个数据(对象或者说签名?)做出不同的反应

比如说之前学到的重载(函数和运算符)

还有通过一个传入一个基类的参数,通过基类来访问子类的override函数或方法

抽象

1
2
3
4
5
/*抽象类*/
public abstract class A{}

/*抽象方法*/
public abstract int function( int a, double b, ... );

无法实例化只能用来被继承,因为没有具体实现

抽象类中的抽象函数必须在子类中被具体实现,还是体现OOP的思想

override

子类实现基类的抽象方法时使用override(重写),当父类和子类的函数签名是一致的情况下(重载overload的函数签名不一样)

virtual

必须给出具体实现方法

在派生类中override是可选的,因为父类有具体实现

成员字段和静态方法不能virtual,但属性可以

new

表示全新的方法而和父类中的同签名方法没有任何关系

一般在函数名不得不相同的情况下使用

sealed密封

可以密封类密封方法

  • 不能继承

  • 不能重写