第一篇博文

今天又复习了一下面向对象的思想，为了加强记忆，所以把自己回顾的东西给记下来。

首先第一个面向对象的三大特征:封装、继承、多态

1：封装

    何为封装，我的简单的理解封装就是打包，为了解决大项目的维护和管理。

2：继承

    理解：继承其实就是拿来主义，将一个类库作为原始的模板，在其基础上拓展别的模板。

    优点：解决了代码的冗余 。

    特性：传递性

    其中涉及到构造方法的调用问题，子类在调用自己的构造方法的时候会首先初始化父类的构造方法，但是不会初始化化一个父类的对象，至于为什么会初始化父类的构造方法，我理解的是，会首先初始化父类的字段。

    里氏转换原则：

    子类可以赋值给父类对象。

    父类对象可以强制转换成对应的子类对象。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 继承
{
    public class BaseFun
    {
    }
    public class Fun:BaseFun
    {
    }
    class Program
    {
        static void Main(string[] args)
        {
            //子类可以赋值给父类
            BaseFun bs = new Fun();
            //父类可以强制装换成对应的子类
            Fun fun1 = (Fun)bs;
            //is的使用
            Console.WriteLine(fun1 is BaseFun);//True
            Console.WriteLine(fun1 is Fun);//True
            Console.WriteLine(fun1 is object);//True
            //as的使用
            Fun fun2 = fun1 as Fun;
            Console.WriteLine("ok");
            Console.Read();
        }
    }
}

3：多态

     定义：对象在调用同一个方法表现出来的多种种状态

      a：通过重写基类的方法实现多态：父类统一调用，子类来实现。

      b：通过隐藏基类的方法实现多态。

      

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态
{
    public class BaseFun
    {
        public virtual void Eat()
        {
            Console.WriteLine("我是BaseFun");
        }
    }
    public class Fun:BaseFun
    {
        public override void  Eat()
        {
            Console.WriteLine("我是Fun");
        }
    }
    public class Fun1:BaseFun
    {
        public new void  Eat()
        {
            Console.WriteLine("我是Fun1");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            BaseFun bs = null;
            bs = new Fun();
            bs.Eat();
            Fun1 fun1 = new Fun1();
            fun1.Eat();
            BaseFun bs1 = fun1;
            bs1.Eat();
            Console.Read();
        }
    }
}