java中什么是方法重载

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

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

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

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

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

两者的区别：

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

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

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

(1)java中什么是方法重载扩展阅读：

java的特点：

1、高性能

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

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

2、多线索性

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

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

3、动态性

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

参考资料来源：

网络-方法重载

网络-方法覆盖

❷ java中为什么要用方法重载

（1）重载的意义在于扩展父类的功能，如果有两个类A和B，继承C，那么在C的方法只需要定义A和B相同的功能，而在各个子类中扩展子类具体的实现。

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

（3）Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

❸ java中方法覆盖和方法重载是什么意思

Java中覆盖和重载的区别如下：
override 可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对来说可能比较熟悉，可以翻译为重载，它是指可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，将注释去掉，看看在编译时会产生什么效果。
// 对overload测试的文件：OverloadTest.java
public class OverloadTest {
// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。
public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}

public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}

public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}

public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}

// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。
// 需要注意：这里的参数肯定不是相同的类型，否则的顺序的先后就毫无意义。
public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");
}

public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");
}

// 下面的两个方法用来验证方法抛出的异常对于重载的影响.
// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。
public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}

public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");
}

public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}

// 不能通过抛出的异常类型来重载fun方法。
//public void fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");
//}

// 不能通过返回值重载fun方法。
//public boolean fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");
// return true;
//}

private void fun3() { }

// 不能通过不同的访问权限进行重载
public void fun3() { }

