首页 > 代码库 > 【C#】OOP之继承那点事

【C#】OOP之继承那点事

2024-07-15 21:47:58   224人阅读


前言：

继承这点事，说多不多，说少不少，这里只描述了一些我认为的基础篇，望各位大神指教。
本节参照了C#高级编程和Think in java对继承的描述，我个人认为OOP只是思想,故看明白一个就说通的，只是语法上的区别。

 

  • 权限限制关键字
  • 类继承
    • 类继承基本写法
    • 类继承的好处　
    • 继承中的Virtual(虚方法）
    • 抽象类
    • 类继承的坏处
    • 执行循序
    • 不可继承的类
  • 接口继承

 

1.类继承

　　　　类继承基本写法：

　　　　

 public class SuperClass : Object{} public class SubClass : SuperClass{}

 　　我们用":"来表示类的继承, 而且每个类只能有一个父类（这个靠谱啊，你不可能有两个亲身父亲,C++不论)。

　　 SuperClass继承了Object类， Object类是顶级类，你自定义的顶级类（这里说SuperClass)会自动继承这个类（我看有很多人说:你的每个类都会继承Object，我们说过，你只能有一个亲生父亲，这样的说法不是很严谨，这样的Tier1, Tier2, Tier3的层次下来，你的高层可以直接用Object所开放的一些方法）。

　　

　　　　类继承的好处：　　

　　我们先来看些该死的温柔（类）!!!

 public class Dog    {        public string Name { get; set; }        public string Age { get; set; }        public void Run()        {            Console.WriteLine("Dog is running.");        }    }    public class Cat    {        public string Name { get; set; }        public string Age { get; set; }        public void Run()        {            Console.WriteLine("Cat is running.");        }    }
View Code

　　

　　粗看一下，没什么问题，猫类和狗类 都有名字，年龄和一个跑的方法。 （当年，我写完还点头，双手叉腰，嗯，很好，不错--傻的一塌糊涂，冏）

　　但是如果那天有个变态叫你把所有动物都写一边，你开始造轮子了，1234567.....，终于要完工了, 大喜过望，那个变态回来告诉你，不好意思，弄错了，年龄没有意义，可以去掉（纳尼....). 这个时候你就需要再去1234567....，oh Fuck...难道我不能只改一次吗？

　　完 全 可 以->继承

　　

    public abstract class Animal    {        public string Name { get; set; }        public string Age { get; set; }        public void Run()        {            Console.WriteLine(string.Format("{0} is running.", Name));        }    }    public class Dog : Animal    {    }    public class Cat : Animal    {    }
View Code

　　代码所示之处我们提取一个父类：Aniaml(抽象类..过后再说这个）.我们重新来完成那个变态的需求，我们只要开辟一个类然后继承一下Animal就好了，

（场景恢复）嘿，年龄没有意义，可以去掉（简单....),我们只要把Animal中的年龄去掉，就OK了，一步到位。

　

　　到这里看出来继承的好处没：消除你重复的代码，让修改更加的方便。

　　

