C# 方法重载
c#方法重载
2008-11-14 14:27
首先我们说一下什么是方法重载。在面对对象这样的高级语言中都允许我们在一个类中定义多个方法名相同、方法间参数个数和参数顺序不同的方法，对于参数个数不同或者参数列表不同的情况我们称之为参数列表不同。需要注意的是这里没有提到方法的返回值。也就是决定方法是否构成重载有两个条件：
(1)在同一个类中；
(2)方法名相同；
(3)参数列表不同。
例如下面的代码：
1. public void Show()//(1)
2. {
3. Console.WriteLine("Nothing");
4. }
5.
6. public void Show(int number)//(2)
7. {
8. Console.WriteLine(number);
9. }
10. /*
11. public int Show(int number)//(3)
12. {
13. Console.WriteLine(number);
14. return number % 5;
15. }
16. */
对于上面的代码，(1)没有参数，（2）使用了一个int类型的参数，(1)和(2)之间就构成了重载。(2)与(3)相比仅仅返回值不同，虽然重载不关心返回值的不同，但是在C#中不允许存在方法名和参数列表相同、返回值不同的方法，所以(2)和（3）不能同时存在于代码中，(3)如果不注释掉上面的代码是没有办法通过编译的。
上面我们仅仅讨论了重载的一些基本常识，下面我们探讨一下一些情况稍微复杂的重载情况。
首先我们看第一个版本：
https://www.360docs.net/doc/8316557594.html,ing System;
https://www.360docs.net/doc/8316557594.html,ing System.Collections.Generic;
https://www.360docs.net/doc/8316557594.html,ing System.Text;
4.
https://www.360docs.net/doc/8316557594.html,space OverrideDemo
6.{
7. ///
8. /// 说明：本实例用于讲述重载的关系
9. /// 作者：周公
10. /// 日期：2008-09-04
11. /// 首发地址：https://www.360docs.net/doc/8316557594.html,/zhoufoxcn
12. ///
13. class Program
14. {
15. static void Main(string[] args)
16. {
17. String s = null;
18. Show(s);
19. Object o = "123";
20. Show(o);
21. }
22.
23. static void Show(string s)
24. {
25. Console.WriteLine("String");
26. }
27.
28. static void Show(Object o)
29. {
30. Console.WriteLine("Object");
31. }
32. }
33.}
大家猜猜这个程序的运行结果是什么？
以下是程序运行结果：
String
Object
对以上代码进行分析，我们发现Show()方法有两种形式，一种是string类型的参数，一种是object类型参数，在一个类中存在方法名相同、参数列表不同（参数个数或者参数类型不同）的现象我们称之为overloading，即重载。不过这里的Show()方法的参数比较特殊，因为string类继承于Object类，也就是Show()方法的参数存在一种继承关系。从结果我们可以得出两点结论：
(1)从String s = null;Show(s);最后调用的是static void Show(string s)这个方法我们可以得出，C#中方法调用是精确匹配的，也就是s是string类型，虽然string类型继承自object类型，尽管static void Show(Object o)也满足条件，但是方法声明中static void Show(string s)这个声明与s类型的最接近（因为s是string类型，与它最接近），所以执行static void Show(string s)，而不执行static void
Show(Object o)这个方法。
(2)从Object o = "123"; Show(o);最后调用的是static void Show(Object o)这个方法我们可以得出，C#中如果存在方法重载，会根据其refrence type（引用类型）来调用对象的方法，而不是根据instance type （实例类型）来调用。尽管”123”是string类型，但是它的refrence type是object类型的，所以会调用static void Show(Object o)这个方法而不是static void Show(string s)。
上面的Main()方法的IL代码如下:
.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// 代码大小 24 (0x18)
.maxstack 1
.locals init ([0] string s,
[1] object o)
IL_0000: nop
IL_0001: ldnull
IL_0002: stloc.0
IL_0003: ldloc.0
IL_0004: call void OverrideDemo.Program::Show(string)
IL_0009: nop
IL_000a: ldstr "123"
IL_000f: stloc.1
IL_0010: ldloc.1
IL_0011: call void OverrideDemo.Program::Show(object)
IL_0016: nop
IL_0017: ret
} // end of method Program::Main
从上面的IL代码我们可以看出对于string s=null;这句代码在IL中表示为：ldnull。
再根据上面的结论，我们看下面的代码：
https://www.360docs.net/doc/8316557594.html,ing System;
2.public class Program
3.{ public static void Main()
4. {
5. Show(null);
6. Show("");
7. Show(1)；
8. }
9.
10. static void Show(Object o)
11. {
12. Console.WriteLine("Object");
13. }
14.
15. static void Show(String s)
16. {
17. Console.WriteLine("String");
18. }
19.
20.}
猜猜上面的代码执行结果会是怎样的？
以下是程序运行结果：
String
String(感谢btbtshu、windman0925提醒此处的笔误，原来粘贴错了，成了Object了，现在已更正）Object
从上面的运行结果我们可以得出以下结论：
(1)从Show(null)最后调用的是static void Show(String s)方法我们更进一步可以说在C#中是方法调用尽量精确匹配的。尽管null我们可以理解为一个空object对象或者一个空字符串，但是在这里C#还是精确为派生类。这就像我们没有钱，可以说没有一分钱也可以说没有500英镑，但是没有一分钱自然就没有500亿英镑，所以我们跟别人说没有钱的时候没有必要说没有500亿英镑一样。在这里自然null 就表示空字符串。所以Show(null)这个方法会调用static void Show(String s)这个方法。
这有点像下面的情况：
一次活动大会上，主持人说：“身高不到1.60m的请坐在1到3排，身高不到1.75m的请做到4到6排，其他的请随便坐。”
上面的语句似乎有些逻辑方面的问题，应该说身高超过1.60m但是不到1.75m的请坐到4到6排。但是如果你面对着一群拿着枪的强盗，他说上面的话时，恰好你也在场并且你的身高是1.55m，你会坐到哪一排？你总不可能冒着挨一枪的危险去纠正他的逻辑错误吧？最好的办法是坐到1到3排。因为无论怎么说你的身高是绝对满足不到1.60m这个条件的（尽管你的身高也满足强盗说的第二个条件，即身高不到1.75米，但是你肯定不会冒这个危险，从上下句的意思我们也能推断出人家的意思就是身高在1.61m到1.74m之间的人坐4到6排）。
在上面的代码中，你在运行环境的眼中就是一个持枪的强盗，虽然null可以理解为null类型的string 或者null类型的object，但是它不能向你问清楚这个到底是null类型的string或者null类型的object，因为string是Object的派生类，所以它按照null类型的string来调用相应的方法了。
(2)从Show("")最后调用static void Show(String s)这个方法进一步证明了方法调用是尽量选择参数最匹配的那个执行。因为Show("")相当于：string s = ""; Show(s);s的引用类型是string，所以会调用static void Show(String s)这个方法。
我们在这里可以假设一下：假如存在一个类A是String类的派生类（实际上string类是sealed的，也就是不可继承的，所以我说了是假设），并且存在在上面的代码改变如下：
https://www.360docs.net/doc/8316557594.html,ing System;
2.public class Program
3.{ public static void Main()
4. {
5. Show(null);
6. Show("");
7. }
8.
9. static void Show(Object o)
10. {
11. Console.WriteLine("Object");
12. }
13.
14. static void Show(String s)
15. {
16. Console.WriteLine("String");
17. }
18.
19. static void Show(A a)//假设A是String的派生类，当然实际上String类并没有派生类，这里
仅仅是假设
20. {
21. Console.WriteLine("A");
22. }
23.
24.}
如果上面的假设成立，上面的代码运行结果应该如下：
A
String
(3)为什么Show(1)会调用static void Show(Object o)这个方法呢？在这个类中与Show(1)最精确的方法重载应该是static void Show(int i)这种方法声明，但是方法中没有，因为int是继承自ValueType类，所以
如果没有static void Show(int i)这种声明，那么其次接近的声明应该是static void Show(ValueType v)这种声明，可惜方法中依然没有，不过ValueType类继承自Object类，所以比static void
Show(ValueType v)还次一点的方法重载声明应该是static void Show(Object o)，而类中也确实存在这种声明，所以会调用static void Show(Object o)这个方法。当然从int到Object这个过程中存在一次box，也就是装箱（装箱是从值类型到引用类型的转换），这个可以从下面的IL代码可以看出来。
以下是第二种情况下Main()方法的IL代码：
.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// 代码大小 32 (0x20)
.maxstack 8
IL_0000: nop
IL_0001: ldnull
IL_0002: call void OverrideDemo.Program::Show(string)
IL_0007: nop
IL_0008: ldstr ""
IL_000d: call void OverrideDemo.Program::Show(string)
IL_0012: nop
IL_0013: ldc.i4.1
IL_0014: box [mscorlib]System.Int32
IL_0019: call void OverrideDemo.Program::Show(object)
IL_001e: nop
IL_001f: ret
} // end of method Program::Main
下面我们对第二种情况的代码做一些变化，代码如下：
https://www.360docs.net/doc/8316557594.html,ing System;
https://www.360docs.net/doc/8316557594.html,ing System.Collections.Generic;
https://www.360docs.net/doc/8316557594.html,ing System.Text;
4.
https://www.360docs.net/doc/8316557594.html,space OverrideDemo
6.{
7. ///
8. /// 说明：本实例用于讲述重载的关系
9. /// 作者：周公
10. /// 日期：2008-09-04
11. /// 首发地址：https://www.360docs.net/doc/8316557594.html,/zhoufoxcn
12. ///
13. class Program
14. {
15. static void Main(string[] args)
16. {
17. Show(null);
18. Show("");
19. Show(1);
20. }
21.
22. static void Show(string s)
23. {
24. Console.WriteLine("String");
25. }
26.
27. static void Show(Object o)
28. {
29. Console.WriteLine("Object");
30. }
31.
32. static void Show(Program p)//Program是当前方法所在的类
33. {
34. Console.WriteLine("Program");
35. }
36. }
37.}
上面的代码的运行结果是什么，你能猜出来吗？
哈哈，上面的程序代码是没有运行结果的，因为它没有办法编译！编译情况如下：
为什么不能通过编译呢？
原因就出在Show(null)这个方法这里！如果仅仅有static void Show(string s)和static void Show(Object o)方法构成重载关系，那么null我们既可以理解为空string引用也可以理解为空Object引用，因为string 类型的限制更精确一些，所以C#会按照最精确地匹配成string类型，因而会执行static void
Show(string s)这个方法。这是在前面的代码中已经被证明的。可是现在多了一个static void
Show(Program p)方法的重载，null既可以理解成空string类型引用，也可以理解成空Program类型引用，因为string类和Program类都是Object类的派生类，所以按照前面的推论自然不会当成空Object 类型的引用。因为String类和Program类之间不存在继承关系，按照最精确匹配原则，编译器无法决定匹配成String类还是Program类最精确，所以编译无法通过。
相当于传送默认值....
方法返回方法.....
举个例子
不使用方法重载
public string GetString(string strValues)
{
if(strValues.Length==0)
{
return "今天我遇到无名了。。。。";
}
return "Hello,"+strValues+"兄";
}
使用重载就是
public string GetString()
{
return GetString("我是无名。。。你是？"); }
public string GetString(string strValues) {
return strValues;
}
练习题—方法和方法的重载
一.选择题 1.下列方法定义中，正确的是( )。 A）int x( int a,b ) { return (a-b); } B）double x( int a,int b) { int w; w=a-b; } C）double x( a,b ) { return b; } D）nt x( int a,int b) { return a-b; } 2.下列方法定义中，正确的是( )。 A）void x( int a,int b ); { return (a-b); } B）x( int a,int b) { return a-b; } C）double x { return b; } D）int x( int a,int b) { return a+b; } 3.下列方法定义中，不正确的是( )。 A）float x( int a,int b ) { return (a-b); } B）int x( int a,int b) { return a-b; } C）int x( int a,int b ) { return a*b; } D）int x(int a,int b) { return 1.2*(a+b); } 4.下列方法定义中，正确的是( )。 A）int x( ){ char ch='a'; return (int)ch; } B）void x( ){ ...return true; } C）int x( ){ ...return true; } D）nt x( int a, b){ return a+b; } 5.下列方法定义中，方法头不正确的是( )。 A）public int x( ){ ... } B）public static int x( double y ){ ... } C）void x( double d ) { ... } D）public static x( double a ){ ... } 6.在某个类中存在一个方法：void getSort(int x)，以下能作为这个方法的重载的声明的是( )。 A）public getSort(float x) B）int getSort(int y) C）double getSort(int x,int y) D）void get(int x,int y) 7.在某个类中存在一个方法：void sort(int x),以下不能作为这个方法的重载的声明的是( )。 A）public float sort(float x) B）int sort(int y) C）double sort(int x,int y) D）void sort(double y) 8.为了区分类中重载的同名的不同方法，要求( )。 A）采用不同的形式参数列表B）返回值类型不同 C）调用时用类名或对象名做前缀D）参数名不同
C# 方法重载
c#方法重载 2008-11-14 14:27 首先我们说一下什么是方法重载。在面对对象这样的高级语言中都允许我们在一个类中定义多个方法名相同、方法间参数个数和参数顺序不同的方法，对于参数个数不同或者参数列表不同的情况我们称之为参数列表不同。需要注意的是这里没有提到方法的返回值。也就是决定方法是否构成重载有两个条件： (1)在同一个类中； (2)方法名相同； (3)参数列表不同。 例如下面的代码： 1. public void Show()//(1) 2. { 3. Console.WriteLine("Nothing"); 4. } 5. 6. public void Show(int number)//(2) 7. { 8. Console.WriteLine(number); 9. } 10. /* 11. public int Show(int number)//(3) 12. { 13. Console.WriteLine(number); 14. return number % 5; 15. } 16. */ 对于上面的代码，(1)没有参数，（2）使用了一个int类型的参数，(1)和(2)之间就构成了重载。(2)与(3)相比仅仅返回值不同，虽然重载不关心返回值的不同，但是在C#中不允许存在方法名和参数列表相同、返回值不同的方法，所以(2)和（3）不能同时存在于代码中，(3)如果不注释掉上面的代码是没有办法通过编译的。 上面我们仅仅讨论了重载的一些基本常识，下面我们探讨一下一些情况稍微复杂的重载情况。 首先我们看第一个版本： https://www.360docs.net/doc/8316557594.html,ing System; https://www.360docs.net/doc/8316557594.html,ing System.Collections.Generic; https://www.360docs.net/doc/8316557594.html,ing System.Text; 4. https://www.360docs.net/doc/8316557594.html,space OverrideDemo 6.{ 7. ///
C++重载运算符的几类使用方法
1.非运算符重载实现复数的加法运算//非运算符重载实现复数的加法运算 //complex.h #include
double complex::getimag() { return image; } void complex::display() { cout<<"the result is\n"<
实验五 方法的重载和静态成员
实验五方法的重载和静态成员 【实验目的】 1.巩固掌握构造方法的作用和定义； 2.掌握方法重载的意义和实现方式； 3.掌握静态成员的使用方法。 【实验准备】 复习配套教材相关章节的内容； 【实验内容】 项目一： 1.定义一个游戏中Hero 英雄的类，在该类中定义英雄的名字，生命值和等级 3 个属性，定义一个无参构造方法完成对名字、生命值和等级的初始化，分 别赋初值为“无名英雄”、100和1。同时实现名字和英雄信息的输出。 public class Hero { String name; int healthPower = 100; int grade; public Hero() { https://www.360docs.net/doc/8316557594.html, ="无名英雄"; this.healthPower = 100; this.grade=1; } void showInfo() { System.out.println("——英雄信息——"); System.out.println("名字：" + https://www.360docs.net/doc/8316557594.html,); System.out.println("生命值：" + this.healthPower); System.out.println("类型：" + this.grade); } }
2.在上一步的基础上，为英雄再定义拥有一个参数的构造方法，第一个参数传 入英雄的名字,第二个参数传入一个英雄类型的值，如果为1，则为普通英雄，生命值为100；如果该值为2，则为高级英雄，生命值初始化为200；如果该值为3，则为超级英雄，生命值初始化为300。 Public Hero(String name, int grade) { https://www.360docs.net/doc/8316557594.html, = name; if (grade == 3) { this.healthPower = 300; this.grade = 3; } else if (grade == 2) { this.healthPower = 200; this.grade = 2; } else { this.healthPower = 100; this.grade = 1; } } 3.为英雄添加一个基本战斗的方法，该方法拥有一个英雄类型的参数，当传入 另一个英雄时，能降低对方10点血。再增加一个绝招战斗的重载方法，加入一个绝招类型参数，通过输入不同绝招参数，降低对方不同的血量（这里简化为：1，多杀伤3点血，2，多杀伤6点血，3，多杀伤10点血）。 void fight(Hero opponent) { opponent.healthPower -= 10; } void fight(Hero opponent, int skill) { opponent.healthPower -= 10; if (skill == 3) { opponent.healthPower -= 10; } else if (skill == 2) { opponent.healthPower -= 6; } else if (skill == 1) { opponent.healthPower -= 3; } } 4.在主类的主方法中编写代码，测试。 public static void main(String[] args) { // TODO code application logic here
覆盖和重载的区别与举例
java中覆盖和重载的区别与举例 override可以翻译为覆盖，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点： 1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果； 2、覆盖的方法的返回值必须和被覆盖的方法的返回一致； 3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类； 4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点： 1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int)）； 2、不能通过访问权限、返回类型、抛出的异常进行重载； 3、方法的异常类型和数目不会对重载造成影响； 4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果 class A { protected int method1(int a, int b) { return 0; } } public class B extends A{ public int method1(int a, int b) { return 0; } //正确，重写父类方法，可以扩大访问权限 //private int method1(int a, int b) { return 0; } //错误，重写父类方法，不能降低了访问权限 //private long method1(int a, int b) { return 0; } //错误，重写父类方法，不能改变返回值类型 public short method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型 private int method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型}
Java 方法重载学习
1. 方法的重载 通过定义JiSuan这个方法，实现求三个整数的和，两个整数的和，两个小数的和 public class HelloWorld { public static void main(String[] args) { //求两个整数的和，三个整数的和，两个小数的和，三个小数的和 //如果不用方法的重载，写的方法个数多。另外就是调用的时候，需要根据不同的方法去调用。 int sum=JiSuan(3,4,5); System.out.println(sum); int s=JiSuan(3,4); System.out.println(s); double ss=JiSuan(0.33,0.54); System.out.println(ss); } public static int JiSuan(int a,int b,int c) { int sum=a+b+c;//方法的重载是方法名一样，但是：参数的个数不一样，或者参数的类型不一样。 return sum;//实现的是三个整数数据相加的和} public static int JiSuan(int a,int b) {
int sum=a+b;//实现的是两个整数数据相加的和 return sum; } public static double JiSuan(double a,double b) { double sum=a+b;//实现的是两个小数数据相加的和 return sum; } } 2.定义Print方法，打印一行5个星号 public class HelloWorld { public static void main(String[] args) { Print(); Print(); } public static void Print() { System.out.println("*****"); } }
Java实验3方法和重载
实验3 方法和重载 一、实验目的： 1、学习创建和使用Java方法。 2、学习掌握重载方法。 二、实验任务： 1. 使用Java SDK建立一个标准Java程序，学习创建和使用方法、掌握 向方法传递参数。实现一个方法，接受用户从键盘输入的10个整数，比较并输出其中的最大值和最小值。要求程序能对非法数据进行处理。 2. 学习掌握重载方法。程序要求：创建3个重载的max方法，第一个返 回两个整型参数中较大的一个；第二个返回两个双精度浮点数中较大的一个；第三个返回三个整数中最大的一个。 3. 实现一个方法，求满足1+2!+3!+…+n!<=9999的最大整数n。 三、实验步骤： 任务2参考代码 public class TestMethodOverloading { public static void main(String[] args) { System.out.println("The maximum between 3 and 4 is " + max(3, 4)); System.out.println("The maximum between 3.0 and 5.4 is " + max(3.0, 5.4)); System.out.println("The maximum between 3.0, 5.4, and 10.14 is " + max(3.0, 5.4, 10.14)); } static int max(int num1, int num2) { if (num1 > num2) return num1; else return num2; } static double max(double num1, double num2) { if (num1 > num2) return num1;
万吨重载列车办法
重载、组合列车管理办法 一、万吨重载列车行车组织办法 （一）列车种类 大秦线、北同蒲线及相关线路开行的重载列车有单元和组合两种，单元列车为车辆固定编组，循环使用，机车为动力集中重联牵引；组合列车由指定的机车车辆混编组成。 （二）机车牵引类型、重量 机车类型为DJ1、SS4、8K、HXD1、HXD2，牵引重量为万吨，具体重量和机车运用以及机车匹配根据运输组织的需要，在调度日班计划中确定。 （三）车辆运用 单元列车使用C63、C76、C80、C64等型车辆固定编组，循环使用；组合列车原则上也应固定编组，特殊情况可混编。具体编组形式为： 1.单元列车 （1）105辆C76或C80型车辆编组列车。 （2）120辆C63型车辆编组列车。 （3）110辆C64（C62）型车辆编组列车。 2.组合列车 （1）最高辆数为240，车型为C80。 （2） C61Y与其它车型编组须编入列车前部。 （四）车辆技术检查 1.重载单元、组合列车车辆技术检查，时间为60min。 2.重载列车技检作业布局及质量保证区段按现行普通列车有
关规定执行。对已进行过列检技术作业的列车，在其质量保证区段内遇中途组合、分解继续开行时，只进行简略试验。 3.列车在安太堡、安家岭、店坪、大新、怀仁、柳村南(一场)站及云冈支线各站开车前，列车尾部制动软管压力应达到580kPa，其他车站开车前应达到550kPa。 4.万吨始发站（装车点）技检后经湖东站开往秦皇岛方面的直通货物列车，车次贯通，在原车次前冠以“T”读“通”，加“T”的列车（C63、C76、C80编组）在湖东二场不做技检作业，质量保证到终到站。 （五）调度指挥 重载列车（单元、组合）的开行要在日（班）计划中明确。 万吨重载单元列车车次重车为71002/1-71198/7，空车方向为72002/1-72198/7。组合列车开行车次为：在最前列基本车次前冠以“H”，读音为“合”。组合列车分解后恢复开行基本车次。列车调度员对万吨重载列车及前行、续行列车的编组、运行，特别是在设备限制区间运行情况重点掌握。 （六）列车相关标志 1.在列车运行区段沿线设置接触网双机合电标。合电标距分相绝缘器外沿70m。 2.在具备列车停留、作业条件的车站(含装、卸车点)设置万吨列车停车标。 3.在区间线路上施工使用移动减速信号防护，须在减速地段终端根据列车长度设置“万吨列车减速防护地段终端信号牌”，“万吨列车减速防护地段终端信号牌”为带“W”字的移动减速信号牌昼间与夜间均为反光膜绿底黑字圆牌（在原有绿色圆牌内增加“W”