方法重载时编译处理

❶ java中方法重载和重写的区别

重载overloading
1)方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载是一个类中多态性的一种表现。
2)Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型给它们的不同参数个数和参数类型来决定具体使用哪个方法,这就是多态性。
3)重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

例子
packagec04.answer;//这是包名
//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。不同的重载方法bark是根据其参数类型的不同而区分的。
//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。
packagec04.answer;
publicclassDog{
Dog(){
this.bark();
}
voidbark()//bark()方法是重载方法
{
System.out.println("nobarking!");
this.bark("female",3.4);
}
voidbark(Stringm,doublel)//注意：重载的方法的返回值都是一样的，
{
System.out.println("abarkingdog!");
this.bark(5,"China");
}
voidbark(inta,Stringn)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
{
System.out.println("ahowlingdog");
}
publicstaticvoidmain(String[]args)
Dogdog=newDog();
//dog.bark();
//dog.bark("male","yellow");
//dog.bark(5,"China");重写overriding
1)父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

3)子类函数的访问修饰权限不能少于父类的；
例子
publicclassBase
{
voidtest(inti)
{
System.out.print(i);
}
voidtest(byteb)
{
System.out.print(b);
}
}

{
voidtest(inti)
{
i++;
System.out.println(i);
}
publicstaticvoidmain(String[]agrs)
{
Baseb=newTestOverriding();
b.test(0)
b.test((byte)0)
}
}
这时的输出结果是10，这是运行时动态绑定的结果。

总结：重载和重写(覆盖)

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，

将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了，而且如果子类的方法名和参数类型和个数都和父类相同，那么子类的返回值类型必须和父类的相同；如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。Overloaded的方法

是可以改变返回值的类型。也就是说，重载的返回值类型可以相同也可以不同。

附录：动态绑定即调用对象方法的机制

1)编译器检查对象声明的类型和方法名，从而获取所有候选方法。试着把上例Base类的test注释掉，这时再编译就无法通过。

2)重载决策：编译器检查方法调用的参数类型，从上述候选方法选出唯一的那一个（其间会有隐含类型转化）。如果编译器找到多于一个或者没找到，此时编译器就会报错。试着把上例Base类的test(byteb)注释掉，这时运行结果是11。

3)若方法类型为priavtestaticfinal，java采用静态编译，编译器会准确知道该调用哪个方法。

4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本。在例子中，b所指向的实际类型是TestOverriding，所以b.test(0)调用子类的test。但是，子类并没有重写test(byteb)，所以b.test((byte)0)调用的是父类
的test(byteb)。如果把父类的(byteb)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(inti)。

❷ Java里，重载的方法为何是静态编译，而没有重载的方法却是动态编译这么设计有什么原因吗

java允许在一个类中，多个方法拥有相同的名字，但在名字相同的同时，必须有不同的参数，这就是重载，编译器会根据实际情况挑选出正确的方法，如果编译器找不到匹配的参数或者找出多个可能的匹配就会产生编译时错误，这个过程被称为重载的解析
1 普通方法的重载
普通方法的重载是Java实现多态技术的重要手段，为编程带来了很多便利
当方法同名时，为了让编译器区别他们，至少需要下面之一不同
1 参数个数不同
2 对应位置上的参数类型不同
不允许参数完全相同而只是返回值不同的情况出现。无法进行编译，程序在eclips中显示错误
2 构造方法的重载
见文章构造方法的继承
重载的解析
当类的设计者提供了重载方法之后，类的使用者在使用这些方法时编译器需要确定调用哪一个方法，确定的唯一依据是参数列表，确定的过程被称为重载的解析。

以下举些例子说明：
show(int a ,int b,int c) //1
show(int a ,int b,double c) //2
show(int a ,double b,double c)//3
show(double a,double b,int c) //4
下面是调用
show(1,2,3);//1,2,3,4都是可行方法所有参数完全匹配1
show(1.0,2.0,3.0);//没有一个可行方法
show(1.0,2,3);//4是最佳可行方法
show(1,2.0,3);//3，4都是可行方法，没有最佳可行方法，报错

重载和覆盖都是多态的表现，他们在某些地方很相似，很容易引起初学者的疑惑，这里将它们之间的区别总结如下
1 重载和覆盖的方法名称都相同，但重载要求参数列表不同，而覆盖要求参数列表完全相同。
2 重载对于方法前面的修饰符没有限制，而覆盖则对这些修饰符的使用有限制
3 重载时编译器在编译期间就可以确定调用那一个方法，而覆盖则有可能在运行期间才能确定。