　　　　继承中的Virtual(虚方法）

　　这里又有人提出另一个问题了，如果我发现我父类的方法不能满足我的条件了，但是我又不想重载，我能重写吗？答案：完全可以。

　　

　　C#提供一个Virtual的一个标识，可以用于方法重写（java都说虚方法）

 　　

    public abstract class Animal    {        public string Name { get; set; }        public string Age { get; set; }        public virtual void Run()        {            Console.WriteLine(string.Format("{0} is running.", Name));        }    }    public class Dog : Animal    {        public override void Run()        {            Console.WriteLine("Dog is running.");        }    }    public class Cat : Animal    {    }
View Code

　　看Animal中的Run方法加上了virtual标识这个方法说虚方法，也就说可以被重写，在Dog类中，我们使用了override标识我们重写了Run的方法，这样我们在实例化对象Cat的时候，我调用Run方法就是我们重写过的。

　

　有人提出疑问了：如果不写virtual 和 override，直接在Cat中重写Run方法，实例化Cat cat=new Cat()后调用Run方法也是一样的结果。　回答：C#不像JAVA都说虚方法，如果不想写virtual 和 override的话，CLR认为这个是隐藏，所以要在子类的Run方法上添加一个new关键字，如果不添加会出现
　　warning。
  public class Cat:Animal
  {
    public new void Run()
    {
       Console.WriteLine("....");
    }
　}
New 关键字代表我要隐藏父类同名，同参数的方法（这里有几个可以讨论的地方，在多态那章会提出来说）

 　　抽象方法

 　　　　为什么会出现抽象方法，OOP告诉我们，实例化就像我们现实中创造一件东西，就如上例来看，我们如何去创造一个叫Animal的一个实体，这样是不是很奇怪，所以我们出现了抽象类。　　　　抽象类无法被实例化，只能被继承使用。public abstract class Animal,在class前面定义abstract关键字就好了。

　　 抽象类可以定义抽象的方法，用abstract关键字来标识，所有继承该抽象类的子类必须实现这个抽象方法，来一个实例：
　　

 public abstract class Animal    {        public string Name { get; set; }        public string Age { get; set; }        public virtual void Run()        {            Console.WriteLine(string.Format("{0} is running.", Name));        }        public abstract void Scream();    }    public class Dog : Animal    {        public override void Run()        {            Console.WriteLine("Dog is running.");        }        public override void Scream()        {            throw new NotImplementedException();        }    }    public class Cat : Animal    {        public override void Scream()        {            throw new NotImplementedException();        }    }
View Code

　　在Animal的抽象类中（我们说了为什么把Animal定义成抽象类),定义了一个Scream()的抽象方法，我们看见了。抽象方法是没有实现体的，直接后面跟上";"作为结束。在子类Dog和Cat类里，我们实现了Scream这个方法（不可以不实现，只要你用IDE工具，编译时会报错），我们在来看子类的Scream方法有override的关键字，所以abstract被认为是虚方法，用法类似。

　　注：这里还没有说接口，抽象类和接口一起用非常的常见，等说到接口，再详细的来说下抽象类的其他作用。

　　

　　类继承的坏处　　

　　　　所谓有得必有失，继承给我们带来了很多好的地方，消除代码重复，让层次更加清晰，修改方便等好处，但是随之带来的坏处也是很明显的，当我们继承的层次变多了，整个的架构会变得十分臃肿而导致不清晰，拿个简单的例子来说，假设我们说从猩猩进化而来，那尾巴是否已经没有了，而猩猩还是有的，这就会导致使用的迷糊，我们做类的时候要把该类的东西放在此类中，做父类的时候把对应的公共的东西提出来，而一直用继承的话很恐怖，所以这里又引出一个新的概念->组合。

　　　　组合概念就说在类中放一个其他类的对象，如果要用就赋值，不要用了就直接拿掉（父亲我们总不能放弃吧）。

　　执行循序

　　

 public abstract class SuperClass    {        public static string StaticField = "StaticFieldInSuperClass";        private string _privateField = "_privateFieldInSuperClass";        public string publicField = "publicFieldInSuperClass";        public SuperClass()        {                  }    }    public class SubClass : SuperClass    {        public static string StaticFieldInDog = "StaticFieldInSubClass";        private string _privateField = "_privateFieldInSubClass";        public SubClass()        {        }    }
View Code

　　我们看一下这两个类SuperClass里面有静态字段，私有字段，共有字段和一个构造，SubClass有一个静态字段，私有字段。

　　我们实例化SubClass subClass=new SubClass()的时候，执行循序如下：

　　1.先初始化子类(subclass)的字段。

　　2.执行子类构造，这时会发现它拥有父类，所以暂停初始化子类构造，而初始化父类（SuperClass)

　　3.初始化父类（SuperClass)的字段

　　4.执行父类构造

　　5.返回子类继续初始化子类构造

　　这里有兴趣的朋友可以直接debug看步骤就明白了。

 　不可继承的类

　　  拥有关键字sealed类都不能被继承。

　　　　

    public sealed class ConfigHelper    {          }

　　故可以认为里面所有的字段和方法都说自带sealed，因为无法继承就无法重写。

2.接口继承

　　pending...有点别的事..先发布了..。


联系
我们