复习.Net C# 继承，多态

 

　　上一篇中研究OOP（面向对象）的第一支柱—封装，接下来介绍继承、

　　　继承的作用

　　　　是指基于已有的类来创建新类

　　　　代码重用：这种形式是不用来创建基类和子类关系的，它意味着，一个类可以定义另一个类的成员变量，并向对象用户间接公开它的功能（如果需要的话）

　　　　基本语法

　　　　　　

namespace vs__Csharp
{
    class Program
    {
        static void Main(string[] args)
        {
            MyCar car = new MyCar();
            car.Start();//调用基类的方法
            Console.ReadKey();
        }
    }
    class Car
    {
        private string color;
        //车子有很多特征，特征用字段表示，这里就只写一个特征演示下吧
        public string Color
        {
            get { return color; }
            set { color = value; }
        }
        public void Start()
        {
            Console.WriteLine("启动");
        }

    }
    class MyCar : Car
    {
        public string Brand;//定义子类的字段

    }
}

　　多态

　　　　多态的作用

　　　　　　为所有的派生类，定义一个多态接口，一个类类型的多态接口由任意个虚拟（virtual）或抽象(abstract)成员组成

　　　　virtual和override关键字

　　　　　　多态为子类提供了一种方式，使其可以定义由基类定义的方法，这种过程叫做方法重写　

　　　　　　　　虚方法必须有实现，可以被子类重写，也可以不重写

　　　　　　　　虚方法可以出现在抽象类中，也可以出现在普通类中

　　　　　　　　基类 对象=new子类（）;

　　　　　　　　解释：让基类对象指向子类，在堆里面开辟一块子类内存空间在子类中找相应的方法，找到了就调用

　　　

　　　　案例：动物animal   都有吃eat和叫bark的方法，狗dog和猫cat叫的方法不一样

　　　　　　

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Dog d = new Dog();
            d.Back();
            Cat c = new Cat();
            c.Back();
            Console.ReadKey();
        }
    }
    class animal
    {
        public virtual void Eat()
        {
            Console.WriteLine("吃");
        }
        public virtual void Back()
        {
            Console.WriteLine("叫");
        }

    }
    class Dog : animal
    {
        public override void Back()//必须要有实现，不然会报错，哪怕为空也要有方法体
        {
            Console.WriteLine("旺旺");//大家发财哈
        }

    }
    class Cat : animal
    {
        public override void Back()
        {
            Console.WriteLine("喵喵");
        }
    }
}

　　

　　　　抽象类

　　　　　　关键字：abstract

　　　　　　不能实例化，定义子类的实现方法和能力

　　　　抽象方法

   　　　　  抽象方法不能有实现，（不能有大括弧）

　　　　　　抽象方法在子类中必须全部用override重写，除非子类也是抽象类

　　　　　　抽象方法必须出现在抽象类中，

　　　　　　可以有抽象成员也可以无

    　　　　 抽象方法不能有主体

　　　　案例：改写上面那个案例

　　　　　　

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Dog d = new Dog();
            d.Back();
            Console.ReadKey();
        }
    }
    abstract class animal//抽象方法必须出现在抽象类中
    {
        public abstract void Back();//不能有实现（大括号）

    }
    class Dog : animal
    {
        public override void Back()
        {
            Console.WriteLine("旺旺");
        }
    }
}

　　　C#中的as关键字

　　　　要知道，显式强制转换在运行时而不是编译时进行运算的，

　　　　object as TypeA:先判断object是否可以转换成TypeA类型,如果能转,则帮我们转换完成,并返回转换后的值.如果不能转,则返回null

　　　　

    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc=new MyClass();
            object o =  mc as object;
            if (o != null)
            {
                Console.WriteLine("成功");
            }
            Console.ReadKey();
        }
      
    }
    class MyClass
    {
        public  int Add(int x, int y)//定义一个被指向的方法
        {
            return x + y;
        }
    }

　　　　C#中的is关键字

　　　　　　object is type B:判断object是否可以转换成typeB,如果能转换成功,则返回true,否则返回false