❸ 什么是方法重载Java编译器如何选择实际使用的方法

方法重载是相同方法名,但参数不同,返回类型可以相同也可以不同~参数的不同可以是类型不同,也可以是参数个数不同,比如在一个类里写:
class C{
public int a(int i){
方法体
}
public int a(String i){
方法体//方法体不必相同
}
public void a(int i,int j){
方法体//方法体不必相同
}
}

编译器选择实际使用方法是根据参数来选择到底使用哪个方法的
比如
C c=new C();
c.a(1);//调用第一个方法
c.a(2,3)//调用第三个方法

(注:不要把重载和重写弄错了,重写是继承里对方法进行重写,方法头要相同的,除了限制使用范围不能比父类方法更严,是对方法体的重写)

❹ 什么是重载方法，什么是覆盖方法，主要区别

一、重载方法：方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。

方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法。Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。

调用方法时通过传递给它们的不同个数和类型的参数，以及传入参数的顺序来决定具体使用哪个方法

二、覆盖方法：在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想做一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

两者的区别：

1、子类与父类的关系不同：覆盖方法中的子类与父类之间是垂直关系；在重载方法中因为两个方法在同一个类中，所以是不同方法之间的水平关系。

2、映射关系不同：覆盖只能由一个方法，或只能由一对方法产生关系；在重载方法时，多个方法之间发生变化。

3、对于参数列表的需求不同：覆盖要求参数列表相同；重载要求参数列表不同。

(4)方法重载时编译处理扩展阅读：

java的特点：

1、高性能

Java是一种先编译后解释的语言，所以它不如全编译性语言快。但是有些情况下性能是很要紧的，为了支持这些情况，Java设计者制作了“及时”编译程序，它能在运行时把Java字节码翻译成特定CPU的机器代码，也就是实现全编译了。

Java字节码格式设计时考虑到这些“及时”编译程序的需要，所以生成机器代码的过程相当简单，它能产生相当好的代码。

2、多线索性

Java是多线索语言，它提供支持多线索的执行，能处理不同任务，使具有线索的程序设计很容易。Java的lang包提供一个Thread类，它支持开始线索、运行线索、停止线索和检查线索状态的方法。

Java的线索支持也包括一组同步原语。这些原语是基于监督程序和条件变量风范，由C.A.R.Haore开发的广泛使用的同步化方案。用关键词synchronized，程序员可以说明某些方法在一个类中不能并发地运行。这些方法在监督程序控制之下，确保变量维持在一个一致的状态。

3、动态性

Java语言设计成适应于变化的环境，它是一个动态的语言。例如，Java中的类是根据需要载入的，甚至有些是通过网络获取的。

参考资料来源：

网络-方法重载

网络-方法覆盖

❺ c++怎样处理重载函数编译之后的函数符号问题

对每一个函数 都会生成一个符号
对于不同的重载都会生成不同的符号

比如
如果有一个函数int add(int, int)
那么用C编译后 它的符号就是add
而用C++编译后 它的符号可能是这样的
_Z3addii
如果再加上一个float add(float, float)的重载 那么它就会多一个这样的符号

_Z3addff
也就是对于每个重载 都会有一个根据参数类型生成的后缀 表示不同的含义

PS:在编译后 可以通过nm查看符号名(gcc/g++)

❻ 什么是方法重载方法重载的规则是什么

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法。

一、方法名一定要相同。

二、方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

1、如果参数个数不同，就不管它的参数类型了！

2、如果参数个数相同，那么参数的类型必须不同。

三、方法的返回类型、修饰符可以相同，也可不同。

(6)方法重载时编译处理扩展阅读：

Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。

调用方法时通过传递给它们的不同个数和类型的参数，以及传入参数的顺序来决定具体使用哪个方法。

❼ Java编译器如何生成重载和覆盖方法代码

举个简单的例子，展示了多态性（Polymorphism）：重载（Overloaded）和覆盖（Overridden）。

多态性意味着方法可以在不同的时刻表现出不同的形式。在编译期间，这被称为方法重载。重载允许相关的方法可以使用相同的方法名访问。有时候这被称为ad hoc polymorphism,与parametric polymorphism 不同。

输出：

intstringoverriden int

从编译器的角度讲，如何生成能够正确调用的函数的代码？

静态重载（Static overloading）不难实现。当处理一个重载方法的声明时，一个新的绑定会被映射到一个不同的实现。在处理类型检查的过程中，编译器会分析参数的实际类型，然后决定使用哪个方法。

