其实在写好一个自定义的类时，这个类本身就有一个默认的空参数构造方法，只是不用自己去写出来，但是在有些时候，需要对它的成员变量在创建对象的时候就进行初始化值，这时就需要重写构造方法，也就是构造器。
构造方法的作用就是对成员变量进行默认初始化值。
修饰符 方法名(参数列表){
}
修饰符：也就是它的权限问题
方法名：定义必须和类名完全一致
参数列表：如果需要对成员变量在创建对象的时候就进行赋值，就写参数，如果不需要，不需要写参数列表。
构造方法在创建对象的时候就运行了，具体代码演示如下：
l Person类
package cn.itcast.ConstructorMethod;
/*
* 构造方法的创建
*/
public class Person {
//定义姓名，年龄，将其私有化
private String name;
private int age;
//构造方法，实验这个构造方法是在什么时候被运行的
public Person(){
System.out.println("我是一个空参数的构造方法");
}
//get方法set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}l 测试类
package cn.itcast.ConstructorMethod;
/*
* 测试构造方法是在什么时候被运行的
*/
public class Test {
public static void main(String[] args) {
//创建Person类对象
Person p = new Person();
}
}运行结果：
在创建对象的时候就对成员变量进行初始化值，具体的代码演示如下：
l PersonName类
package cn.itcast.ConstructorMethod;
/*
* 创建构造方法
*/
public class PersonName {
//定义姓名
private String name;
//重写构造方法，对其传入有参的参数，也就是姓名
public PersonName(String name){
this.name = name;
}
//get方法set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}l 测试类
package cn.itcast.ConstructorMethod;
/*
* 测试构造方法是否在创建对象时初始化姓名值
*/
public class TestName {
public static void main(String[] args) {
//创建PersonName类的对象，对构造方法初始化值，其实就是在调用这个构造方法
PersonName pm = new PersonName("王杰");
//查看一下是否在创建对象时对姓名进行初始化值
System.out.println(pm.getName());
}
}构造方法的重载
类中的构造方法可以有重载，只要其参数列表不同即可，下面用一段代码来演示构造方法的重载：
l Person类
package cn.itcast.ConstructorMethodOverLoad;
/*
* 构造方法的重载
*/
public class Person {
//定义姓名，年龄
private String name;
private int age;
//构造方法的重载，空参构造方法
public Person(){
}
//构造方法的重载，有参构造方法
public Person(String name,int age){
this.name = name;
this.age = age;
}
//get方法set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}l 测试类
package cn.itcast.ConstructorMethodOverLoad;
/*
* 测试构造方法的重载
*/
public class Test {
public static void main(String[] args) {
//创建Person类对象，调用空参构造方法
Person p = new Person();
p.setName("张三");
p.setAge(18);
System.out.println(p.getName());
System.out.println(p.getAge());
//创建对象，调用有参的构造方法
Person p2 = new Person("李四", 19);
System.out.println(p2.getName());
System.out.println(p2.getAge());
}
}运行结果：
构造方法和一般方法的区别：
构造方法在创建对象的时候就被调用了，并且只能执行一次，而一般方法在创建对象后，需要被使用才会被对象所进行调用，一般方法可以被调用多次。
构造方法中this的作用就是将两个构造方法进行连接，在一个空参构造方法中通过this的方式对成员进行赋值，可以和有参的构造方法进行联系，调用有参的构造方法，传递实际参数，具体的使用细节如下：
注意，this的使用必须写在构造方法中的第一行。
l Person类
package cn.itcast.This;
/*
* 构造方法中this 的用法
*/
public class Person {
//定义姓名，年龄
private String name;
private int age;
//空参构造方法
public Person(){
this("张三",20);
}
//有参构造方法
public Person(String name,int age){
this.name = name;
this.age = age;
}
//get方法和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}l 测试类
package cn.itcast.This;
/*
* 测试类，测试构造方法中this的用法
*/
public class Test {
public static void main(String[] args) {
//创建对象，调用空参构造方法
Person p = new Person();
System.out.println(p.getName());
System.out.println(p.getAge());
}
}在子类中，可以使用super去调用父类的构造方法
super()调用的是父类空参数的构造方法
super(参数)调用的是父类中有参数的构造方法
注意：super必须写在构造方法中的第一行，super和this，两者有一个就可以了，如果子类继承父类，子类都必须直接或间接访问父类的构造方法。代码演示如下：
l 人类
package cn.itcast.ConstructorMethodSuper;
/*
* 父类构造方法
*/
public class Person {
public Person(int a){
}
}l 学生类
package cn.itcast.ConstructorMethodSuper;
/*
* 子类继承父类
* 子类构造方法直接或间接访问父类构造方法
*/
public class Student extends Person{
public Student(){
this(5);//调用本类构造方法，参数为int的构造方法
}
public Student(int a){
super(4);//调用父类的构造方法
}
}l Person类
package cn.itcast.ConstructorMethodSuper实例;
/*
* 需求：有学生和工人两个类，有其共有的属性name和age，要求在创建这两个对象时就对name和age赋值
* Person父类，学生和工人抽取的共有内容
* 成员变量私有，重写构造方法，接收传递变量的值
* get，set方法用于获取私有变量的值
*/
public class Person {
//私有变量name，age
private String name;
private int age;
//重写构造方法
public Person(String name,int age){
this.name = name;
this.age = age;
}
//get，set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}l Student类
package cn.itcast.ConstructorMethodSuper实例;
/*
* 学生类，继承Person类，重写构造方法，将创建学生对象后赋的值传递给父类的构造方法
*/
public class Student extends Person{
//重写构造方法，创建Student对象时直接赋值name，age
public Student(String name,int age){
//将值传递给父类的构造方法
super(name,age);
}
}l Worker类
package cn.itcast.ConstructorMethodSuper实例;
/*
* 工人类，继承Person类，重写构造方法，将值传递给父类的构造方法中
*/
public class Worker extends Person{
//重写构造方法，创建Worker对象时直接赋值name，age
public Worker(String name,int age){
//将值传递给父类构造方法
super(name, age);
}
}l Test测试类
package cn.itcast.ConstructorMethodSuper实例;
/*
* 测试类
* 创建学生，工人对象时就对name，age赋值，获取name，age的值
*/
public class Test {
public static void main(String[] args) {
//创建Student对象并赋值
Student s = new Student("张三",30);
//获取name，age的值
System.out.println(s.getName());
System.out.println(s.getAge());
//创建Worker对象并赋值
Worker w = new Worker("李四",20);
System.out.println(w.getName());
System.out.println(w.getAge());
}
}运行结果：
原文：http://blog.51cto.com/13502869/2060974