【C#】OOP之继承那点事

前言：

继承这点事，说多不多，说少不少，这里只描述了一些我认为的基础篇，望各位大神指教。
本节参照了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.接口继承

　　　关于前言Class的抽象类，我们说到抽象类可以实现抽象方法，在Animal中有一个Run的抽象方法,但是我们人也能Run, 而不能去继承Animal,因为我们的关系图应该在People或者Human下比较靠谱。 我们这时就可以用接口来做了。

　　我的概念中的接口：

　　1.是一个规则，制定程序员只能做什么的规则

　　2.只关注行为，不关注字段的一个神奇的产物

　　3.用来做底层抽象和设计框架的不二神器

　

public interface IRun
    {
        void Run();
    }

    public abstract class Animal : IRun
    {
        public abstract void Run();
    }
    public class Dog : Animal
    {
        public override void Run()
        {
            throw new NotImplementedException();
        }
    }
    public abstract class People : IRun
    {
        public abstract void Run();
    }
    public class Man : People
    {
        public override void Run()
        {
            throw new NotImplementedException();
        }
    }

View Code

我们来看一下上面的代码，People和Animal都说抽抽象类，我们并没有实现IRun接口下的Run方法，而是直接做成了抽象方法（这里可以证明，接口里面的方法都说抽象方法），而是由我们的子类Man和Dog分别去实现了，这样可以说明，接口关注的只是行为，因为IRun接口可以被所有可以跑的物体去实现。

 关于第一个点：我强烈建议不要在类中任意的去加public方法，因为我建议只要有接口，就用接口作为对象，这样的好处有几点：

　　1.所有实现了该特定接口的类看起来都这样

　　2.接口被用来建立类与类之间的协议。（同步开发的时候，只关注接口就行了）

　　3.定义了规则，无论你底层的编写人员怎么加public方法你是看不见的，因为作为高层我只认接口里面的方法（这里要明白多态）。

　　4.接口可以跨类继承体系来使用（就像IRun run=new Dog(), IRun run=new Man() 这样）

　　

　　对于这篇来说是我对接口浅显的理解，肯定不全，我其实觉得接口在框架级上的可以说的很多，但说这个技术，我真心觉得没什么好说的。下面是我对接口一些功能的总结：

　　1.接口 能多继承接口，类可以多继承实现。

　　2.接口里能包含：事件、属性、索引器、静态方法、静态字段、静态构造函数以及常量。

　　3.出来抽象类以外，所有实现接口的类都要实现其定义的方法

　　

　　

转载于:https://www.cnblogs.com/guochenkai/p/3892164.html