Vision Studio C#程序设计基础--多态函数重载、多态符号重载、抽象类、虚方法、密封类和静态类

多态函数重载

面向对象四个特性: 封装 继承 多态 抽象
多态: 同一个方法不同形态体现
多态分静态多态和动态多态
静态多态: 函数重载和符号重载
动态多态:抽象和虚方法

静态多态的函数重载:在同一个范围内,函数名一样,参数的类型不一样、参数的个数不一样,
这样的函数就是重载
仅仅只有返回值的类型不一样, 它不属于函数的重载

定义一个class类在里面输入构造函数重载

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("带两个参数的构造函数"); } public void Set() { Console.WriteLine("中午吃饭"); } public void Set(string a) { Console.WriteLine("中午吃"+a); } public void Eat(string a, int count) { Console.WriteLine("中文吃" + a); } }

在Main函数里面调用

static void Main(string[] args) { new People(); new People(10); new People("l1"); new People().Set(); new People().Set("𰻞𰻞面"); new People().Set("豆豉糖"); Console.ReadKey(); }

多态函数符号重载

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

首先定义一个class类

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; } }

在class类里添加对应的符号重载

//重载+ 让两个对象相加 计算两个对象体积相加的结果 //符号重载:定义成静态的方法 在符号前面添加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; } //例子 两个对象相减 返回一个对象 对象包含了属性值为两个对象属性的差值 //s1 - s2 =s3(0,0,0) //s1:10 20 30 //s2:10 20 30 public static Shape operator -(Shape s1, Shape s2) { Shape s3 = new Shape(); s3.X = Math.Abs(s1.X - s2.X); s3.Y = Math.Abs(s1.Y - s2.Y); s3.Z = Math.Abs(s1.Y - s2.Y); return s3; } //重载++符号 public static Shape operator ++(Shape s1) { Shape s3 = new Shape(); s3.X = s1.X++; s3.Y = s1.Y++; s3.Z = s1.Z++; return s3; } //重载一个>符号 public static bool operator >(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z > s2.X * s2.Y * s2.Z; } public static bool operator <(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z < s2.X * s2.Y * s2.Z; } //重载一个==符号 相等 public static bool operator ==(Shape s1, Shape s2) { return s1.X * s1.Y * s1.Z == s2.X * s2.Y * s2.Z; } //重载一个!=符号 不等 public static bool operator !=(Shape s1, Shape s2) { return s1.X* s1.Y* s1.Z != s2.X * s2.Y * s2.Z; }

最后在Main函数里调用实现

static void Main(string[] args) { Shape p1 = new Shape(10,20,30); Shape p2 = new Shape(10,20,30); Console.WriteLine(p1+p2);//允许两个Shape对象相加 Console.WriteLine(10+20);//30 Console.WriteLine((p1-p2).X+"----"+(p1-p2).Y+"------"+(p1-p2).Z);//重载- Console.WriteLine((p1++).X + "----" + (p1++).Y + "------" + (p1++).Z);//重载++ Console.WriteLine(p1>p2);//true 重载> Console.WriteLine(p1<p2);//false 重载< Console.WriteLine((p1==p2)+"---"); Console.WriteLine((p1!=p2)+"---"); //Console.WriteLine(p1+p2); 对象不能相加 Console.ReadKey(); }

抽象类

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

定义抽象类: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 abstract class People { public int Age { get; set; } = 10;//普通的属性 public abstract string Name { get; set; }//抽象属性 //普通方法可以正常定义和实现 public void Eat() { Console.WriteLine("难看"); } //抽象方法不能有方法体 不能加{} public abstract void SayHello(int age); } //在子类实现抽象成员 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("你好=="); } }

在Main函数里调用属性

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(); }

虚方法

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

特点: 添加virtual关键字 可以使方法变成虚方法中 虚方法可以定义普通类中 并且可以实现

首先定义一个类在类里使用虚方法

public class People { public string Name { get; set; }//普通属性 //public abstract int Age { get; set; }抽象成员不能定义在普通类中 //public abstract void Eat();抽象方法不饿能定义在普通类中 public virtual void Eat()//特点: 添加virtual关键字 可以使方法变成虚方法中 虚方法可以定义普通类中 并且可以实现 { Console.WriteLine("People1的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("印度人吃披萨"); } }

在Main函数里调用

static void Main(string[] args) { HanGuo h1 = new HanGuo(); h1.Name = "欧巴"; h1.Eat(); YinDu yd = new YinDu(); yd.Name = "阿三"; yd.Eat(); Console.ReadKey(); }

密封类和静态类

抽象类可以被继承
sealed 密封类:特点是不能够被继承

sealed class A { public string Name { get; set; } public void Eat() { Console.WriteLine("eat"); } static class B { public static int Age { get; set; } public static void Eat() { Console.WriteLine("1111"); } } }

密封类不允许被继承的，虚方法设计的目的就是为了在子类重写这个虚方法，两者的设计理念违背了
以下不能够定义虚方法

public virtual void Eat2() { Console.WriteLine("eat2"); }

class B : A
{}特点不能被继承
静态类:添加静态成员,不能new实例化

密封类的使用

A a = new A(); a.Name = "好"; a.Eat();

静态类的使用

B.Age = 10; B.Eat();

static class静态类：添加静态成员，不能new 实例化
sealed class 密封类，特点不能被继承