温故而知新 C# 面向对象

      说到面向对象 首先谈到的就是 类与对象的关系。

　　1. 类： 类是一个抽象的概念，具有相同特性类别的统称。 比如  电器 就可以理解成一个类，但是 它只是一个抽象的词，冰箱，电视，洗衣机，都可以统称为 电器。更直白的说就是 平时所理解的 分类 。

      2. 对象： 总有那么句话 世间万物皆对象。 其实就是 每一个类中 具体到一个事物。比如上面说的 电器 类。如果具体到 冰箱。那么冰箱就是一个对象。他有各项属性，价格，颜色，体重等。这就是一个对象。

      3. 面向对象：其实面向对象就是 对某一个类的 实例 的操作。面向对象有三大特性：封装，继承，多态。

　　    那么为什么要有面向对象？　　 　　

　　　　（1）增加代码重用。

　　　　（2）降低维护负担，将具备独特性质的代码封装起来，修改程序时，相互不会影响。

　　4. 重点说说面向对象的三大特性：　封装，继承，多态。

   　　（1）封装：顾名思义，其实就是将零散的 代码封装在一个方法 或 类中。常见的方法，属性 的封装。

　　     比如下面 代码 枚举中就可以看成一个封装，这样就能有通用性，每次使用只需要调用  这个枚举 EnumSortID 来取其中的值。

    public class Animals
    {
        /// <summary>
        /// 分类Enum
        /// </summary>
        public enum EnumSortID
        {
            /// <summary>
            /// 房屋及建筑物类
            /// </summary>
            [Remark("房屋及建筑物类")]
            FW = 1,

            /// <summary>
            /// 专业设备类
            /// </summary>
            [Remark("专业设备类")]
            ZY = 2 

        }
    
    }

 

　　　（2）继承：通俗的说法 子承父业 。 继承了父类的 方法 等。 看下面的代码：

 static void Main(string[] args)
        {
            Father fat = new Father(2, 3);
            int asd = fat.ages(2);
            //通过继承后 子类可以调用父类中 的方法，当然私有方法除外
         child chi = new child();
            chi.ages(23);

           
        }

//父类
    public class Father
    {
        
        public Father(int dfs, int sdf)
        {

        }
         
        public int age
        { get; set; }

        public int ages(int age)
        {
            return age + 2;
        }
    }

    //基类继承父类
    public class child : Father
    {
        public decimal dse { get; set; }
        public child()
            : base(2, 3)
        {
 
        } 
        public void chil() 
        {
            int de =base.age;
           
            Console.WriteLine("Animal eats");
        }
        
    }

        （3）多态：  通过继承实现的不同对象调用相同的方法，表现出不同的行为，或者 同一个方法在不同的类中有不同的实现体 称为多态。前面说的 封装、继承在实际工作中 随处可见，但是多态可能就比较少了。

　　　      这里说说实现多态的两种方法 abstract（抽象方法），virtual（虚方法）。

　　　　   首先，先理解他们的作用： virtual和abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义。

　　　　   1.)它们共同点：如果用来修饰方法，前面必须添加public，要不然就会出现编译错误：虚拟方法或抽象方法是不能私有的。毕竟加上virtual或abstract就是让子类重新定义的，而private成员是不能被子类访问的。

　　　　　　　　　　　　 必须使用override关键字来重写方法。

　　　　　2.)他们的区别：virtual（虚方法必须有具体的实现）而abstract（抽象方法没有具体实现）。如下代码。在定义abstract（1. 抽象方法的时候要注意，必须定义在抽象类中，否则会报错 2.子类继承父类时候必须实现 父类中的抽象方法。）

　　　　　　　　　　　　virtual可以被子类重写，而abstract必须被子类重写。

 　　　　　　　　　　　　无法创建abstract类的实例 跟接口 静态类一样 。

 //抽象类
    public abstract class Animal
    {
        //定义虚方法
        public virtual void Eat()
        {
            Console.WriteLine("Animal eat");
        }
        //抽象方法
        public abstract void Run();
    }

 

 static void Main(string[] args)
        {
             
            Dog dog = new Dog();
            dog.Eat();
            dog.Run();
            Cat cat = new Cat();
            cat.Eat();
            cat.Run();
            Console.ReadLine();

       
          }

//抽象类
    public abstract class Animal
    {
        //定义虚方法
        public virtual void Eat()
        {
            Console.WriteLine("Animal eat");
        }
        //抽象方法
        public abstract void Run();
    } 

    public class Dog : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("我是Dog虚方法的多态 吃");
        } 

        public override void Run()
        {
            Console.WriteLine("我是Dog抽象方法的多态 跑");
        }
    }

    public class Cat : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("我是Cat虚方法的多态 吃");
        }

        public override void Run()
        {
            Console.WriteLine("我是Cat抽象方法的多态 跑");
        }
    }

 

运行结果为：我是Dog虚方法的多态 吃　

　　　　　　我是Dog抽象方法的多态 跑

　　　　　　我是Cat虚方法的多态 吃

　　　　　　我是Cat抽象方法的多态 跑

这就是多态。这就是面向对象，当然这其中还有很多东西，只是这个三个特性是最具代表性的也最重要的。