【C#】OOP之继承那点事

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

新老客户大回馈,云服务器低至5折


前言:

继承这点事,说多不多,说少不少,这里只描述了一些我认为的基础篇,望各位大神指教。
本节参照了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.出来抽象类以外,所有实现接口的类都要实现其定义的方法

  

  

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:计算机基础知识学习

下一篇:值类型装箱问题