继承
继承主要实现重用代码,来节省开发时间。
1 继承基本概念
一个类B继承一个类A,被继承的类A称为 父类、基类、超类,继承的类B称为 子类、派生类。
- 子类会继承父类的所有成员
- 子类拥有父类的所有特征和行为
- 子类可以有自己的特征行为
- C#中允许子类和父类存在同名的成员,但不建议使用
特点:
- 单根性 子类只能有一个父类,不能多继承
- 传递性 子类可以间接继承父类的父类
1.1 基本语法
|
class Teacher |
|
{ |
|
public string name; |
|
public int number; |
|
|
|
public void SpeakName() |
|
{ |
|
Console.WriteLine(name); |
|
} |
|
} |
|
|
|
class TeachingTeacher : Teacher |
|
{ |
|
public string subject;//科目 |
|
|
|
public void SpeakSubject() |
|
{ |
|
Console.WriteLine($"我是{subject}老师"); |
|
} |
|
} |
|
|
|
class ChineseTeacher : TeachingTeacher |
|
{ |
|
public void Skill() |
|
{ |
|
Console.WriteLine("余幼时即嗜学"); |
|
} |
|
} |
1.2 使用
|
TeachingTeacher tt = new TeachingTeacher(); |
|
tt.name = "abc"; |
|
tt.number = 1; |
|
tt.SpeakName(); |
|
tt.subject = "C#"; |
|
tt.SpeakSubject(); |
|
|
|
ChineseTeacher ct = new ChineseTeacher(); |
|
ct.name = "def"; |
|
ct.number = 2; |
|
ct.SpeakName(); |
|
ct.subject = "Chinese"; |
|
ct.SpeakSubject(); |
|
ct.Skill(); |
2 里氏替换原则
里氏替换原则(Liskov Substitution principle):子类可以扩展父类的功能,但不能改变父类原有的功能,是面向对象七大原则中最重要的原则。 概念:任何父类出现的地方,子类都可以替代 重点:语法表现一父类容器装子类对象,因为子类对象包含了父类的所有内容 作用:方便进行对象存储和管理
2.1 基本语法
|
class GameObject |
|
{ |
|
|
|
} |
|
|
|
class Player : GameObject |
|
{ |
|
public void PlayerAttack() |
|
{ |
|
Console.WriteLine("玩家攻击"); |
|
} |
|
} |
|
|
|
class Monster : GameObject |
|
{ |
|
public void MonsterAttack() |
|
{ |
|
Console.WriteLine("怪物攻击"); |
|
} |
|
} |
|
|
|
class Boss : GameObject |
|
{ |
|
public void BossAttack() |
|
{ |
|
Console.WriteLine("Boss攻击"); |
|
} |
|
} |
|
|
|
//Main |
|
//里氏替换原则 用父类容器装载子类对象 |
|
GameObject p = new Player(); |
|
GameObject m = new Monster(); |
|
GameObject b = new Boss(); |
2.2 is 和 as
is:判断一个对象是否为指定对象,返回:bool,是为真,不是为假
as:将一个对象转换为指定类对象,返回:成功返回指定类对象,失败返回null
基本语法:
- 类对象 is 类名,语句返回真或假
- 类对象 as 类名,语句返回对象或null
|
if(p is Player) |
|
{ |
|
Player p1 = p as Player; |
|
p1.PlayerAttack(); |
|
} |
3 继承的构造函数
3.1 基本概念
子类声明子类对象时,先执行父类的构造函数,再执行子类的构造函数。
- 父类的无参构造很重要,有参构造函数会自动顶掉无参构造函数,若写了有参构造,则最好还要写无参构造
- 子类可以通过base关键字代表父类调用父类构造函数
- 构造函数执行顺序:父类的父类的构造函数——父类的构造函数——子类的构造函数
|
class GameObject |
|
{ |
|
public GameObject() |
|
{ |
|
Console.WriteLine("GameObject的构造函数"); |
|
} |
|
} |
|
class Player : GameObject |
|
{ |
|
public Player() |
|
{ |
|
Console.WriteLine("Player的构造函数"); |
|
} |
|
} |
|
class MainPlayer : Player |
|
{ |
|
public MainPlayer() |
|
{ |
|
Console.WriteLine("MainPlayer的构造函数"); |
|
} |
|
} |
|
|
|
//Main |
|
MainPlayer mp = new MainPlayer(); |
|
/* |
|
输出: |
|
GameObject的构造函数 |
|
Player的构造函数 |
|
MainPlayer的构造函数 |
|
*/ |
|
Father构造 |
|
Son一个参数构造 |
|
Son两个个参数构造 |
3.2 base关键字
通过 base(参数) 可以调用指定父类构造。
|
class Father |
|
{ |
|
/*public Father() |
|
{ |
|
|
|
}*/ |
|
public Father(int i)//有参构造函数会自动顶掉无参构造函数 |
|
{ |
|
Console.WriteLine("Father构造"); |
|
} |
|
} |
|
//子类实例化时默认先调用父类的无参构造,如果父类无参构造被顶掉,就会报错 |
|
class Son : Father |
|
{ |
|
//通过base改变默认调用父类的无参构造,指定为有参构造 |
|
public Son(int i) : base(i) |
|
{ |
|
Console.WriteLine("Son一个参数构造"); |
|
} |
|
|
|
public Son(int i, string str) : this(i)//this(i)表示调用一个参数的构造函数public Son(int i) : base(i){} |
|
{ |
|
Console.WriteLine("Son两个个参数构造"); |
|
} |
|
} |
|
|
|
//Main |
|
Son s = new Son(1, "123"); |
|
/* |
|
输出: |
|
Father构造 |
|
Son一个参数构造 |
|
Son两个个参数构造 |
|
*/ |
4 object 和装箱拆箱
4.1 object
object 是所有类型的父类,它是一个类(引用类型)。
作用:
- 利用里氏替换原则,用object容器装所有对象
- 表示不确定类型,作为函数参数类型
4.2 使用
|
class Father |
|
{ |
|
|
|
} |
|
|
|
class Son : Father |
|
{ |
|
public void Speak() |
|
{ |
|
|
|
} |
|
} |
|
|
|
//Main |
|
Father f = new Son();//用父类容器装载子类 |
|
if(f is Son) |
|
{ |
|
(f as Son).Speak(); |
|
} |
|
|
|
//用object装载万物,然后转换成所需类型来使用 |
|
//1、引用类型 |
|
object o = new Son(); |
|
//用is和as来判断和转换即可 |
|
if(o is Son) |
|
{ |
|
(o as Son).Speak(); |
|
} |
|
|
|
//2、值类型 |
|
object o2 = 1f; |
|
//用强转 |
|
float fl = (float)o2; |
|
|
|
//特殊string类型 |
|
object str = "123"; |
|
string str2 = str as string; |
|
|
|
//数组 |
|
object arr = new int[10]; |
|
int[] ar = arr as int[]; |
4.3 装箱和拆箱
- 装箱:用object来存值类型,即值类型转换为object类型 ,栈内存会迁移到堆内存中
- 拆箱:再把object转为值类型 ,堆内存会迁移到栈内存中
- 好处:不确定类型时可以方便参数的存储和传递
- 坏处:存在内存迁移,增加性能消耗
|
object v = 3;//装箱 |
|
int a = (int)v;//拆箱 |
5 sealed 密封类
- 使用 sealed 关键字修饰的类,让类无法被继承
- 在面向对象程序的设计中,密封类的主要作用就是不允许最底层子类被继承,可以保证程序的规范性、安全性
|
sealed class Father |
|
{ |
|
|
|
} |
|
|
|
class Son : Father//报错,无法继承 |
|
{ |
|
|
|
} |