OOP面向对象

一：什么是面向过程

我们是怎么思考和解决上面的问题呢？

答案是：我们自己的思维一直按照步骤来处理这个问题，这是我们的常规思维，这就是所谓的面向过程POP编程

 

二：面向过程POP为什么转换为OOP

 

面向过程POP的思想是步骤越多，变化越多，是无法掌控的，所以有时候非常复杂，就比如我们拿起来手机玩游戏如果按照步骤来编程，则会如下：

 Console.WriteLine("手机开机");
 Console.WriteLine("手机联网");
 Console.WriteLine("手机打开游戏");
 Console.WriteLine("手机玩游戏");
 Console.WriteLine("手机结束游戏");

但是突然出现，不同的手机，不同的玩法，不同的游戏，那么又要重新写类似的东西，所以面向过程虽然更更符合人的思考方式，但是及其不方便扩展管理，不能够重复使用，尤其是项目复杂的情况下，会使编程不好维护

但是怎么从POP转换为OOP呢？

我们通过手机玩游戏，可以转换一下思想，我们把对象进行分析，可以把手机，玩家，游戏分别定义为一个对象，可以参考如下：

    public class Player
     {
         public int Id { set; get; }
         public string Name { set; get; }
 
         public void PlayIPhone(IPhone phone)
         {
             Console.WriteLine($"{phone.GetType().Name}");
         }
     }
     public class Game
     {
         public void Start()
         {
             Console.WriteLine($"{this.GetType().Name}开始游戏");
         }
         public void Play()
         {
             Console.WriteLine($"{this.GetType().Name}玩游戏");
         }
         public void Over()
         {
             Console.WriteLine($"{this.GetType().Name}结束游戏");
         }
     }
     public class IPhone
     {
         public int Id { set; get; }
         public string Name { set; get; }
 
         public string Branch { set; get; }
 
         public void PlayGame()
         {
             Game game = new Game();
             game.Start();
             game.Play();
             game.Over();
         }
         public void Open()
         {
 
         }
         public void Close()
         {
 
         }
     }

我们按照对象划分，就是所谓的万物皆对象，然后我们把对象定义好，然后对象封装好，然后把对象的属性和动作都归结为一起，这就是所谓的画格子，每个格子自成体系，内部任意改动不会影响到别人，然后每个格子之间相互交互！虽然我们使思路更加复杂化，但是以后极其容易扩展。 

总的说来面向对象就是把以前按照步骤考虑的然后划分为对象，然后对象之间交互组成功能，功能与功能之间组成系统，系统与系统之间组成平台，比如：一块块砖然后砌成墙，然后墙与墙之间组成房间，房间与房间之间组成一个大厦

三：面向对象的好处【封装，继承，多态】

1：【封装】的好处
        A：最主要的好处是：隔离，即是外部不用关心内部怎么实现，只要接口不变，内部可以随意扩展
        B: 安全 private protect等数据结构，只能通过公开的方法来访问，而不能随意修改以致于保证数据的安全
        C: 降低耦合，提高重要性，尽量隐藏更多的东西

2：继承的好处：就是为了方便代码重用，通过继承然后子类拥有父类的一切属性和行为,但是只能单继承 ；重载（参数不一致,跟返回值没有关系）

3：多态：意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

4：多态的表现方式分为以下几种：

A： 多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

B：接口多态

C：继承多态

