【第14天】14c#今日小结

原创于 2025-12-18 19:18:14 发布 · 427 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言

1.多态之函数重载

多态:同一个方法不同形态体现，
多态分静态多态和动态多态
静态多态:函数重载和符号重载
动态多态：抽象和虚方法

函数重载：在同一个范围内，函数名一样，参数的类型不一样、参数的个数不一样，这样函数就是重载

仅仅只有返回值类型不一样，不属于函数的重载

class People
{
    //构造函数重载
    public People()
    {
        Console.WriteLine("不带参数的构造函数");
    }
    public People(int a)
    {
        Console.WriteLine("带一个整型参数的构造函数");
    }

    public People(string a)
    {
        Console.WriteLine("带一个字符串参数的构造函数");
    }
    public People(string a,int b)
    {
        Console.WriteLine("带2个参数的构造函数");
    }

    public void Eat()
    {
        Console.WriteLine("中文吃饭");
    }
    public void Eat(string a)
    {
        Console.WriteLine("中文吃"+a);
    }

    public void Eat(string a,int count)
    {
        Console.WriteLine("中文吃" + a);
    }
}

static void Main(string[] args)
{
    
    new People("11");

    new People().Eat();
    new People().Eat("biangbiang面");
    new People().Eat("豆豉糖");
    Console.ReadKey();
}

2.符号重载

符号重载：把常用的算术运算符号、逻辑运算符号按照自己的定义方式进行运算能够使对象进行运算
例如+，可以计算俩个数字相加， 10+10=20
如果想实现俩个对象相加可以通过符号重载实现

符号重载：定义成静态的方法，在符号前面添加operator关键字

class Shape
{
    public int X { get; set; }//长
    public int Y { get; set; } //宽
    public int Z { get; set; }// 高
    public Shape()
    {

    }
    public Shape(int x, int y, int z)
    {
        this.X = x;
        this.Y = y;
        this.Z = z;
    }
    //重载+ 让俩个对象相加，计算俩个对象体积相加的结果
    //符号重载：定义成静态的方法 ，在符号前面添加operator关键字
    public static int operator +(Shape s1, Shape s2)
    {
        //s1.X*s1.Y*s1.Z s1的体积
        //s2.X * s2.Y * s2.Z s2的体积
        return s1.X * s1.Y * s1.Z + s2.X * s2.Y * s2.Z;
    }
}

static void Main(string[] args)
{
    
    Shape p1 = new Shape(100,200,300);
    Shape p2 = new Shape(10,20,30);

    Console.WriteLine(p1+p2);// 允许俩个Shape对象相加  重载+
}

3.抽象类

动态多态表现:抽象
抽象类：用于提供类的部分成员实现，包含抽象方法也可以普通的方法，如果是抽象方法不用去实现，谁继承这个抽象类谁去实现抽象方法
抽象类里面也可以定义抽象成员，如果是抽象成员，需要在派生类去实现成员

定义抽象类 public abstract class People{}
定义抽象方法 public abstract void SayHello(int a) ;

派生类实现的时候添加override关键字 public override void SayHello(int a) { Console.WriteLine("你好吃了么"); }

//定义抽象类 public abstract class People{}
public abstract class People
{
    public int Age { get; set; } = 10;// 普通的属性

    //public abstract string Name { get; set; } = "上海一女子单身46死亡了 遗产几百万被当地民政局没收，墓地费需要表弟承担"; // 抽象属性 不能赋值

    public abstract string Name { get; set; }

    //普通方法可以正常定义和实现
    public void Eat()
    {
        Console.WriteLine("吃相难看");
    }

    //抽象方法不能有方法体 不能加{}
    public abstract void SayHello(int a) ;
}

//在子类实现抽象成员
public class China : People
{
    //需要重写抽象成员和抽象方法
    //重写关键字 override
    public override string Name { get; set; } = "南京博物馆火了";

    //重写抽象方法
    public override void SayHello(int a)
    {
        Console.WriteLine("你好 吃了么");
    }
}
public class Japan : People
{
    public override string Name { get; set; } = "高斯早苗";
    public override void SayHello(int a)
    {
        Console.WriteLine("こんにちは (Konnichiwa)");
        // สวัสดี（发音：sa - wàt - dii）
        // 안녕하세요（An-nyeong-ha-se-yo）
    }
}

static void Main(string[] args)
{
    

    China china = new China();
    china.Age = 10;//继承过来的普通属性
    china.Name = "ss";//调用子类的实现的抽象成员
    china.SayHello(10);//调用子类的实现的抽象方法
    china.Eat();//继承过来的普通方法

    Japan japan = new Japan();
    japan.SayHello(10); // 调用子类的实现的抽象方法
    japan.Eat();// 继承过来的普通方法
        



    Console.ReadKey();
}

4.虚方法

抽象方法和虚方法的区别
1 抽象成员和抽象方法只能定义抽象类里面，但是虚方法和虚成员可以定义普通类里面
2 抽象方法和抽象成员在抽象类不能实现，但是虚方法和虚成员可以定义普通类里面可以实现
3 抽象方法和抽象成员在派生类必须实现，但是虚方法和虚成员可以不用在派生类实现
4 可以使用overrid重写基类的抽象方法或者虚方法

public class People
{
    public virtual int A { get; set; } = 10;
    public string Name { get; set; } // 普通属性
    //public abstract int Age { get; set; }// 抽象成员不能定义在普通类中
    //public abstract void Eat(); //抽象方法不能定义在普通类中

    public virtual void Eat() //添加virtual关键字 使方法变成虚方法，虚方法可以定义普通类中,并且可以实现。
    {
        Console.WriteLine("Peoplel的eat方法");
    }

}
public class HanGuo : People
{
    //通过重写override基类虚方法
    public override void Eat()
    {
        Console.WriteLine("韩国吃泡菜");
    }

} 
public class YinDu:People
{
   
    //new 新建一个eat方法，和基类eat的方法没有任何关系，
    public new void  Eat()
    {
        Console.WriteLine("印度人吃咖喱");
    }
}

static void Main(string[] args)
{

    HanGuo h1 = new HanGuo();
    h1.Name = "金喜善";
    h1.Eat();

    YinDu yd = new YinDu();
    yd.Name = "阿三";
    yd.Eat();
    Console.ReadKey(); 
}

5.密封类和静态类

 //抽象类被继承
 // sealed 密封类，特点不能被继承
 public sealed class A 
 {
   public string Name {  get; set; }
  public void Eat()
  {
         Console.WriteLine("eat");
  }
   //密封类不允许被继承的，虚方法设计目的就是为了在子类重写这个虚方法，俩者设计理念违背了
  //public virtual void Eat2()
  //{
  //       Console.WriteLine("aa1");
  //}
}
 //class B :A{ } 特点不能被继承
 //静态类：添加静态成员，不能new 实例化
 static class B
 {
     public static int Age { get; set; }
     public static void Eat() { Console.WriteLine("111"); }
     
 }

 static void Main(string[] args)
 {
     // 密封类的使用
     A a = new A();
     a.Name = "好";
     a.Eat();

     // 静态类的使用
     B.Age = 10;
     B.Eat();

      //static class静态类：添加静态成员，不能new 实例化
     //sealed class 密封类，特点不能被继承
     Console.ReadKey();
 }