tk后缀网站是什么网站,wordpress 后台颜色,营销推广平台都干什么的,微信小程序界面设计上期回顾 - https://www.cnblogs.com/liu-jinxin/p/10826971.html 一、类 当你定义一个类时#xff0c;你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据#xff0c;但它定义了类的名称意味着什么#xff0c;也就是说#xff0c;类的对象由什么组成及在这个对象…上期回顾 - https://www.cnblogs.com/liu-jinxin/p/10826971.html 一、类 当你定义一个类时你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据但它定义了类的名称意味着什么也就是说类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量成为类的成员。 代码示例 1 using System;2 namespace BoxApplication3 {4 class Box5 {6 public double length; // 长度7 public double breadth; // 宽度8 public double height; // 高度9 }
10 class Boxtester
11 {
12 static void Main(string[] args)
13 {
14 Box Box1 new Box(); // 声明 Box1类型为 Box
15 Box Box2 new Box(); // 声明 Box2类型为 Box
16 double volume 0.0; // 体积
17
18 // Box1 详述
19 Box1.height 5.0;
20 Box1.length 6.0;
21 Box1.breadth 7.0;
22
23 // Box2 详述
24 Box2.height 10.0;
25 Box2.length 12.0;
26 Box2.breadth 13.0;
27
28 // Box1 的体积
29 volume Box1.height * Box1.length * Box1.breadth;
30 Console.WriteLine(Box1 的体积 {0}, volume);
31
32 // Box2 的体积
33 volume Box2.height * Box2.length * Box2.breadth;
34 Console.WriteLine(Box2 的体积 {0}, volume);
35 Console.ReadKey();
36 }
37 }
38 }
39 //执行结果
40 //Box1 的体积 210
41 //Box2 的体积 1560 View Code 一、成员函数 类的成员函数是一个在类定义中有它的定义或原型的函数就像其他变量一样。作为类的一个成员它能在类的任何对象上操作且能访问该对象的类的所有成员。 成员变量是对象的属性从设计角度且它们保持私有来实现封装。这些变量只能使用公共成员函数来访问。 代码示例 1 using System;2 namespace BoxApplication3 {4 class Box5 {6 private double length; // 长度7 private double breadth; // 宽度8 private double height; // 高度9 public void setLength( double len )
10 {
11 length len;
12 }
13
14 public void setBreadth( double bre )
15 {
16 breadth bre;
17 }
18
19 public void setHeight( double hei )
20 {
21 height hei;
22 }
23 public double getVolume()
24 {
25 return length * breadth * height;
26 }
27 }
28 class Boxtester
29 {
30 static void Main(string[] args)
31 {
32 Box Box1 new Box(); // 声明 Box1类型为 Box
33 Box Box2 new Box(); // 声明 Box2类型为 Box
34 double volume; // 体积
35
36
37 // Box1 详述
38 Box1.setLength(6.0);
39 Box1.setBreadth(7.0);
40 Box1.setHeight(5.0);
41
42 // Box2 详述
43 Box2.setLength(12.0);
44 Box2.setBreadth(13.0);
45 Box2.setHeight(10.0);
46
47 // Box1 的体积
48 volume Box1.getVolume();
49 Console.WriteLine(Box1 的体积 {0} ,volume);
50
51 // Box2 的体积
52 volume Box2.getVolume();
53 Console.WriteLine(Box2 的体积 {0}, volume);
54
55 Console.ReadKey();
56 }
57 }
58 }
59 //执行结果
60 //Box1 的体积 210
61 //Box2 的体积 1560 View Code 二、构造函数 类的 构造函数 是类的一个特殊的成员函数当创建类的新对象时执行。 构造函数的名称与类的名称完全相同它没有任何返回类型。 代码示例 1 using System;2 namespace LineApplication3 {4 class Line5 {6 private double length; // 线条的长度7 public Line() //构造函数8 {9 Console.WriteLine(对象已创建);
10 }
11
12 public void setLength( double len )
13 {
14 length len;
15 }
16 public double getLength()
17 {
18 return length;
19 }
20
21 static void Main(string[] args)
22 {
23 Line line new Line();
24 // 设置线条长度
25 line.setLength(6.0);
26 Console.WriteLine(线条的长度 {0}, line.getLength());
27 Console.ReadKey();
28 }
29 }
30 }
31 //执行结果
32 //对象已创建
33 //线条的长度 6 View Code 默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数这种构造函数叫做参数化构造函数。这种技术可以帮助你在创建对象的同时给对象赋初始值 代码示例 1 using System;2 namespace LineApplication3 {4 class Line5 {6 private double length; // 线条的长度7 public Line(double len) // 参数化构造函数8 {9 Console.WriteLine(对象已创建length {0}, len);
10 length len;
11 }
12
13 public void setLength( double len )
14 {
15 length len;
16 }
17 public double getLength()
18 {
19 return length;
20 }
21
22 static void Main(string[] args)
23 {
24 Line line new Line(10.0);
25 Console.WriteLine(线条的长度 {0}, line.getLength());
26 // 设置线条长度
27 line.setLength(6.0);
28 Console.WriteLine(线条的长度 {0}, line.getLength());
29 Console.ReadKey();
30 }
31 }
32 }
33 //执行结果
34 //对象已创建length 10
35 //线条的长度 10
36 //线条的长度 6 View Code 三、析构函数 类的 析构函数 是类的一个特殊的成员函数当类的对象超出范围时执行。 析构函数的名称是在类的名称前加上一个波浪形~作为前缀它不返回值也不带任何参数。 析构函数用于在结束程序比如关闭文件、释放内存等之前释放资源。析构函数不能继承或重载。 代码示例 1 using System;2 namespace LineApplication3 {4 class Line5 {6 private double length; // 线条的长度7 public Line() // 构造函数8 {9 Console.WriteLine(对象已创建);
10 }
11 ~Line() //析构函数
12 {
13 Console.WriteLine(对象已删除);
14 }
15
16 public void setLength( double len )
17 {
18 length len;
19 }
20 public double getLength()
21 {
22 return length;
23 }
24
25 static void Main(string[] args)
26 {
27 Line line new Line();
28 // 设置线条长度
29 line.setLength(6.0);
30 Console.WriteLine(线条的长度 {0}, line.getLength());
31 }
32 }
33 }
34 //执行结果
35 //对象已创建
36 //线条的长度 6
37 //对象已删除 View Code 构造函数在创建实例时调用析构函数在结束程序时调用。 四、静态成员 我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时意味着无论有多少个类的对象被创建只会有一个该静态成员的副本。 关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。 代码示例 1 using System;2 namespace StaticVarApplication3 {4 class StaticVar5 {6 public static int num;7 public void count()8 {9 num;
10 }
11 public int getNum()
12 {
13 return num;
14 }
15 }
16 class StaticTester
17 {
18 static void Main(string[] args)
19 {
20 StaticVar s1 new StaticVar();
21 StaticVar s2 new StaticVar();
22 s1.count();
23 s1.count();
24 s1.count();
25 s2.count();
26 s2.count();
27 s2.count();
28 Console.WriteLine(s1 的变量 num {0}, s1.getNum());
29 Console.WriteLine(s2 的变量 num {0}, s2.getNum());
30 Console.ReadKey();
31 }
32 }
33 }
34 //执行结果
35 //s1 的变量 num 6
36 //s2 的变量 num 6 View Code 你也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。 代码示例 1 using System;2 namespace StaticVarApplication3 {4 class StaticVar5 {6 public static int num;7 public void count()8 {9 num;
10 }
11 public static int getNum()
12 {
13 return num;
14 }
15 }
16 class StaticTester
17 {
18 static void Main(string[] args)
19 {
20 StaticVar s new StaticVar();
21 s.count();
22 s.count();
23 s.count();
24 Console.WriteLine(变量 num {0}, StaticVar.getNum());
25 Console.ReadKey();
26 }
27 }
28 }
29 //执行结果
30 //变量 num 3 View Code 将类成员函数声明为public static无需实例化即可调用类成员函数。 反之如果不声明为static即使和Main方法从属于同一个类也必须经过实例化 代码示例 1 //示例一2 using System;3 4 namespace ConsoleApp5 {6 class Program7 {8 static void Main(string[] args)9 {
10 int num AddClass.Add(2, 3); //编译通过
11 Console.WriteLine(num);
12 }
13 }
14
15 class AddClass
16 {
17 public static int Add(int x,int y)
18 {
19 return x y;
20 }
21 }
22 }
23
24 //示例二
25 using System;
26
27 namespace ConsoleApp
28 {
29 class Program
30 {
31 static void Main(string[] args)
32 {
33 int num Add(2, 3); //编译错误即使改为Program.Add(2, 3);也无法通过编译
34 Console.WriteLine(num);
35 }
36
37 public int Add(int x, int y)
38 {
39 return x y;
40 }
41 }
42 }
43 using System;
44
45 namespace ConsoleApp
46 {
47 class Program
48 {
49 static void Main(string[] args)
50 {
51 Program self new Program();
52 int num self.Add(2, 3); //编译通过
53 Console.WriteLine(num);
54 }
55
56 public int Add(int x, int y)
57 {
58 return x y;
59 }
60 }
61 } View Code 注 我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时意味着无论有多少个类的对象被创建只会有一个该静态成员的副本。 关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。 二、封装 封装是面向对象程序设计中最重要的概念之一。封装 被定义为把一个或多个项目封闭在一个物理的或者逻辑的包中。在面向对象程序设计方法论中封装是为了防止对实现细节的访问。 抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化封装则使开发者实现所需级别的抽象。 C# 封装根据具体的需要设置使用者的访问权限并通过 访问修饰符 来实现。 一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示 1、public所有对象都可以访问 2、private对象本身在对象内部可以访问 3、protected只有该类对象及其子类对象可以访问 4、internal同一个程序集的对象可以访问 5、protected internal访问限于当前程序集或派生自包含类的类型。 一、public Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。 代码示例 1 using System;2 namespace RectangleApplication3 {4 class Rectangle5 {6 //成员变量7 public double length;8 public double width;9
10 public double GetArea()
11 {
12 return length * width;
13 }
14 public void Display()
15 {
16 Console.WriteLine(长度 {0}, length);
17 Console.WriteLine(宽度 {0}, width);
18 Console.WriteLine(面积 {0}, GetArea());
19 }
20 }// Rectangle 结束
21
22 class ExecuteRectangle
23 {
24 static void Main(string[] args)
25 {
26 Rectangle r new Rectangle();
27 r.length 4.5;
28 r.width 3.5;
29 r.Display();
30 Console.ReadLine();
31 }
32 }
33 }
34 //执行结果
35 //长度 4.5
36 //宽度 3.5
37 //面积 15.75 View Code 二、private Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。 代码示例 1 using System;2 namespace RectangleApplication3 {4 class Rectangle5 {6 //成员变量7 private double length;8 private double width;9
10 public void Acceptdetails()
11 {
12 Console.WriteLine(请输入长度);
13 length Convert.ToDouble(Console.ReadLine());
14 Console.WriteLine(请输入宽度);
15 width Convert.ToDouble(Console.ReadLine());
16 }
17 public double GetArea()
18 {
19 return length * width;
20 }
21 public void Display()
22 {
23 Console.WriteLine(长度 {0}, length);
24 Console.WriteLine(宽度 {0}, width);
25 Console.WriteLine(面积 {0}, GetArea());
26 }
27 }//end class Rectangle
28 class ExecuteRectangle
29 {
30 static void Main(string[] args)
31 {
32 Rectangle r new Rectangle();
33 r.Acceptdetails();
34 r.Display();
35 Console.ReadLine();
36 }
37 }
38 }
39 //执行结果
40 //请输入长度
41 //4.4
42 //请输入宽度
43 //3.3
44 //长度 4.4
45 //宽度 3.3
46 //面积 14.52 View Code 三、protected Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。我们将在继承的章节详细讨论这个。更详细地讨论这个。 四、internal Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。 代码示例 1 using System;2 3 namespace RectangleApplication4 {5 class Rectangle6 {7 //成员变量8 internal double length;9 internal double width;
10
11 double GetArea()
12 {
13 return length * width;
14 }
15 public void Display()
16 {
17 Console.WriteLine(长度 {0}, length);
18 Console.WriteLine(宽度 {0}, width);
19 Console.WriteLine(面积 {0}, GetArea());
20 }
21 }//end class Rectangle
22 class ExecuteRectangle
23 {
24 static void Main(string[] args)
25 {
26 Rectangle r new Rectangle();
27 r.length 4.5;
28 r.width 3.5;
29 r.Display();
30 Console.ReadLine();
31 }
32 }
33 }
34 //执行结果
35 //长度 4.5
36 //宽度 3.5
37 //面积 15.75 View Code 五、protected internal Protected Internal 访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承。 注 Pubilc 任何公有成员可以被外部的类访问。 Private 只有同一个类中的函数可以访问它的私有成员。 Protected 该类内部和继承类中可以访问。 internal : 同一个程序集的对象可以访问。 Protected internal 3 和 4 的并集符合任意一条都可以访问。 1、范围比较private internal/protected protected internal public 2、public 和 internal 修饰符的区别 一个是国际妓女谁用都可以就是 public一个是不懂外语的只能在国内做生意就是 internal只能在当前所在的工程里面引用。你建两个工程建立一个引用关系被引用的里面建两个类就能区别了。用 VS 的话你根本点不出来那个不懂外语的。 三、继承 继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。 当创建一个类时程序员不需要完全重新编写新的数据成员和成员函数只需要设计一个新的类继承了已有的类的成员即可。这个已有的类被称为的基类这个新的类被称为派生类。 继承的思想实现了 属于IS-A 关系。例如哺乳动物 属于IS-A 动物狗 属于IS-A 哺乳动物因此狗 属于IS-A 动物。 基类与派生类一个类可以派生自多个类或接口这意味着它可以从多个基类或接口继承数据和函数。 - 父类与子类。 一、基类的初始化 派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。 代码示例 1 using System;2 namespace RectangleApplication3 {4 class Rectangle5 {6 // 成员变量7 protected double length;8 protected double width;9 public Rectangle(double l, double w)
10 {
11 length l;
12 width w;
13 }
14 public double GetArea()
15 {
16 return length * width;
17 }
18 public void Display()
19 {
20 Console.WriteLine(长度 {0}, length);
21 Console.WriteLine(宽度 {0}, width);
22 Console.WriteLine(面积 {0}, GetArea());
23 }
24 }//end class Rectangle
25 class Tabletop : Rectangle
26 {
27 private double cost;
28 public Tabletop(double l, double w) : base(l, w)
29 { }
30 public double GetCost()
31 {
32 double cost;
33 cost GetArea() * 70;
34 return cost;
35 }
36 public void Display()
37 {
38 base.Display();
39 Console.WriteLine(成本 {0}, GetCost());
40 }
41 }
42 class ExecuteRectangle
43 {
44 static void Main(string[] args)
45 {
46 Tabletop t new Tabletop(4.5, 7.5);
47 t.Display();
48 Console.ReadLine();
49 }
50 }
51 }
52 //执行结果
53 //长度 4.5
54 //宽度 7.5
55 //面积 33.75
56 //成本 2362.5 View Code 二、多重继承 多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对单一继承指一个类别只可以继承自一个父类。 C# 不支持多重继承。但是您可以使用接口来实现多重继承。 代码示例 1 using System;2 namespace InheritanceApplication3 {4 class Shape 5 {6 public void setWidth(int w)7 {8 width w;9 }
10 public void setHeight(int h)
11 {
12 height h;
13 }
14 protected int width;
15 protected int height;
16 }
17
18 // 基类 PaintCost
19 public interface PaintCost
20 {
21 int getCost(int area);
22
23 }
24 // 派生类
25 class Rectangle : Shape, PaintCost
26 {
27 public int getArea()
28 {
29 return (width * height);
30 }
31 public int getCost(int area)
32 {
33 return area * 70;
34 }
35 }
36 class RectangleTester
37 {
38 static void Main(string[] args)
39 {
40 Rectangle Rect new Rectangle();
41 int area;
42 Rect.setWidth(5);
43 Rect.setHeight(7);
44 area Rect.getArea();
45 // 打印对象的面积
46 Console.WriteLine(总面积 {0}, Rect.getArea());
47 Console.WriteLine(油漆总成本 ${0} , Rect.getCost(area));
48 Console.ReadKey();
49 }
50 }
51 }
52 //执行结果
53 //总面积 35
54 //油漆总成本 $2450 View Code 注 为什么一个对象可以用父类声明却用子类实例化 这个实例是子类的但是因为你声明时是用父类声明的所以你用正常的办法访问不到子类自己的成员只能访问到从父类继承来的成员。 在子类中用 override 重写父类中用 virtual 申明的虚方法时实例化父类调用该方法执行时调用的是子类中重写的方法 如果子类中用 new 覆盖父类中用 virtual 申明的虚方法时实例化父类调用该方法执行时调用的是父类中的虚方法 1 /// summary 2 /// 父类 3 /// /summary 4 public class ParentClass 5 { 6 public virtual void ParVirMethod() 7 { 8 Console.WriteLine(父类的方法...); 9 }
10 }
11
12 /// summary
13 /// 子类1
14 /// /summary
15 public class ChildClass1 : ParentClass
16 {
17 public override void ParVirMethod()
18 {
19 Console.WriteLine(子类1的方法...);
20 }
21 }
22
23 /// summary
24 /// 子类2
25 /// /summary
26 public class ChildClass2 : ParentClass
27 {
28 public new void ParVirMethod()
29 {
30 Console.WriteLine(子类2的方法...);
31 }
32
33 public void Test()
34 {
35 Console.WriteLine(子类2的其他方法...);
36 }
37 }
38
39 //执行调用
40 ParentClass par new ChildClass1();
41 par.ParVirMethod(); //结果子类1的方法调用子类的方法实现了多态
42
43 par new ChildClass2();
44 par.ParVirMethod(); //结果父类的方法调用父类的方法没有实现多态 View Code 深究其原因为何两者不同是因为原理不同 override是重写即将基类的方法在派生类里直接抹去重新写故而调用的方法就是子类方法而new只是将基类的方法在派生类里隐藏起来故而调用的仍旧是基类方法。 应用举例 有这样的需要,比如 People 类有一个 Run 方法Man 和 Woman 这两个类都是继承自 People 的类并且都重写(override)了 Run 这个方法(男人女人跑起步来不一样)。 现在有一群人一起跑步有男人有女人。 我们可以把这些都装进一个People数组(假设为peoples)。 然后: foreach(People p in peoples) // peoples中对象不同即有男有女用于实例化的子类就不同。 { p.Run(); // 故而调用的方法也不同实现了多态 } 由于多态性,在调用 p.Run() 的时候 p 对象本身如果是男人就会自动调用男人的 Run 方法,是女人就会调用女人的 Run 方法。 依赖倒置原则 依赖倒置原则DIP,Dependency Inverse Principle DIP的表述是 1、高层模块不应该依赖于低层模块, 二者都应该依赖于抽象。 2、抽象不应该依赖于细节,细节应该依赖于抽象。 这里说的“依赖”是使用的意思如果你调用了一个类的一个方法就是依赖这个类如果你直接调用这个类的方法就是依赖细节细节就是具体的类但如果你调用的是它父类或者接口的方法就是依赖抽象 所以 DIP 说白了就是不要直接使用具体的子类而是用它的父类的引用去调用子类的方法这样就是依赖于抽象不依赖具体。 其实简单的说DIP 的好处就是解除耦合用了 DIP 之后调用者就不知道被调用的代码是什么因为调用者拿到的是父类的引用它不知道具体指向哪个子类的实例更不知道要调用的方法具体是什么所以被调用代码被偷偷换成另一个子类之后调用者不需要做任何修改 这就是解耦了。 四、多态 多态性意味着有多重形式。在面向对象编程范式中多态性往往表现为一个接口多个功能。 多态性可以是静态的或动态的。在静态多态性中函数的响应是在编译时发生的。在动态多态性中函数的响应是在运行时发生的。 一、静态多态性 在编译时函数和对象的连接机制被称为早期绑定也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为 函数重载运算符重载 运算符重载将在下一章节讨论接下来我们将讨论函数重载。 二、函数重载 您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同可以是参数列表中的参数类型不同也可以是参数个数不同。不能重载只有返回类型不同的函数声明。下面的实例演示了几个相同的函数 print()用于打印不同的数据类型 代码示例 1 using System;2 namespace PolymorphismApplication3 {4 class Printdata5 {6 void print(int i)7 {8 Console.WriteLine(Printing int: {0}, i );9 }
10
11 void print(double f)
12 {
13 Console.WriteLine(Printing float: {0} , f);
14 }
15
16 void print(string s)
17 {
18 Console.WriteLine(Printing string: {0}, s);
19 }
20 static void Main(string[] args)
21 {
22 Printdata p new Printdata();
23 // 调用 print 来打印整数
24 p.print(5);
25 // 调用 print 来打印浮点数
26 p.print(500.263);
27 // 调用 print 来打印字符串
28 p.print(Hello C);
29 Console.ReadKey();
30 }
31 }
32 }
33 //执行结果
34 //Printing int: 5
35 //Printing float: 500.263
36 //Printing string: Hello C View Code 三、动态多态性 C# 允许您使用关键字 abstract 创建抽象类用于提供接口的部分类的实现。当一个派生类继承自该抽象类时实现即完成。抽象类包含抽象方法抽象方法可被派生类实现。派生类具有更专业的功能。 请注意下面是有关抽象类的一些规则 您不能创建一个抽象类的实例。您不能在一个抽象类外部声明一个抽象方法。通过在类定义前面放置关键字 sealed可以将类声明为密封类。当一个类被声明为 sealed 时它不能被继承。抽象类不能被声明为 sealed。 代码示例 1 using System;2 namespace PolymorphismApplication3 {4 abstract class Shape5 {6 abstract public int area();7 }8 class Rectangle: Shape9 {
10 private int length;
11 private int width;
12 public Rectangle( int a0, int b0)
13 {
14 length a;
15 width b;
16 }
17 public override int area ()
18 {
19 Console.WriteLine(Rectangle 类的面积);
20 return (width * length);
21 }
22 }
23
24 class RectangleTester
25 {
26 static void Main(string[] args)
27 {
28 Rectangle r new Rectangle(10, 7);
29 double a r.area();
30 Console.WriteLine(面积 {0},a);
31 Console.ReadKey();
32 }
33 }
34 }
35 //执行结果
36 //Rectangle 类的面积
37 //面积 70 View Code 当有一个定义在类中的函数需要在继承类中实现时可以使用虚方法。虚方法是使用关键字 virtual 声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。 动态多态性是通过 抽象类 和 虚方法 实现的。 代码示例 1 using System;2 namespace PolymorphismApplication3 {4 class Shape 5 {6 protected int width, height;7 public Shape( int a0, int b0)8 {9 width a;
10 height b;
11 }
12 public virtual int area()
13 {
14 Console.WriteLine(父类的面积);
15 return 0;
16 }
17 }
18 class Rectangle: Shape
19 {
20 public Rectangle( int a0, int b0): base(a, b)
21 {
22
23 }
24 public override int area ()
25 {
26 Console.WriteLine(Rectangle 类的面积);
27 return (width * height);
28 }
29 }
30 class Triangle: Shape
31 {
32 public Triangle(int a 0, int b 0): base(a, b)
33 {
34
35 }
36 public override int area()
37 {
38 Console.WriteLine(Triangle 类的面积);
39 return (width * height / 2);
40 }
41 }
42 class Caller
43 {
44 public void CallArea(Shape sh)
45 {
46 int a;
47 a sh.area();
48 Console.WriteLine(面积 {0}, a);
49 }
50 }
51 class Tester
52 {
53
54 static void Main(string[] args)
55 {
56 Caller c new Caller();
57 Rectangle r new Rectangle(10, 7);
58 Triangle t new Triangle(10, 5);
59 c.CallArea(r);
60 c.CallArea(t);
61 Console.ReadKey();
62 }
63 }
64 }
65 //执行结果
66 //Rectangle 类的面积
67 //面积70
68 //Triangle 类的面积
69 //面积25 View Code 注 1、virtual和abstract都是用来修饰父类的通过覆盖父类的定义让子类重新定义。 virtual修饰的方法必须有实现哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。virtual可以被子类重写而abstract必须被子类重写。如果类成员被abstract修饰则该类前必须添加abstract因为只有抽象类才可以有抽象方法。无法创建abstract类的实例只能被继承无法实例化。 2、overload和override 重载(overload)是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制。 重写(override)是用于重写基类的虚方法,这样在派生类中提供一个新的方法。 3、抽象方法和虚方法 虚方法必须有实现部分抽象方法没有提供实现部分抽象方法是一种强制派生类覆盖的方法否则派生类将不能被实例化。 抽象方法只能在抽象类中声明虚方法不是。如果类包含抽象方法那么该类也是抽象的也必须声明类是抽象的。 抽象方法必须在派生类中重写这一点和接口类似虚方法不需要再派生类中重写。 简单说抽象方法是需要子类去实现的。虚方法是已经实现了的可以被子类覆盖也可以不覆盖取决于需求。抽象方法和虚方法都可以供派生类重写。 对于面向对象的特性推荐几篇不错的文章 https://www.cnblogs.com/harrogath/p/6445793.html https://www.cnblogs.com/autumn001/p/9036148.html 五、下期预告-敬请期待 -运算符重载 -接口 -命名空间 -预处理器指令 -正则表达式 -异常处理 -文件的输入输出 参考文献https://www.runoob.com/csharp/csharp-encapsulation.html 根据w3school自我温习一下c#基础分享给大家。转载于:https://www.cnblogs.com/liu-jinxin/p/10831189.html
