抽象类/接口以及区别

SUMMARY:

具体类→抽象类→接口：越来越抽象，内部实现的东西越来越少

一、抽象类

抽象类是未完全实现逻辑的类

抽象类为复用而生，专门用作基类

封装确定的，开放不确定的，推迟到合适的子类来实现

抽象类的成员可以是私有的，受保护的，内部的

using UnityEngine;
using System;

public class OCPandObstract : MonoBehaviour
{
    private void Start()
    {
        Vehicle1 vehicle1 = new();
        vehicle1.Run();

        //无法实例化抽象类，只能实现其子类
        Vehicle2 v = new Car2();
        v.Stop();
    }
}
/// <summary>
/// 一个汽车类，一个卡车类，里面的方法都是一样的，重新写两个类就很繁琐
/// </summary>
class Car
{
    public void Run()
    {
        Console.WriteLine("Car is running ..");
    }
    public void Stop()
    {
        Console.WriteLine("Stopped...");
    }
}
class Truck
{
    public void Run()
    {
        Console.WriteLine("Car is running ..");
    }
    public void Stop()
    {
        Console.WriteLine("Stopped...");
    }
}

/// <summary>
/// 简化方法1：使用虚函数进行重写，符合开闭原则
/// </summary>
class Vehicle1
{
    public void Stop()
    {
        Console.WriteLine("Stopped...");
    }
    public virtual void Run()
    {
        Console.WriteLine("Vehicle is running...");
    }
}
class Car1:Vehicle1
{
    public override void Run()
    {
        Console.WriteLine("Car1 is running...");
    }
}
class Truck1:Vehicle1
{
    public override void Run()
    {
        Console.WriteLine("Truck1 is running...");
    }
}

/// <summary>
/// 简化方法2:，使用抽象类，抽象函数，也就是纯虚方法
/// 此时抽象类无法实例化
/// </summary>
abstract class Vehicle2
{
    public  void Stop()
    {
        Console.WriteLine("Stopped...");
    }
    /// <summary>
    /// Run需要重写，因此作为抽象函数，没有实现部分
    /// </summary>
    public abstract void Run();
}
class Car2 : Vehicle2
{
    public override void Run()
    {
        Console.WriteLine("Car2 is running...");
    }
}
class Truck2 : Vehicle2
{
    public override void Run()
    {
        Console.WriteLine("Truck2 is running...");
    }
}

上述代码一步步介绍了为什么使用抽象类，怎么使用抽象函数

抽象方法又称为纯虚方法

二、接口

接口是完全未实现逻辑的“类”

接口是“纯虚类”，只有成员函数，成员全部public

接口为解耦而生，高内聚，低耦合

继承自接口的类必须实现接口中的函数，且自身无法实现

接口中可以有属性，方法，事件，索引

接口成员默认是公开的，且不加任何修饰符

using UnityEngine;

public class OCPandInterface : MonoBehaviour
{
    
}
/// <summary>
/// 纯抽象类
/// </summary>
abstract class AnimalBase
{
    abstract public void Eat();
    abstract public void Sleep();
    abstract public void Walk();
}
/// <summary>
/// 抽象类，继承自纯抽象类
/// </summary>
abstract class Animal : AnimalBase
{
    public override void Eat()
    {

    }
    public override void Sleep()
    {

    }
}
/// <summary>
/// 具体类
/// </summary>
class Dog:Animal
{
    public override void Walk()
    {

    }
}
/// <summary>
/// 具体类
/// </summary>
class Duke : Animal
{
    public override void Walk()
    {

    }
}

/// <summary>
/// 引入interface，它成员变量默认为抽象且公开
/// </summary>
interface IAnimalBase
{
    void Eat();
    void Sleep();
    void Walk();
}
abstract class Animal1 : IAnimalBase
{
    /// <summary>
    /// 继承接口以后，也变成了具体方法
    /// </summary>
    public void Eat()
    {
        
    }

    public void Sleep()
    {

    }

    public abstract void Walk();
}
class Dog1 : Animal1
{
    public override void Walk()
    {

    }
}
class Duke1 : Animal1
{
    public override void Walk()
    {

    }
}

上述代码描述了如何引入的接口，且接口如何定义