C井封装继承多态接口抽象类

封装
把数据藏起来，只留安全入口访问，防止乱改数据。
访问修饰符：private私有（内部用）、public公开（外部调用）

using System;

// 人类
class Person
{
    // 私有字段：外部不能直接修改
    private int age;

    // 公有属性：对外读写入口
    public int Age
    {
        get { return age; } // 读取年龄
        set
        {
            // 封装好处：赋值前做判断，限制非法值
            if (value >= 0 && value <= 120)
                age = value;
            else
                Console.WriteLine("年龄不合法");
        }
    }
}

class Program
{
    static void Main()
    {
        Person p = new Person();
        p.Age = 20;
        Console.WriteLine(p.Age);

        p.Age = 200; // 输出：年龄不合法
    }
}

核心要点,字段用 private 隐藏,用 public 属性做统一访问通道,在 set 里加校验，控制数据合法性.
封装：隐藏内部细节，只对外暴露安全访问入口（控制权限）

继承

using System;
//父类
class Animal
{
    public void Eat()
    {
        Console.WriteLine("吃东西");
    }
}
//子类狗，继承动物
class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("汪汪");
    }
}

class Program
{
    static void Main()
    {
        Dog d = new Dog();
        d.Eat();//继承父类方法
        d.Bark();//自己的方法
    }
}

公共方法子类直接用，不用重写,base 调用父类构造 / 方法,private 私有成员子类拿不到.
继承：代码复用，子类拥有父类所有非私有成员，扩展功能

多态

using System;

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

//子类狗
class Dog : Animal
{
    //重写叫声
    public override void Cry()
    {
        Console.WriteLine("汪汪汪");
    }
}

//子类猫
class Cat : Animal
{
    public override void Cry()
    {
        Console.WriteLine("喵喵喵");
    }
}

class Program
{
    static void Main()
    {
        //父类引用指向子类，多态核心写法
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        //同一个方法，不同结果 = 多态
        a1.Cry();
        a2.Cry();
    }
}

父类方法加 virtual,子类重写加 override,父类变量接收子类实例，实现多态.
多态：同一个方法，不同对象执行不同逻辑（核心：父类引用指向子类）

接口

using System;

// 定义接口：会叫的规范
interface ICry
{
    // 接口方法默认public，不能加修饰符，无方法体
    void Cry();
}

// 狗实现接口，必须完整实现Cry方法
class Dog : ICry
{
    public void Cry()
    {
        Console.WriteLine("汪汪");
    }
}

// 猫实现接口
class Cat : ICry
{
    public void Cry()
    {
        Console.WriteLine("喵喵");
    }
}

class Program
{
    static void Main()
    {
        // 接口引用指向实现类，多态
        ICry animal1 = new Dog();
        ICry animal2 = new Cat();
        animal1.Cry();
        animal2.Cry();
    }
}

接口只能有方法 / 属性声明，不能写代码,类实现接口，必须重写所有接口方法,一个类可以实现多个接口，只能继承一个父类,接口不能实例化，只能用它接收实现类对象
接口：行为规范契约，只定义方法 / 属性，不写实现，多实现弥补单继承缺陷

抽象类

using System;

//抽象父类
abstract class Animal
{
    //普通方法，子类直接继承
    public void Eat()
    {
        Console.WriteLine("吃东西");
    }
    //抽象方法：只有声明，无实现，子类必须override
    public abstract void Cry();
}

//子类继承抽象类，必须实现所有抽象方法
class Dog : Animal
{
    public override void Cry()
    {
        Console.WriteLine("汪汪");
    }
}

class Program
{
    static void Main()
    {
        Animal a = new Dog();
        a.Eat();
        a.Cry();
    }
}

用abstract修饰，不能 new 实例；可写普通方法、抽象方法（无方法体，子类必须重写）
抽象类 vs 接口简短区分
抽象类用abstract class，只能单继承；接口interface，可多实现
抽象类能写完整方法、字段；接口只能声明方法 / 属性，不能写逻辑
抽象类有构造函数；接口无构造函数

C井 封装 继承 多态 接口 抽象类

C井封装继承多态接口抽象类