如果我们定义一个与类名相同的函数就是构造函数，我们可以在一个类中定义多个构造函数，但是这些构造函数的列表参数必须不同（个数或者数据类型）。如果我们没有定义一个构造函数，系统就会给这个类定义一个默认的构造函数，这个构造函数没有参数。如果我们定义了构造函数那么系统定义的构造函数就会被覆盖。下面用程序来说明。
程序1：
class YuanGong{
private int id;
private String name;
private float salary;
private String depart;
public void say(){
System.out.println("员工号:"+'\t'+id);
System.out.println(" 姓名:"+'\t'+name);
System.out.println(" 薪水:"+'\t'+salary);
System.out.println(" 部门:"+'\t'+depart);
}
public void setId(int id){
this.id=id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSalary(float salary){
this.salary=salary;
}
public float getSalary(){
return salary;
}
public void setDepart(String depart){
this.depart=depart;
}
public String getDepart(){
return depart;
}
}
public class Test1{
public static void main(String args[]){
YuanGong p=new YuanGong();
p.say();
p.setId(50);
p.setName("哈哈");
p.setSalary(2000);
p.setDepart("商务");
p.say();
}
}
上面程序的输出结果如下图所示：
我们看到在程序并没有定义构造函数YuanGong()，这是系统定义的,而且还没有参数。
程序2：
class YuanGong{
private int id;
private String name;
private float salary;
private String depart;
YuanGong(int id){
this.setId(id);
this.setName("未确定");
this.setSalary(1000);
this.setDepart("后勤");
}
YuanGong(int id,String name){
this.setId(id);
this.setName(name);
this.setSalary(3000);
this.setDepart("技术");
}
YuanGong(int id,String name,float salary,String depart){
this.setId(id);
this.setName(name);
this.setSalary(salary);
this.setDepart(depart);
}
YuanGong(){
}
public void say(){
System.out.println("员工号:"+'\t'+id);
System.out.println(" 姓名:"+'\t'+name);
System.out.println(" 薪水:"+'\t'+salary);
System.out.println(" 部门:"+'\t'+depart);
}
public void setId(int id){
this.id=id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSalary(float salary){
this.salary=salary;
}
public float getSalary(){
return salary;
}
public void setDepart(String depart){
this.depart=depart;
}
public String getDepart(){
return depart;
}
}
public class Test2{
public static void main(String args[]){
YuanGong p1=null;
YuanGong p2=null;
p1=new YuanGong(10);
p2=new YuanGong(20,"张三");
p1.say();
p2.say();
p1=new YuanGong(30,"李四",5000,"财政");
p2=new YuanGong();
p1.say();
p2.say();
}
}
此程序的输出结果如下图所示：
在此程序中我们定义了四个构造函数，分别是单参、双参、四参和没有参数。我们可以看到最后没有参数的构造函数的结果和程序1初始化的结果一样。
看程序3：
class YuanGong{
private int id;
private String name;
private float salary;
private String depart;
YuanGong(int id){
this.setId(id);
this.setName("未确定");
this.setSalary(1000);
this.setDepart("后勤");
}
YuanGong(int id,String name){
this.setId(id);
this.setName(name);
this.setSalary(3000);
this.setDepart("技术");
}
YuanGong(int id,String name,float salary,String depart){
this.setId(id);
this.setName(name);
this.setSalary(salary);
this.setDepart(depart);
}
public void say(){
System.out.println("员工号:"+'\t'+id);
System.out.println(" 姓名:"+'\t'+name);
System.out.println(" 薪水:"+'\t'+salary);
System.out.println(" 部门:"+'\t'+depart);
}
public void setId(int id){
this.id=id;
}
public int getId(){
return id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSalary(float salary){
this.salary=salary;
}
public float getSalary(){
return salary;
}
public void setDepart(String depart){
this.depart=depart;
}
public String getDepart(){
return depart;
}
}
public class Test3{
public static void main(String args[]){
YuanGong p1=null;
YuanGong p2=null;
p1=new YuanGong(10);
p2=new YuanGong(20,"张三");
p1.say();
p2.say();
p1=new YuanGong(30,"李四",5000,"财政");
p2=new YuanGong();
p1.say();
p2.say();
}
}
这个程序编译的时候就会出现如下图所示的错误：
程序3与程序2的区别就是少了一个无参的构造函数，这样做就验证了“如果类中定义了新的构造函数就会覆盖系统定义的构造函数”。程序2同样也覆盖了系统定义的构造函数只不过我们又新建了一个无参的构造函数，这就造成了程序2中无参函数的输出结果与程序1初始化的输出结果相同。