1.什么是面向对象？

简单来说面向对象就是把现实存在的东西用抽象的方法搬到你的代码里

---举个列子 现实中你有一台手机：

 ***有属性：手机的品牌，手机的颜色，手机的价格

***有行为：打电话，发信息，拍照片

代码：

// 现实里有手机 → 代码里写【手机类】
 class 手机
 {
     // 现实手机有的特征
     public string 品牌;
     public string 颜色;
     // 现实手机会做的事
     public void 打电话()
     {
         
     }
     public void 放音乐()
     {
     }
 }
 // 现实里你手里这台真实手机 → 代码里【new 对象】
 手机 我的手机 = new 手机();

2.认识完什么是面向对象我们来了解面向对象的四大核心

封装  继承  多态  抽象

1.封装：什么是封装一句话了解

把数据（属性）和方法（行为）包在一起，把内部细节藏起来，只给外面留能用的接口，不让外面随便乱改内部数据。

打个比方：手机就是封装。

• 内部：电路板、电池、芯片（隐藏起来，你不能随便拆改）
• 外部：屏幕、按键、充电口（只给你用的接口）

  class Person
  {
      // 1. 私有字段：隐藏起来，外部不能直接访问
      private string _name;
      private int _age;
  
      // 2. 公开属性：对外提供访问入口 + 校验逻辑
      public string Name
      {
          get { return _name; }
          set { _name = value; }
      }
  
      public int Age
      {
          get { return _age; }
          set 
          {
              // 封装的核心：在这里加规则校验
              if (value >= 0 && value <= 150)
              {
                  _age = value;
              }
              else
              {
                  Console.WriteLine("年龄不合法！");
              }
          }
      }
  }

  代码：把字段，属性，方法放进一个[类]里面，就是封装。

2.继承：

儿子可以继承父亲的money,当然妈妈也可以继承。

举个列子：

***父类：电子产品
***子类：手机，耳机，平板

代码例子：

// 父类：动物
class Animal
{
    // 公共属性
    public string Name { get; set; }

    // 父类通用方法
    public void Eat()
    {
        Console.WriteLine($"{Name} 在吃东西");
    }

    public void Sleep()
    {
        Console.WriteLine($"{Name} 在睡觉");
    }
}

作用：代码复用，不用重复写一模一样的代码

3.多态：

同一个方法，父类引用指向不同子类对象，执行的是子类自己的逻辑

举例： 都叫【播放】

**手机播放==》放视频

**耳机播放==》放音乐

**电视播放==》放电视

代码例子：

// 父类
class Animal
{
    // 虚方法：允许子类重写
    public virtual void Cry()
    {
        Console.WriteLine("动物发出叫声");
    }
}

子类继承，用 override 重写方法

// 狗 继承 动物
class Dog : Animal
{
    // 重写父类方法
    public override void Cry()
    {
        Console.WriteLine("汪汪汪");
    }
}

// 猫 继承 动物
class Cat : Animal
{
    public override void Cry()
    {
        Console.WriteLine("喵喵喵");
    }
}

总结：同一个动作，不同对象，表现不同，中就是多态。

4.抽象：

抽象类：只定规矩、不做具体实现，让子类必须帮我实现。有抽象方法的类，必须是抽象类。

举例：你打电话

你只知道：点拨号就能打

你不用管：信号怎么发射，基站怎么连接，电流怎么变化。

代码：

// 抽象类：交通工具
abstract class Vehicle
{
    // 普通方法：有实现，子类直接用
    public void Run()
    {
        Console.WriteLine("交通工具都能跑");
    }

    // 抽象方法：没有实现，强制子类必须写
    public abstract void Fuel();
}

1.封装：打包放一起

2.继承：子类用父类，代码不用重复写

3多态：同一个方法，不同对象不同效果

4抽象：只看功能，不看复杂底层