面向对象(OO，封装、继承、多态)

多态：允许将子类类型的指针赋值给父类类型的指针

1.抽象 （子类继承父类，若要定义构造方法，则父类必须要有对应的构造方法）

using System;

namespace MyOO.Abstract
{
    /// <summary>
    /// 基础抽象类
    /// </summary>
    public abstract class BaseCar
    {
        public BaseCar(string window)
        {
            Console.WriteLine($"基础类{window}");
        }
        //抽象方法
        public abstract void AbstractColor();//子类必须实现(override)的方法
        //虚方法
        public virtual void VirtualTyre()//可以不重写，但是为了规范须在Public 前加 new 区分是子类方法，如果重写(override)，则同上方法一致
        {
            Console.WriteLine("是什么轮胎");
        }
        //虚方法
        public virtual void NewVirtualEngine()//可以不重写，但是为了规范须在Public 前加 new 区分是子类方法，如果重写(override)，则同上方法一致
        {
            Console.WriteLine("是什么引擎");
        }
        public virtual void VirtualBody()
        {
            Console.WriteLine("是什么车身");
        }
        public void NormalLogo()//不能被重写
        {
            Console.WriteLine("是什么车标");
        }
    }
    /// <summary>
    /// 保时捷类
    /// </summary>
    public class Porsche : BaseCar
    {
        public Porsche(string window) : base(window)
        {
            Console.WriteLine($"保时捷的{window}");
        }
        public override void AbstractColor()//重写抽象方法
        {
            Console.WriteLine("保时捷红色");
        }
        public override void VirtualTyre()//重写虚方法
        {
            Console.WriteLine("保时捷的轮胎");
        }
        new public void NewVirtualEngine()//写一个自己的方法，new区分父类方法
        {
            Console.WriteLine("保时捷的引擎");
        }

        public sealed override void VirtualBody()//sealed 代表子类不能再override这个方法
        {
            base.VirtualBody();//调用父类的该方法
        }
        new public void NormalLogo()
        {
            Console.WriteLine("保时捷的车标");
        }
    }
    /// <summary>
    /// 保时捷911类
    /// </summary>
    public class Porsche911 : Porsche
    {
        public Porsche911() : this("蓝色的窗户玻璃") { }//实例化类的时候，要先实例化本类对应的构造方法
        public Porsche911(string window) : base(window)//实例化类的时候，要先实例化父类对应的构造方法
        {
            Console.WriteLine($"保时捷911的{window}");
        }
        public override void AbstractColor()//重写抽象方法
        {
            Console.WriteLine("保时捷911红色");
        }
        public override void VirtualTyre()//重写虚方法
        {
            Console.WriteLine("保时捷911的轮胎");
        }
        new public void NewVirtualEngine()//写一个自己的方法，new区分父类方法
        {
            Console.WriteLine("保时捷911的引擎");
        }

        //public override void VirtualBody()//报错
        //{
        //    base.VirtualBody();
        //}
        new public void NormalLogo()
        {
            Console.WriteLine("保时捷911的车标");
        }
    }
}

using MyOO.Abstract;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyOO
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("-------------保时捷-----------");
            BaseCar porsche = new Porsche();
            porsche.AbstractColor();//重写的抽象方法，采用子类，运行时确认,为了灵活
            porsche.VirtualTyre();//重写的虚方法，采用子类，运行时确认,为了灵活
            porsche.NewVirtualEngine();//采用new用的还是父类的,编译时确认，性能最高的
            porsche.NormalLogo();//父类自己定义的用的是父类的,编译时确认，性能最高的

            Console.WriteLine("-------------保时捷911-----------");

            BaseCar porsche911 = new Porsche911("白色的窗户玻璃");
            new Porsche911();
            Console.WriteLine("-------------保时捷的基础类-----------");
            porsche911.AbstractColor();//重写的抽象方法，采用子类，运行时确认,为了灵活
            porsche911.VirtualTyre();//重写的虚方法，采用子类，运行时确认,为了灵活
            porsche911.NewVirtualEngine();//采用new用的还是父类的,编译时确认，性能最高的
            porsche911.VirtualBody();
            porsche911.NormalLogo();//父类自己定义的用的是父类的,编译时确认，性能最高的
        }
    }
}

2.接口

using System;

namespace MyOO.Interface
{
    public interface IHouse
    {
        void Window();
        void Style();
        void Position();
    }
    public interface IGarden
    {
        void Color();
        void Rockery();
    }
    public class Villa : IHouse, IGarden
    {
        public void Color()
        {
            throw new NotImplementedException();
        }

        public void Position()
        {
            throw new NotImplementedException();
        }

        public void Rockery()
        {
            throw new NotImplementedException();
        }

        public void Style()
        {
            throw new NotImplementedException();
        }

        public void Window()
        {
            throw new NotImplementedException();
        }
    }
}