动态重载（Dynamic overloading ）允许运行时根据实际参数的类型来选择函数的不同实现。这是动态调度（dynamic dispatch）的一种形式。

动态调度也被用来实现方法覆盖。被覆盖的方法的调用由运行期间实际对象的类型决定的。

❽ java中的方法重载

重载

含义： 只要方法名相同，参数表不同，就可以构成方法重载。

方法重载，在JAVA中，也叫： 编译时多态。（由编译的时候来确定调用哪个方法）

重载的原则： 向上就近匹配原则

注意： 如果只有print( double d ) 方法,而要调用 print(int) ，则编译器会自动地就近向上匹配 print(double) 方法。但是反过来就不行，

因为从大到小会丢失精度， 所以，没有就近向下匹配原则.

关键字： this

This: 指当前对象的。 。 。

有两种用法：

表示当前对象： this.age = age; this.name = name;

在调用本类的其它构造方法时。 This(参数表), 注：this的这种用法只能放在第一行。

方法调用：传值， 传引用

记住： 在JAVA中，简单类型变量一定是传值。 对象变量一这是传引用（也就是指向对象的首地址）

❾ 简述方法重载和方法重写的区别

、方法重写(0veriding)
在Java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。

子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。

重写体现了Java优越性，重写是建立在继承关系上，它使语言结构更加丰富。在Java中的继承中，子类既可以隐藏和访问父类的方法，也可以覆盖继承父类的方法。

在Java中覆盖继承父类的方法就是通过方法的重写来实现的。所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。

这样，就可以实现对父类方法的覆盖。如果子类将父类中的方法重写了，调用的时候肯定是调用被重写过的方法，那么如果现在一定要调用父类中的方法该怎么办呢?

此时，通过使用super关键就可以实现这个功能，super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。

如果要使用super关键字不一定非要在方法重写之后使用，也可以明确地表示某个方法是从父类中继承而来的。使用super只是更加明确的说，要从父类中查找，就不在子类查找了。

重写的好处在于子类可以根据需要，定义特定于自己的行为。
也就是说子类能够根据需要实现父类的方法。
在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}

//运行结果
动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管b属于Animal类型，但是它运行的是Dog类的move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。
因此在上面的例子中，之所以能编译成功，是因为Animal类中存在move方法，然而运行时，运行的是特定对象的方法。
思考以下例子：

class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
public void bark(){
System.out.println("狗可以吠叫");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
b.bark();
}
}
//以上实例编译运行结果如下：
TestDog.java:30: cannot find symbol
symbol : method bark()
location: class Animal

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

二、重写规则
在重写方法时，需要遵循以下的规则：
(一) 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。

(二) 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。

(三) Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。编写过Java程序的人就知道，父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。

(四) 由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。

(五) 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。

Super关键字的使用
当需要在子类中调用父类的被重写方法时，要使用super关键字。

三、方法重载(Overloading)
方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。

所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。

方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。

在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法。

重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型或个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。

虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。

当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。
6.可以抛出不同的异常。

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
只能重载构造函数

四、重载规则
被重载的方法必须改变参数列表；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异
五、访问修饰符
访问修饰符 本类 同包 子类 其他
private √
默认 √ √
protected √ √ √
public √ √ √
重写与重载之间的区别

方法重载：
1、同一个类中
2、方法名相同，参数列表不同（参数顺序、个数、类型）
3、方法返回值、访问修饰符任意
4、与方法的参数名无关

方法重写：
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
3、访问修饰符，访问范围需要大于等于父类的访问范围
4、与方法的参数名无关

区别点 重载方法 重写方法
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
异常 可以修改 可以减少或删除，一定不能抛出新的或者更广的异常
访问 可以修改 一定不能做更严格的限制（可以降低限制）

❿ C# 方法重载

方法1、3不属于重载，是无法编译通过的，首先你要理解什么是一个方法的签名，签名是指方法的名称和它参数的数量、类型、以及顺序。注意这里面不包括返回值的类型，也就是说，返回值的类型不是方法签名的一部分。
再来看重载，重载是指方法名称相同，但签名不同的一组方法，通俗来说，就是参数不能完全一样（数量、类型、顺序），与返回值无关。
你的方法1和方法3仅仅是返回值不同，而方法名相同，参数的数量、类型、以及顺序也完全相同，因此是具有同样签名的两个方法，编译器无法区分这两个方法，所以在编译时会报错