四-面向对象 -多态、接口 is、as运算

多态：
有了继承，才有了多态；
概念：继承同一个父类的全部子类，使用起来都不一样，他们都是一个独立的个体；

普通父类中，可以出现虚方法，虚方法可以在子类中被重写；

虚方法：virtual
重写：override

父类，基类
子类，派生类，超类

namespace 多态
{
    class Ren
    {
        public void chifan()
        {
            Console.WriteLine("我必须得吃饭！");
        }

        public virtual void xihuanchi()  -----虚方法
        {
            Console.WriteLine("喜欢吃肉，蔬菜，水果！");
        }

    }
}

namespace 多态
{
    class Nan : Ren
    {
        public override void xihuanchi()   ---=--重写
        {
            Console.WriteLine("我是男人，我只喜欢吃肉！");
        }

        public void zuqiu()   --------子类拥有，父类没有的方法
        {
            Console.WriteLine("我喜欢足球！");
        }
    }

namespace 多态
{
    class Nv : Ren
    {
        public override void xihuanchi()
        {
            Console.WriteLine("我是女人，我只喜欢吃蔬菜和水果！");
        }

        public void gouwu()
        {
            Console.WriteLine("我喜欢购物！");
        }

    }
}

namespace 多态
{
    class XiaoNanHai : Nan     --------子类可以被另一子类继承
    {
    }
}

------------------------------------------------------------------
抽象类：abstract
就是用来被继承的，不能实例化对象，因为没有构造函数；
抽象方法，不能有方法的主体，只能定义方法的结构；

抽象方法或抽象属性，只能存在于抽象类中；
抽象类中不一定只有抽象方法和抽象属性；

namespace 抽象类
{
    class Program
    {
        static void Main(string[] args)
        {
            Nan n = new Nan();  -----就是用来被继承的，不能实例化对象，因为没有构造函数；抽象方法，不能有方法的主体，只能定义方法的结构；

            n.chifan();
            n.xihuanchi();

            Ren r = new Nan();
            r.xihuanchi();



            Console.ReadKey();
        }
    }

namespace 抽象类
{
    abstract class Ren     ----抽象类
    {
        public virtual void chifan()-----就是用来被继承的，不能实例化对象，因为没有构造函数；抽象方法，不能有方法的主体，只能定义方法的结构；

{ Console.WriteLine("用嘴吃饭！"); ------抽象类中不一定只有抽象方法和抽象属性；

} public abstract void xihuanchi(); -------抽象方法或抽象属性，只能存在于抽象类中；

    }
}

namespace 抽象类
{
    class Nan : Ren
    {
        public override void chifan()    ----继承时要定义方法
        {
            Console.WriteLine("我是男人，我大口吃饭！");
        }

        public override void xihuanchi()
        {
            Console.WriteLine("我是男人，我喜欢吃肉！");
        }

    }
}

-----------------------------------------------------------------
接口：
在团队开发中，一个类，需要多个模块组合起来才是完整的类；
多个人开发不同的模块，最后要把它们拼接起来，靠的就是接口；

一个类，需要继承多个类才是完整的，但是程序规定，一个类只能继承一个父类；
为了解决这个问题，就出现了接口，一个类可以继承无数个接口；

=========就像一个子类继承了多个父类

人 这个类，需要会吃饭，技能，运动，才是一个完整的人；
吃饭这个功能是A单独开发的，作为人的最基本的父类，使用的是抽象类；
技能和运动，是B和C分别开发的，需要人这个类来继承，但是已经有父类了；
那么B和C就使用的接口，来让人这个类可以继承他们写的两个功能模块；

接口里面的方法很像抽象方法；

接口也是起到一个规范和约束的作用；

namespace 接口
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList arr = new ArrayList();

            Ren r = new Ren();
            //r.chifan();
            //r.Skill();
            //r.Sport1();

namespace 接口
{
    abstract class HuoZhe
    {
        public abstract void chifan();

    }

namespace 接口
{
    public interface Sports
    {
        void Sport1();
    }
}

namespace 接口
{
    public interface Work
    {
        void Skill();
    }
}

namespace 接口
{
    class Ren : HuoZhe, Work, Sports
    {
        public override void chifan()
        {
            Console.WriteLine("用嘴吃饭！");
        }

        public void Skill()
        {
            Console.WriteLine("会编程！");
        }

        public void Sport1()
        {
            Console.WriteLine("会踢足球！");
        }

------------------------------------------------------------------------------------------------
is和as运算符：
is是判断是否是某个类型，返回true或false
o as Ren； 如果转换成功了，没问题；
如果没转换成功，不会报出错误，而是返回一个null值

 ====就是防止 强制转换失败 程序崩溃 而设立的一种方法

           Random ran = new Random();

            arr.Add(r);
            arr.Add(ran);

            foreach (object o in arr)
            {
                Ren rr = o as Ren;
                if (rr != null)
                {
                    rr.chifan();
                }
                else
                {
                    Console.WriteLine("没转换成功！");
                }
            }

            Console.ReadKey();
        }
    }