java中重载有什么用

在Java 中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded ），这个过程称为方法重载（method overloading ）。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java 最激动人心和最有用的特性之一。

当一个重载方法被调用时，Java 用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时，参数与调用参数匹配的方法被执行。

下面是一个说明方法重载的简单例子：

// Demonstrate method overloading

class OverloadDemo {

void test() {

Systemoutprintln("No parameters");

}

// Overload test for one integer parameter

void test(int a) {

Systemoutprintln("a: " + a);

}

// Overload test for two integer parameters void test(int a，int b) { Systemoutprintln("a and b: " + a + " " + b);}

// overload test for a double parameter

double test(double a) {

Systemoutprintln("double a: " + a);

return aa; }}

class Overload {

public static void main(String args[]) {

OverloadDemo ob = new OverloadDemo();

double result;

// call all versions of test()obtest();obtest(10);obtest(10，20);result = obtest(12325);Systemoutprintln("Result of obtest(12325): " + result);

}

}

该程序产生如下输出：

No parameters

a: 10

a and b: 10 20

double a: 12325

Result of obtest(12325): 151905625

从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double 型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。

当一个重载的方法被调用时，Java 在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些情况下，Java 的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：

// Automatic type conversions apply to overloading

class OverloadDemo {

void test() {

Systemoutprintln("No parameters");

}

// Overload test for two integer parameters void test(int a，int b) { Systemoutprintln("a and b: " + a + " " + b);}

// overload test for a double parameter

void test(double a) {

Systemoutprintln("Inside test(double) a: " + a);

}

}

class Overload {

public static void main(String args[]) {

OverloadDemo ob = new OverloadDemo();

int i = 88;

obtest();obtest(10，20);

obtest(i); // this will invoke test(double)

obtest(1232); // this will invoke test(double)

}

}

该程序产生如下输出：

No parameters

a and b: 10 20

Inside test(double) a: 88

Inside test(double) a: 1232

在本例中，OverloadDemo 的这个版本没有定义test(int) 。因此当在Overload 内带整数参数调用test()时，找不到和它匹配的方法。但是，Java 可以自动地将整数转换为double 型，这种转换就可以解决这个问题。因此，在test(int) 找不到以后，Java 将i扩大到double 型，然后调用test(double) 。当然，如果定义了test(int) ，当然先调用test(int) 而不会调用test(double) 。只有在找不到精确匹配时，Java 的自动转换才会起作用。

方法重载支持多态性，因为它是Java 实现“一个接口，多个方法”范型的一种方式。要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中，函数abs( )返回整数的绝对值，labs( ) 返回long 型整数的绝对值( )，而fabs( )返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java 中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java 的标准的类库包含一个绝对值方法，叫做abs ( )。这个方法被Java 的math 类重载，用于处理数字类型。Java 根据参数类型决定调用的abs()的版本。

重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action ）。为特定环境选择正确的指定（specific ）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用 *** 作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。

当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种 *** 作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的 *** 作。

711 构造函数重载

除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的

类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们回想上一章中举过的Box类例子。下面是最新版本的Box类的例子：

class Box { double width; double height; double depth;

// This is the constructor for Box

Box(double w，double h，double d) {width = w; height = h;depth = d;

}

// compute and return volume double volume() { return width height depth;}}

在本例中，Box() 构造函数需要三个自变量，这意味着定义的所有Box对象必须给Box() 构造函数传递三个参数。例如，下面的语句在当前情况下是无效的：

Box ob = new Box();

因为Box( )要求有三个参数，因此如果不带参数的调用它则是一个错误。这会引起一些重要的问题。如果你只想要一个盒子而不在乎 (或知道)它的原始的尺寸该怎么办？或，如果你想用仅仅一个值来初始化一个立方体，而该值可以被用作它的所有的三个尺寸又该怎么办？如果Box 类是像现在这样写的，与此类似的其他问题你都没有办法解决，因为你只能带三个参数而没有别的选择权。

幸好，解决这些问题的方案是相当容易的：重载Box 构造函数，使它能处理刚才描述的情况。下面程序是Box 的一个改进版本，它就是运用对Box构造函数的重载来解决这些问题的：

/ Here，Box defines three constructors to initialize

the dimensions of a box various ways

/

class Box {

double width; double height; double depth; // constructor used when all dimensions specified Box(double w，double h，double d) {

width = w;

height = h;

depth = d;

}

// constructor used when no dimensions specified Box() { width = -1; // use -1 to indicate

height = -1; // an uninitialized

depth = -1; // box

}

// constructor used when cube is created Box(double len) { width = height = depth = len;}

// compute and return volume double volume() { return width height depth;}}

class OverloadCons {

public static void main(String args[]) { // create boxes using the various constructorsBox mybox1 = new Box(10，20，15);Box mybox2 = new Box();Box mycube = new Box(7);

double vol;

// get volume of first box

vol = mybox1volume();

Systemoutprintln("Volume of mybox1 is " + vol);

// get volume of second box

vol = mybox2volume();

Systemoutprintln("Volume of mybox2 is " + vol);

// get volume of cube

vol = mycubevolume();

Systemoutprintln("Volume of mycube is " + vol);

}

}

该程序产生的输出如下所示：

Volume of mybox1 is 30000

Volume of mybox2 is -10

Volume of mycube is 3430

在本例中，当new执行时，根据指定的自变量调用适当的构造函数。

Java中覆盖和重载的区别如下：

override 可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对来说可能比较熟悉，可以翻译为重载，它是指可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，将注释去掉，看看在编译时会产生什么效果。