public static void main(String[] args) {
// 这里只是定义了OverloadTest的实例，所以test不会调用
// OverloadTest1中的方法。
OverloadTest test = new OverloadTest1();
// 这里定义了OverloadTest1的实例，因为OverloadTest1是OverloadTest
// 的子类，所以test1会调用OverloadTest中的方法。
OverloadTest1 test1 = new OverloadTest1();

try {
int i = 1, j = 2, m = 3;

// 这里不会调用OverloadTest1的fun方法
// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
// 这个调用不会执行，因为fun3()在OverloadTest中访问权限是priavte
//test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}

class OverloadTest1 extends OverloadTest{
// 在子类中重载fun
public void fun(int i, int m, int n) {
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");
}

// 这个不是对父类中方法的重载，只是一个新的方法。
public void fun3(int i) {
System.out.println("fun2 in OverloadTest1");
}
}

// 对override测试的文件：OverrideTest.java
public class OverrideTest {
public void fun() throws TestException {
System.out.println("method fun in OverrideTest");
}

private void fun1() {
System.out.println("method fun1 in OverrideTest");
}

public static void main(String[] args) {
OverrideTest test = new OverrideTest1();
try {
test.fun();
test.fun1();
} catch(Exception e) { }
}
}

class OverrideTest1 extends OverrideTest{
// 以下正常Override
public void fun() throws TestException2 {
System.out.println("fun in OverrideTest1");
}

// 不能Override父类中的方法，因为它定义了不同的异常类型和
// 返回值。
//public int fun() throws TestException1 {
// System.out.println("method fun in Test");
// return 1;
//}

// 不能Override父类中的方法，因为它抛出了比父类中非法范围
// 更大的异常。
//public void fun() throws Exception {
// System.out.println("fun in OverrideTest1");
//}

// 这个方法并没有Override父类中的fun1方法，因为这个方法在
// 父类是private类型，所以这里只是相当于定义了一个新方法。
public void fun1() {
System.out.println("method fun1 in Test");
}
}

class TestException extends Exception{
public TestException(String msg) {
super(msg);
}
}

class TestException1 extends TestException {
public TestException1(String msg) {
super(msg);
}
}

class TestException2 extends TestException {
public TestException2(String msg) {
super(msg);
}
}

❹ 什么是方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

❺ JAVA中方法重载和方法重写的区别和应用

你好，很高兴回答你的问题。
java中方法重载是指在同一个类内，方法名相同，参数列表不同。
而重写是指子类继承父类的方法后重新编写方法内的逻辑。
多态其实就是通过重写和重载实现的。
各种设计模式也都离不开重新和重载。
如果有帮助到你，请点击采纳。

❻ Java请说明什么叫方法重载，并使用计算2个数的和来举例说明

方法的重载：在一个类中，方法名称一样，参数个数不一样或者类型不一样。
举例：
public class TestOverLoad {
void sum(int a , int b) {
int c=a+b;
System.out.println( "二数之和是"+ c);
}

void sum(double a, double b) {
double c=a+b;
System.out.println( "二数之和是"+ c);
}

public static void main(String[] args) {
TestOverLoad t = new TestOverLoad();
t.sum(3, 4);
double a = 3.0;
double b = 4.0;
t.sum(a, b);
}
}

输出：二数之和是7
二数之和是7.0

❼ java方法重载是指一个类中的，方法重写是不同类中的，对吗

什么是方法的重载:
java中，可以在同一个类中用相同的名称定义两个或者多个方法，但是参数项不同（分为参数类型不同和参数数量不同）。当两个方法名称相同而参数项不同时，那么就认为此方法被重载，而此过程就被称为"方法重载"。调用重载方法时，java使用参数的类型和数量决定实际调用重载方法的哪个版本。重载方法可以具有不同的返回类型，但返回类型本身不足以区分方法的两个版本。因此重载方法的参数类型或者数量必须不同.
方法重载支持多态性,因为它是java实现"一个接口，多重方法"模式的一种方式。此外，构造方法也可以被重载。
什么是方法重写：
在类体系结构中，当子类中的方法与其父类中的方法具有相同的方法时，则认为子类中的方法重写了父类中的方法。从子类中调用重写方法时，将总是调用出现在子类中的方法，而父类中的方法将会被隐藏。如果程序员需要访问重写方法的父类中的该方法，可以使用关键字super来完成。
方法重写以后父类的方法并没有小时，只是隐藏了而已，仍然是可以调用的。

❽ 在Java中，方法重写和方法重载有什么区别

重载(Overloading)

1. 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。

2. Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

3. 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

重写（Overriding）

1. 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

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

3. 子类函数的访问修饰权限不能少于父类的；

备注：因为最佳答案出现一个小问题，所以我参考了一下博客结合自己所学进行了回答纠错。如有错误请大家积极评论纠错，帮助更多的人。

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

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

一、方法名一定要相同。

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

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

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

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

(9)java中什么是方法重载扩展阅读：

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

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

❿ java中方法的重载是什么意思

覆盖是override方法重写 重载是overload
按照教科书上的定义，重载就是具有相同函数名，返回类型可以不同，参数个数、顺序、类型不同的函数。我的理解是重载是发生在两个或者是更多的函数具有相同的名字的情况下。
重写就是覆盖父类的方法，和父类有相同返回类型，参数，甚至是抛出的异常，重写方法不能为private，运用中最典型的就是对接口方法的覆盖。方法的重写Overriding和重载Overloading是Java多态性的不同表现.
重写Overriding是父类和子类之间多态性的一种表现;如果在子类中定义某方法和其父类有相同的名称和参数,我们说该方法被重写 (Overriding).子类的对象使用这个方法时,将调用子类中的定义,对他而言,父类中的定义如同被"屏蔽"了.
重载Overloading是个类中多态性的一种表现；如果在一个类中定义了多个同名的方法,他们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading).重载的方法是能改动返回值的类型.

现实例子：你对比上面看，比如一老爹是木工。儿子继承老爹也是木工。
老爹有个做柜子的独特技术（方法），只需要用到工具锤子和木头（参数），
儿子根据老爹这个做柜子的技术延伸出很多种技术，他懒得再起名就也对外宣称叫做柜子独特技术。
1个继承自老爹，相同的方法名，相同的工具，但有自己的想法，工序有改动。儿子做木工活用到这个技术方法的话就叫重写。
另外的自创，但也叫做柜子独特技术，但用工具不同有：
木头。（儿子牛，不用锤子照样做柜子。。。）
锯子，木头。（也是木头柜子）
锤子，铁皮。（铁皮柜子）
以上3中为重载。
明白？不明白给我发消息。呵呵~