下面的代码能够体现出来继承封装多态

 public abstract class ParentClass
    {
        public ParentClass(int id)
        {
            Console.WriteLine("父类的构造函数");
        }
        public ParentClass()
        {
            Console.WriteLine("父类的构造函数");
        }
        public void CommonMethod()
        {
 
        }
        public virtual void VirturalMethod()
        {
 
        }
        public virtual void VirturalMethod(int id)
        {
            Console.WriteLine("子类的带参");
        }
        public abstract void AbstractMethod();
    }
    public class ChildClass : ParentClass
    {
        /// <summary>
        /// 实例化子类的时候，是先完成父类的实例化
        /// </summary>
        public ChildClass() : base()
        {
            Console.WriteLine("子类的构造函数");
        }
 
        /// <summary>
        /// new 隐藏方法，new 加不加一样的效果
        /// </summary>
        public new void CommonMethod()
        {
            Console.WriteLine("子类的普通方法");
        }
        public sealed override void AbstractMethod()
        {
            Console.WriteLine("子类抽象方法");
        }
        public override void VirturalMethod()
        {
            base.VirturalMethod(); //调用的父类的方法
        }
    }
    public class GrandClass : ChildClass
    {
        /// <summary>
        /// 可以重复覆写，如果不喜欢被重写，可以添加一个sealed
        /// </summary>
        //public override void AbstractMethod()
        //{
        //    throw new NotImplementedException();
        //}
        public override void VirturalMethod()
        {
            base.VirturalMethod(); //调用的父类的方法
        }
    }

然后再调用的时候会出现以下结果

{
   ParentClass instance = new ChildClass();
   instance.CommonMethod(); //调用的父类的方法 普通方法由编译时决定-能够提高效率（由声明时决定）
   instance.VirturalMethod(); //调用的子类方法  虚方法由运行时决定的-多态灵活 （虚方法既可以覆写，也可以不覆写）
   instance.AbstractMethod(); //调用的子类的方法
}

四：说一下抽象类和接口的区别

1、抽象类和接口都不能直接实例化。如要实例化，涉及到多态。抽象类要实例化，抽象类定义的变量必须指向一个子类变量，这个子类继承并实现了抽象类所有的抽象方法。接口要实例化，接口定义的变量必须指向一个子类变量，这个子类继承并实现了接口所有方法。

2、抽象要被子类继承，接口要被子类实现。

3、接口里只能对方法进行声明，抽象类里既可以对方法进行声明，又可以实现。

4、抽象类里面的抽象方法必须被子类实现，如果子类不能全部实现，子类必须也是抽象类。接口里面的方法必须被子类实现，如果子类不能全部实现，子类必须是抽象类。

5、接口里面的方法不能有具体的实现，这说明接口是设计的结果，而抽象类是重构的结果。

6、抽象类里面可以没有抽象方法，如果一个类里面有抽象方法，那么这个类一定是抽象类。

7、抽象类中的抽象方法都要被实现，所以抽象方法不能是静态的static，也不能是私有的private。

8、接口可以继承接口，甚至可以继承多个接口；类可以实现多个接口，只能继承一个类。

9、抽象类主要用来抽象类别，接口主要用来抽象方法功能。关注事物的本质，用抽象类；关注一种操作，用接口。
10、接口可以定义以下内容

 public interface IExtend
  {
        /// <summary>
        /// 属性可以，字段不行
        /// </summary>
        int Tag { set; get; }
 
        /// <summary>
        /// 方法
        /// </summary>
        void Play();
 
        //string Remark = null; //不能声明
        //class Test { }   //不能声明
        //Delegate void NoAction(); //不能声明
 
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        int this[int i]
        {
            get;
        }
        /// <summary>
        /// 事件
        /// </summary>
        event Action DoNothindHandler;
    }

四：如何选择抽象类和接口的区别

1：抽象类必须是一个父类，然后再方法不同的时候使用抽象实现，主要是为了代码重用 is a，所以抽象类可以说成是父类+约束，而且是单继承
2：接口：仅仅是为了约束，告诉实现者一定要有某个功能 can do

所以如果需要约束，一般选择接口，因为接口可以多实现并且多继承，除非项目中有代码需要重用，这样可以选择抽象类

但是目前的大部分项目会选择基类和接口联合使用，比如有通用的属性等使用基类来创建，如果需要约束功能的话一般使用接口来约束，所以接口和抽象类可以相辅相成！