JAVA面向对象2：构造方法和this关键字

构造方法

1、构造方法的定义

在一个类中定义的方法如果同时满足以下三个条件，该方法成为构造方法，具体如下：

1. 方法名与类名相同。
2. 在方法名的前面没有返回值类型的声明。
3. 在方法中不能使用return语句返回一个值。
   案例1：

class Person {
    //下面是类的构造方法
    public Person {
        System.out.println("无参的构造方法被调用了……");
    }
}

public class Example1 {
    public static void main(String[] args) {
        Person p=new Person();        //实例化Person对象
    }
}

在案例1的Person类中定义了一个无参的构造方法Person()。从结果可以看出，Person类中无参的构造方法被调用了。这是因为第10行代码在实例化Person对象时会自动调用类的构造方法，“new Person()”语句的作用除了会实例化Person对象，还会调用构造方法Person()。

在一个类中除了定义无参的构造方法，还可以定义有参的构造方法，通过有参的构造方法就可以实现对属性的赋值。
案例2：

class Person {
    int age;
    //定义有参的构造方法
    public Person(int a) {
        age=a;                         //为age属性赋值
    }
    public void speak() {
        System.out.println("I am "+age+" years old.!");
    }
}
public class Example2 {
    public static void main(String[] args) {
        Person p=new Person(20);       //实例化Person对象
        p.speak();
    }
}

案例2的Person类中定义了有参的构造方法Person(int a)，第13行代码中的“new Person(20)”会在实例化对象的同时调用有参的构造方法，并传入了参数20在构造方法Person(int a)中将20赋值给对象的age属性。Person对象调用speak()方法时，其age属性已经被赋值为20。

2、构造方法的重载

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。
案例3：

class Person {
    String name;
    int age;
    //定义两个参数的构造方法
    public Person(String con_name, int con_age) {
        name=con_name;             //为name属性赋值
        age=con_age;               //为age属性赋值
    }
    //定义一个参数的构造方法
    public Person(String con_name) {
        name=con_name;             //为name属性赋值
    }
    public void speak() {
        //打印name和age的值
        System.out.println("大家好，我叫"+name+"，我今年"+age+"岁！");
    }
}
public class Example3 {
    public static void main(String[] args) {
        //分别创建两个对象p1和p2
        Person p1=new Person("陈杰");
        Person p2=new Person("李芳", 18);
        //通过对象p1和p2调用speak()方法
        p1.speak();
        p2.speak();
    }
}

案例3的Person类中定义了两个构造方法，他们构成了重载。在创建p1对象和p2对象时，根据传入参数的不同，分别调用不同的构造方法。从程序的结果可以看出，两个构造方法对属性赋值的情况是不一样的，其中一个参数的构造方法只针对name属性进行赋值，这是age属性的值为默认值0。

注意！！！
1、在Java中的每个类都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数，在其方法体中没有任何代码，即什么也不做。
第一种写法：

class Person {

}

第二种写法：

class Person {
    public Person {
    }
}

对于第一种写法，类中虽然没有声明构造方法，但仍然可以用new Person()语句来创建Person类的实例对象。由于系统提供的构造方法往往不能满足需求，因此，我们可以自己在类中定义构造方法，一旦为该类定义了构造方法，系统就不再提供默认的构造方法了，例如：

class Person {
    int age;
    public Person(int x) {
        age=x;
    }
}

上面的Person类中定义了一个对成员变量赋初值的构造方法，该构造方法有一个参数，这时系统就不再提供默认的构造方法，接下来再编写一个测试程序调用上面的Person类。

public class Example00 {
    public static void main(String[] args) {
        Person p=new Person();        //实例化Person对象
    }
}

编译上述代码会看出程序在编译时报错，其原因是调用new Person()创建Person类的实例对象时，需要调用无参的构造方法，而我们并没有定义无参的构造方法，只是定义了一个有参的构造方法，系统将不再自动生成无参的构造方法。为了避免出现上面的错误，在一个类中如果定义了有参的构造方法，最好在定义一个无参的构造方法。

2、下一个例子

class Person {
    //定义构造方法
    private Person() {
        System.out.println("调用无参的构造方法");
    }
}

public class Example01 {
    public static void main(String[] args) {
        Person p=new Person();
    }
}

从编译结果可以看出，程序在编译时出现了错误，错误提示为private关键字修饰的构造方法Person()只能在Person类中被访问。也就是说Person()构造方法是私有的，不可以被外界调用，也就无法在类的外部创建该类的实例对象。因此为了方便实例化对象，构造方法通常会用public来修饰。

this关键字

在案例3中使用变量表示年龄时，构造方法中使用的是con_age，成员变量使用的是age，这样的程序可读性很差。这时需要将一个类中表示年龄的变量进行统一的命名，例如都声明为age。但是这样做又会导致成员变量和局部变量的名称冲突，在方法中将无法访问成员变量age。为了解决这个问题，Java中提供了一个关键字this，用于在方法中访问对象的其他成员。
1、通过this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。

class Person {
    int age;
    pubic Person(int age) {
        this.age=age;
    }
    public int getAge() {
        return this.age;
    }
}

在上面的代码中，构造方法的参数被定义为age，它是一个局部变量，在类中还定义了一个成员变量，名称也是age。在构造方法中如果使用“age”，则是访问局部变量，但如果使用“this.age”则是访问成员变量。

2、通过this调用成员方法。

class Person {
    public void openMouth() {
        ...
    }
    public void speak() {
        this.openMouth();
    }
}

在上面的speak()方法中，使用this关键字调用openMouth()方法。注意，此处的this关键字可以省略不写，也就是说上面的第6行代码写成“this.openMouth()”和“openMouth()”，效果是完全一样的。

3、构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数1, 参数2, 参数3, …])”的形式来调用其他的构造方法。
案例4：

class Person {
    public Person() {
        System.out.println("无参的构造方法被调用了……");
    }
    public Person(String name) {
        this();                           //调用无参的构造方法
        System.out.println("有参的构造方法被调用了……");
    }
}
public class Example4 {
    public static void main(String[] args) {
        Person p=new Person("itcast");    //实例化Person对象
    }
}

案例4中第12行代码在实例化Person对象时，调用了有参的构造方法，在该方法中通过this()调用了无参的构造方法，因此运行结果中显示两个构造方法都被调用了。

在使用this调用类的构造方法时，应注意以下几点。
1. 只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。
2. 在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次，下面的写法是非法的：

public Person() {
    String name="小芳";
    this(name);             //调用有参的构造方法，由于不在第一行，编译错误！
}

3.不能再在一个类的两个构造方法中使用this互相调用，例如：

class Person {
    public Person() {
        this("小芳");                 //调用有参的构造方法
        System.out.println("无参的构造方法被调用了……");
    }
    public Person(String name) {
        this();                      //调用无参的构造方法
        System.out.println("有参的构造方法被调用了……");
    }
}