java中构造方法和方法有啥区别
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java中构造方法和方法有啥区别相关的知识,希望对你有一定的参考价值。
我不知道怎么和你解释,所以在网上找了点资料,希望可以帮助你。构造方法要与类名相同,无返回类型,在类初始化的时候调用。
方法最好与类名不同,对象调用,静态方法可用类名.方法().
功能和作用的不同
构造器是为了创建一个类的实例。这个过程也可以在创建一个对象的时候用到:Platypus p1 = new Platypus();
相反,方法的作用是为了执行java代码。
修饰符,返回值和命名的不同
构造器和方法在下面三个方便的区别:修饰符,返回值,命名。和方法一样,构造器可以有任何访问的修饰: public, protected, private或者没有修饰(通常被package 和 friendly调用). 不同于方法的是,构造器不能有以下非访问性质的修饰: abstract, final, native, static, 或者 synchronized。
返回类型也是非常重要的。方法能返回任何类型的值或者无返回值(void),构造器没有返回值,也不需要void。
最后,谈谈两者的命名。构造器使用和类相同的名字,而方法则不同。按照习惯,方法通常用小写字母开始,而构造器通常用大写字母开始。构造器通常是一个名词,因为它和类名相同;而方法通常更接近动词,因为它说明一个操作。
"this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字,因为静态方法不属于类的实例,所以this也就没有什么东西去指向。构造器的this指向同一个类中,不同参数列表的另外一个构造器,我们看看下面的代码:
public class Platypus
String name;
Platypus(String input)
name = input;
Platypus()
this("John/Mary Doe");
public static void main(String args[])
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
在上面的代码中,有2个不同参数列表的构造器。第一个构造器,给类的成员name赋值,第二个构造器,调用第一个构造器,给成员变量name一个初始值 "John/Mary Doe".
在构造器中,如果要使用关键字this,那么,必须放在第一行,如果不这样,将导致一个编译错误。
"super"的用法
构造器和方法,都用关键字super指向超类,但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子:
class Mammal
void getBirthInfo()
System.out.println("born alive.");
class Platypus extends Mammal
void getBirthInfo()
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
在上面的例子中,使用super.getBirthInfo()去调用超类Mammal中被重载的方法。
构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行,否则编译将出错。看下面的例子:
public class SuperClassDemo
SuperClassDemo()
class Child extends SuperClassDemo
Child()
super();
在上面这个没有什么实际意义的例子中,构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化,并加到 Child类中。
编译器自动加入代码
编译器自动加入代码到构造器,对于这个,java程序员新手可能比较混淆。当我们写一个没有构造器的类,编译的时候,编译器会自动加上一个不带参数的构造器,例如:public class Example
编译后将如下代码:
public class Example
Example()
在构造器的第一行,没有使用super,那么编译器也会自动加上,例如:
public class TestConstructors
TestConstructors()
编译器会加上代码,如下:
public class TestConstructors
TestConstructors()
super;
仔细想一下,就知道下面的代码
public class Example
经过会被编译器加代码形如:
public class Example
Example()
super;
继承
构造器是不能被继承的。子类可以继承超类的任何方法。看看下面的代码:
public class Example
public void sayHi
system.out.println("Hi");
Example()
public class SubClass extends Example
类 SubClass 自动继承了父类中的sayHi方法,但是,父类中的构造器 Example()却不能被继承。
总结
主题
构造器
方法
功能
建立一个类的实例
java功能语句
修饰
不能用bstract, final, native, static,
or synchronized
能
返回类型
没有返回值,没有void
有返回值,或者void
命名
和类名相同;通常为名词,大写开头
通常代表一个动词的意思,小写开头
this
指向同一个类中另外一个构造器,在第一行
指向当前类的一个实例,不能用于静态方法
super
调用父类的构造器,在第一行
调用父类中一个重载的方法
继承
构造器不能被继承
方法可以被继承
编译器自动加入一个缺省的构造器
自动加入(如果没有)
不支持
编译器自动加入一个缺省的调用到超类的构造器
自动加入(如果没有)
不支持
构造方法,可以理解为在对象使用之前必须调用的方法,而该类当中的其他方法则没这个必要
所以在创建对象的时候,不但要分配内存,还要调用构造方法
细微的差别
构造方法必须没有返回值,其他方法必须有返回值
构造方法有默认构造方法,而其他方法没有
java 类当中方法有返回值,并且习惯方法名开头小写!
构造方法没有返回值,而其写法特殊是
public/private + 类名 +()+。是固定的
例如
class A
private int id;
private String name;
public A()
public A(int id,String name)
this.id = id;
this.name = name;
第一个 public A()是缺省的构造方法,第二是重载Full的构造方法。 参考技术A 区别如下:
1.返回值的区别
构造方法:没有返回值。
方法:有返回值。
2.命名方式的区别
构造方法:构造方法名称要与类名相同。
方法:只要符合java命名规范即可。
java中重载有啥用
说得太抽象,稍微具体点,我刚学java7天
在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执行时,根据指定的自变量调用适当的构造函数。追问
英文注释看不懂
追答下个金山词霸 不就oK咯?
参考技术A 首先给LZ一个例子先吧class ChongZai
public void a(int a);
public void a(Strting a);
public void a(int a,int b);
如上就是一个重载了 而重载要满足一下条件:
1.必须是同一个类
2.方法名(也可以叫函数)一样
3.参数类型不一样或参数数量不一样
同时我也给LZ讲一下重载的作用吧 还是以上面的例子说吧
ChongZai cz =new ChongZai();
cz.a(1); //调用a(int a);
cz.a("传的参数"); //调用a(String a)
cz.a(1,2); //调用a(int a,int b)
上面已经说了调用哪个方法了 而这个调用方法是程序按照你输入的参数来判断调用哪个方法的
重载的功能也讲下吧 就比如说你做游戏 那么可能游戏可以有多个人完 而完的人数又不确定是几个人 那么就可以用到重载了 参考技术B 重载跟重写 overload和override,是java多态型的两种不同表现,
重载是静态多态性,即同名不同参 好比一个人可以用不同种餐具。
重写就是覆盖,动态多态性,同名又同参 好比一个人我不用餐具吃饭了一样我让人喂!本回答被提问者采纳 参考技术C 好处应该就是:方便,容易理解,好调用。 参考技术D 如果几个方法的方法名一样,参数个数或类型不同该方法就是重载方法。方法重载(包括构造方法)好处在于:如果有2个方法:方法一:public void toEat(int a,int b)System.out.println(a+b);方法二:public void toEat(double a,double b)System.out.println(a*2+b);Java虚拟机在遇到调用该方法时会自动匹配最合适者,如在main函数中我写了一个语句:toEat(1.0,2.0),那么这里会调用方法二而不是方法一,这样设计程序的好处在于相同的方法可以接受不同的参数,实现不同的功能,就如同上面赋给方法toEat2个int型的1、2和2个double型的1.0、2.0分别得到3和4.0.
以上是关于java中构造方法和方法有啥区别的主要内容,如果未能解决你的问题,请参考以下文章