首页 > > 网页制作 > css >

【C#】OOP之继承那点事

2018-06-23 22:30:20来源：未知阅读 ()

前言：

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