C#面向对象核心-继承

  • C#面向对象核心-继承已关闭评论
  • 91 次浏览
  • A+
所属分类:.NET技术
摘要

继承主要实现重用代码,来节省开发时间。一个类B继承一个类A,被继承的类A称为 父类、基类、超类,继承的类B称为 子类、派生类。


继承

继承主要实现重用代码,来节省开发时间。

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//报错,无法继承 {  }