- 相关推荐
java构造方法重载
JAVA 方法重载和构造函数重载【一】
在Java 中,同一个类中的2个或2个以上的方法可以有同一个名字,只要它们的参数声明不同即可。在这种情况下,该方法就被称为重载(overloaded ),这个过程称为方法重载(method overloading )。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言,这个概念最初可能有点奇怪。但是你将看到,方法重载是Java 最激动人心和最有用的特性之一。
当一个重载方法被调用时,Java 用参数的类型和(或)数量来表明实际调用的重载方法的版本。因此,每个重载方法的参数的类型和(或)数量必须是不同的。虽然每个重载方法可以有不同的返回类型,但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时,参数与调用参数匹配的方法被执行。
下面是一个说明方法重载的简单例子:
// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters. void test(int a,int b) { System.out.println("a and b: " + a + " " + b);}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a; }}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()ob.test();ob.test(10);ob.test(10,20);result = ob.test(123.25);System.out.println("Result of ob.test(123.25): " + result);
}
}
该程序产生如下输出:
No parameters
a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625
从上述程序可见,test()被重载了四次。第一个版本没有参数,第二个版本有一个整型参数,第三个版本有两个整型参数,第四个版本有一个double 型参数。由于重载不受方法的返回类型的影响,test()第四个版本也返回了一个和重载没有因果关系的值。
当一个重载的方法被调用时,Java 在调用方法的参数和方法的自变量之间寻找匹配。但是,这种匹配并不总是精确的。在一些情况下,Java 的自动类型转换也适用于重载方法的自变量。例如,看下面的程序:
// Automatic type conversions apply to overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for two integer parameters. void test(int a,int b) { System.out.println("a and b: " + a + " " + b);}
// overload test for a double parameter
void test(double a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
int i = 88;
ob.test();ob.test(10,20);
ob.test(i); // this will invoke test(double)
ob.test(123.2); // this will invoke test(double)
}
}
该程序产生如下输出:
No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
在本例中,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这个名字来创建一种方法,该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种操作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中,你应该只重载相互之间关系紧密的操作。
7.1.1 构造函数重载
除了重载正常的方法外,构造函数也能够重载。实际上,对于大多数你创建的现实的
类,重载构造函数是很常见的,并不是什么例外。为了理解为什么会这样,让我们回想上一章中举过的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 = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycube.volume();
System.out.println("Volume of mycube is " + vol);
}
}
该程序产生的输出如下所示:
Volume of mybox1 is 3000.0
Volume of mybox2 is -1.0
Volume of mycube is 343.0
在本例中,当new执行时,根据指定的自变量调用适当的构造函数。
Java方法的重载以及构造函数的理解【二】
方法的重载有3个条件:
1、函数位于同一个类下面;
2、方法名必须一样;
3、方法的参数列表不一样。
比如有以下的例子:
[java] view plain copyclass Student {
void action(){
System.out.println("该函数没有参数!");
}
void action(int i)
{
System.out.println("有一个整形的参数!");
}
void action(double j)
{
System.out.println("有一个浮点型的参数!");
}
}
该类中定义了3个方法,但是3个方法的参数列表不一样;
下面在主函数中调用这个类:
[java] view plain copypublic class Test {
/**
* @param args
* @author weasleyqi
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Student st = new Student();
st.action();
st.action(1);
st.action(1.0);
}
}
看看运行结果:
从控制台的输出可以看出,我在主函数中实例化一个student对象,分别调用了这个对象的3中方法,由于3个方法的参数不一样,所以可以看到输出的结果也不一样;
构造函数的使用:
定义一个Sutdent类,类里面定义两个属性:
[java] view plain copyclass Student {
String name;
int age;
}
此时的Student类中没有构造函数,系统会自动添加一个无参的构造函数,这个构造函数的名称必须和类的名称完全一样,大小写也必须相同,系统编译完了之后是以下的情况:
[java] view plain copyclass Student {
Student()
{
}
String name;
int age;
}
主函数中实例化两个对象:
[java] view plain copypublic class Test {
/**
* @param args
* @author weasleyqi
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Student st = new Student();
st.name = "张三";
st.age = 10;
Student st2 = new Student();
st2.name = "李四";
st2.age = 20;
}
}
从主函数可以看出,此时的Student对象的属性比较少,创建的实例也比较少,如果属性多再创建多个实例的话,这个代码的量就很大,这时候,我们可以添加一个带参数的构造函数,如下:
[java] view plain copyclass Student {
Student(String n, int a)
{
name = n;
age = a;
}
String name;
int age;
}
主函数的代码如下:
[java] view plain copypublic class Test {
/**
* @param args
* @author weasleyqi
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Student st = new Student("张三",10);
Student st2 = new Student("李四",20);
System.out.println("st的name:" + st.name +", st的age:" + st.age);
System.out.println("st2的name:" + st2.name +", st的age:" + st2.age);
}
}
此时系统运行的结果如图:
从运行结果可以看出,我们在实例化Student对象的时候,调用了带参数的构造函数,节省了很多的代码,要注意:如果我们在Student类中定义了一个带参数的构造函数,但是没有写无参的构造函数,这个时候我们在主函数中就不能定义 Student st = new Student();如果在Student类中加上无参的构造函数就可以实现这样的实例化。
【java构造方法重载】相关文章:
方法重载的条件09-23
什么是方法重载11-15
方法重载与覆盖的区别11-04
方法重载和方法重写的概念和区别09-06
方法重载和方法重写的区别是什么11-16
java技术的学习方法10-07
Java学习方法有哪些10-06
安装java jdk环境变量的方法10-05
JAVA程序员的学习方法指导10-07
汽车构造实习报告11-25