// 对overload测试的文件：OverloadTestjava

public class OverloadTest {

// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。

public void fun(){

Systemoutprintln("method fun in OverloadTest, no parameter");

}

public void fun(float f) {

Systemoutprintln("method fun in OverloadTest, parameter type: float");

}

public void fun(int i){

Systemoutprintln("method fun in OverloadTest, parameter type: int");

}

public void fun(int i1, int i2) {

Systemoutprintln("method fun in OverloadTest, parameter type: int, int");

}

// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。

// 需要注意：这里的参数肯定不是相同的类型，否则的顺序的先后就毫无意义。

public void fun1(int i, float f) {

Systemoutprintln("method fun1 in OverloadTest, sequence of parameters is: int, float");

}

public void fun1(float f, int i) {

Systemoutprintln("method fun1 in OverloadTest, sequence of parameters is: float, int");

}

// 下面的两个方法用来验证方法抛出的异常对于重载的影响

// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。

public void fun2() throws TestException {

Systemoutprintln("fun2 in OverloadTest, exception: TestException");

}

public void fun2(int i) throws TestException, TestException1 {

Systemoutprintln("fun2 in OverloadTest, exception: TestException, TestException1");

}

public void fun2(float f) throws Exception {

Systemoutprintln("fun2 in OverloadTest, exception: Exception");

}

// 不能通过抛出的异常类型来重载fun方法。

//public void fun(int i) throws Exception {

// Systemoutprintln("method fun in OverloadTest, parameter type: int, exception: Exception");

//}

// 不能通过返回值重载fun方法。

//public boolean fun(int i) throws Exception {

// Systemoutprintln("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方法

// testfun(i, m, j);

test1fun(i, j, m);

test1fun();

// 这个调用不会执行，因为fun3()在OverloadTest中访问权限是priavte

//test1fun3();

test1fun3(i);

} catch(Exception e) { }

}

}

class OverloadTest1 extends OverloadTest{

// 在子类中重载fun

public void fun(int i, int m, int n) {

Systemoutprintln("Overload fun1 in OverloadTest1, parameter type: int, int, int");

}

// 这个不是对父类中方法的重载，只是一个新的方法。

public void fun3(int i) {

Systemoutprintln("fun2 in OverloadTest1");

}

}

// 对override测试的文件：OverrideTestjava

public class OverrideTest {

public void fun() throws TestException {

Systemoutprintln("method fun in OverrideTest");

}

private void fun1() {

Systemoutprintln("method fun1 in OverrideTest");

}

public static void main(String[] args) {

OverrideTest test = new OverrideTest1();

try {

testfun();

testfun1();

} catch(Exception e) { }

}

}

class OverrideTest1 extends OverrideTest{

// 以下正常Override

public void fun() throws TestException2 {

Systemoutprintln("fun in OverrideTest1");

}

// 不能Override父类中的方法，因为它定义了不同的异常类型和

// 返回值。

//public int fun() throws TestException1 {

// Systemoutprintln("method fun in Test");

// return 1;

//}

// 不能Override父类中的方法，因为它抛出了比父类中非法范围

// 更大的异常。

//public void fun() throws Exception {

// Systemoutprintln("fun in OverrideTest1");

//}

// 这个方法并没有Override父类中的fun1方法，因为这个方法在

// 父类是private类型，所以这里只是相当于定义了一个新方法。

public void fun1() {

Systemoutprintln("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);

}

}

返回 return   

不是 retum

把 retum 都换成 return 就好了

方法重载就是为这种方法提供多种可能性。API中构造方法的重载就是这种作用！你不能只提供一种方式，这样是不行的。比如DefaultTableModel类中的构造方法，有些人喜欢用数组，有些人喜欢用Vector对象，那你能说什么！只是提供多种方式解决问题而已！

三、

java中的重载(overload)

1、相同方法名，不同参数表。

2、方法重载时，对于参数的匹配有个向上就近原则。（这样可以节省栈空间资源）；

3、为什么面向对象中要有方法重载？

方法的重载使同一类方法由于参数造成的差异对于对象的使用者是透明的。对象的使用者只负责把参数交给对象，而具体怎么实现由对象内部决定。

4、java中的运算符重载

java中唯一重载的运算符是string类型的“+”号，任何类型+string类型结果都为stirng类型。

5、注意点：重载不仅出现在同一个类中，也可以出现在父子类中。

java中的重写（override）

1、

参数表、方法名必须完全相同，访问修饰符要求子类宽于父类。返回值类型在jdk50以前要求完全相同，

50以后可以父类返回一个对象a,子类返回一个该对象a的子类也是覆盖。子类方法覆盖父类方法时要求子类方法的访问修饰符宽于或等于父类的访问修饰符。

2、

为什么面向对象中要有方法覆盖？

覆盖允许子类用自己特色的方法去替换调父类已有的方法。

3、

父类中的私有方法与子类中任何方法不够成覆盖关系，

也就是说只有父类被子类继承过来的方法，才有可能与子类自己的方法构成覆盖关系。

4、少覆盖原则：如果子类覆盖了父类过多的方法，那么我们要重

新思考一下这两个类之间到底是不是继承关系。

注：子类的属性和父类的属性同名时叫遮盖（区覆盖）

属性的遮盖是没有多态的。

这个基本是没有一点关联。。。只是名字容易混淆而已

重写就是对父类的方法重写，改变方法体中的语句。。。。

重载就是同一个函数名，参数个数、类型、排列顺序不同，jvm根据参数来决定调用哪一个方法