C#学习笔记正课九-CSDN博客

1、虚方法、重写

父类中的方法添加关键字virtual将方法变为虚方法，在子类方法前加override，在子类中进行重写。

重写和重载的区别
1.重载是方法重载必须在同一个类中；重写得先有继承关系，在父类中声明虚方法在子类中重写
2.重载没有关键字，只需要参数个数、类型和顺序不同就能实现；重写必须要有virtual、override关键字
3.参数在重写时方法的返回值类型和参数两者必须与父类虚方法保持一致否则无法实现重写
4.重写可以实现多重重写

多态的概念
父类中声明的方法，直接实例化父类调用此方法会输出父类中该方法的执行代码。子类继承父类的同一个方法并重写后，实例化子类并调用该方法那么就会实现子类中自己定义的执行代码。

主函数

internal class Program
{
    static void Main(string[] args)
    {
        //虚方法、重写
        Boss b1=new Boss();
        b1.PingA();

        XiaoGuai x1 = new XiaoGuai();
        //子类中重写后的方法属于子类本身与父类无关
        x1.Move();//调用虚方法重写后的方法

        Xxg xx1=new Xxg();
        xx1.Move();
        xx1.PingA();
        //当孙类继承子类时会一并继承父类的字段和方法，孙类可直接调用父类方法
        //孙类调用子类重写的方法时，调用该方法会指向重写后的方法
    }
}

父类Monster

internal class Monster
{
    public int HP {  get; set; }
    public int GongJiLi { get; set; }
    public string Name {  get; set; }
    public double Speed {  get; set; }


    public void PingA()
    {
        Console.WriteLine("抓挠");
    }
    //在子类方法前加override，在子类中进行重写
    public virtual void Move()//父类中的方法添加关键字virtual将方法变为虚方法
    {
        Console.WriteLine("移动");
    }
   
}

子类1Boss

internal class Boss:Monster
{

    //关键字new
    //父类和子类中方法名相同时，调用子类中的方法时会先调用子类本身的方法，将父类方法隐藏起来。
    //这是需要使用new关键字来告诉程序这是特意将父类方法隐藏的。
    //不加new程序会出现警告
    public new void  PingA()
    {
        Console.WriteLine("Boss的强力一击");
    }
    public void JiNeng()
    {
        Console.WriteLine("释放了技能");
    }

    public override void Move()
    {
        Console.WriteLine("Boss的移动");
    }
}

子类2XiaoGuai

internal class XiaoGuai :Monster
{

    public override void Move()
    {
        Console.WriteLine("小怪正在蠕动");
    }
}

2、只读字段readonly

在定义字段时加入关键字readonly该字段就会变为只读字段

如果想要修改只读字段的值
1.通过构造函数修改
2.定义只读字段时直接赋值

internal class Program
{
    static void Main(string[] args)
    {//只读字段
        Class1 c1 = new Class1(15);

  
        Console.WriteLine(c1.c1);//读取c1的值
        
    }
}

 internal class Class1
 {
     public int a;
     private int b;

     public int Getb()
     {
         return b;
     }
     public void Set(int a)
     {
         b = a;
     }

     //重新定义一个字段
     public int b1 
     { 
         get; set; 
     }

     public int b2
     {
         get
         {
             return b;
         }
         set
         {
             b = value;
         }
     }

     //声明一个readonly只读字段
     public readonly int c1=10;

     public Class1(int a)
     {
         c1 = a;
     }
     //如果想要修改只读字段的值
     //1.通过构造函数修改
     //2.定义只读字段时直接赋值
 }

3、密封关键字sealed

当方法一直被重复继承是容易造成代码混乱，为了避免这种情况发生，使用方法将重写一次后的类密封起来，避免重复调用。
在对方法进行重写的时候可以在对应的方法加上密封关键字sealed，这样就无法继续对此方法进行重写。
使用sealed对方法进行密封时只能用在重写的方法里。
密封后的重写不被允许，但在密封前的重写可以正常重写。

 class A
 {
     public virtual void Show()
     {
         Console.WriteLine("A");
     }
 }

 class B:A
 {   
     public sealed override void Show()//添加sealed关键字对方法进行密封
     {
         Console.WriteLine("B");
     }
 }

 class C : B
 {
     public new void Show()//后面的方法无法继续进行重写，只能加new来声明同名方法
     {
         Console.WriteLine("C");
     }
 }

4、抽象类（abstract）

类是一种完整的模板，抽象类是一种不完整的模板。在类前加入abstract关键字就能定义一个抽象类。

主函数

抽象类不是一个完整的模板所以无法进行实例化

internal class Program
{
    static void Main(string[] args)
    {//抽象类
    //类是一种完整的模板，抽象类是一种不完整的模板。
    
        ChouXiangZi c1 = new ChouXiangZi();
        c1.CX();
        //ChouXiang cx1=new ChouXiang();//抽象类不是一个完整的模板所以无法进行实例化
    }
}

父类抽象类

abstract class ChouXiang//加入abstract关键字就能定义一个抽象类
    {
    public int a;
    private double b;
         
    public void GongJi()//抽象类中可以定义普通方法
    {
     Console.WriteLine("三连哈！！！");
    }

    abstract public void CX();//定义一个抽象方法
    }

class PuTong
{
  public abstract void CXFF();//无法在普通类中声明抽象方法,但可以在抽象类中声明普通方法    
}

子类正常类

internal class ChouXiangZi:ChouXiang
{
    //在抽象父类中定义的抽象方法必须要在子类中对父类中抽象方法进行重写，不重写会报错
    public override void CX()
    {
        Console.WriteLine("对抽象方法进行重写");
    }
}