Java入门-------构造方法和构造方法的重载

构造方法：

当我们实例化一个对象之后，如果要为这个对象中的属性赋值，则必须通过直接访问对象的属性或调用setter方法才可以，如果需要在实例化对象时，为这个对象的属性赋值，可以通过构造方法实现。

构造方法（也被称为构造器）是类的一个特殊成员方法，在类实例化对象时自动调用。

定义构造方法：

构造方法是一个特殊的成员方法，在定义时，有以下几点需要注意：

<1>构造方法的名称必须与类一致

<2>构造方法名称前不能有任何返回值类型的声明。

<3>不能在构造方法中使用return返回一个值，但是可以单独写return语句作为方法的结束。

举例：

无参构造方法：

public class Example{
    public static void main(String[]args){
        System.out.println("声明对象....");
        student1 stu=null;
        System.out.println("实例化对象....");
        stu=new student1();
    }
}
1
2
3
4
5
6
7
8

class student1{
    public student1(){
        System.out.println("调用了无参构造方法");
    }
}
1
2
3
4
5

输出：

声明对象....
实例化对象....
调用了无参构造方法
1
2
3

含参构造方法：

举例：

public class Example{
    public static void main(String[]args){
        student1 stu=new student1("张三",19);//注意不要忘记传递参数
        stu.read();//调用方法
    }
}
1
2
3
4
5
6

class student1{
//私有属性-----name和age
    private String name;
    private int age;
    public student1(String n,int a) {
        name=n;
        age=a;

    }
    public void read(){
        System.out.println("我是："+name+",年龄："+age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

我是：张三,年龄：19
1

构造方法的重载：

和普通方法相同，构造方法也可以重载，在一个类中定义多个构造方法，只要每个构造方法的参数或参数个数个数不同即可。

在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。

举例：

class student1{
    private String name;
    private int age;
    public student1(){}
    public student1(String n){//构造含1个参数方法
        name =n;
    }
    public student1(String n,int a){//构造含2个参数方法 
        name=n;
        age=a;
    }
    public void read()
    {
        System.out.println("我是:"+name+",年龄:"+age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Example{
    public static void main(String[]args){
    //通过传递不同个数的参数来调用不同的构造方法
        student1 stu1=new student1("张三");
        student1 stu2=new student1("李四",30);
        stu1.read();
        stu2.read();
    }
}
1
2
3
4
5
6
7
8
9

输出：

我是:张三,年龄:0
我是:李四,年龄:30
1
2

this关键字：

在Java中，当成员变量与局部变量发生重名问题时，需要使用到this关键字分辨成员变量与局部变量。

Java中的this关键字语法比较灵活，其主要作用有以下几点：

<1>使用this关键字调用本类中的属性。

<2>this关键字调用成员变量.

<3>使用this关键字调用本类的构造方法。

在类的构造方法中，如果参数名称与类属性名称相同，则会导致成员变量和局部变量的名称冲突。

使用this关键字调用本类中的属性：

举例：

public class Example{
    public static void main(String[]args){
        student1 stu=new student1("张三",19);
        System.out.println(stu.read());
    }
}
1
2
3
4
5
6

class student1{
    private String name;
    private int age;
public student1(String name,int age){
//类属性名称和参数名称相同
    name=name;
    age=age;
}
public String read(){
    return "我是："+name+"年龄："+age;
}
}
1
2
3
4
5
6
7
8
9
10
11
12

输出：

我是：null年龄：0
1

从输出结果，我们不难看出，构造方法中的赋值并没有运行成功，这是因为参数名称与对象成员变量名称相同，编译器无法确定那个名称是当前对象的属性，因此当我们赋值名字为张三，年龄为19时，最终并未赋值成功。

为了解决这个问题，Java提供了关键字this指代当前的对象，通过this可以访问当前对象的成员。

将代码修改：

this.name=name;
this.age=age;
1
2

输出：

我是：张三年龄：19
1

使用this关键字调用成员方法：

class student1{
    public static void main(String[] args){
    }
    public void  openMouth(){
    }
    public void read(){
        this.openMouth();//通过关键字调用成员方法
    }
}
1
2
3
4
5
6
7
8
9

使用this关键字调用构造方法：

构造方法是在实例化对象时被Java虚拟机自动调用，在程序中不能像调用其他成员方法一样调用构造方法，但可以在一个构造方法中使用“this（参数一，参数二…）”的形式调用其他的构造方法。

举例：

class student1{
    private String name;
    private int age;
    public student1(){
        System.out.println("实例化了一个新的student对象：");
    }
    public student1(String name,int age){
        this();//调用无参的构造方法
        this.name=name;
        this.age=age;
    }
    public String read(){
        return "我是:"+name+",年龄："+age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Example{
    public static void main(String[]args){
        student1 stu=new student1("张三",19);
        System.out.println(stu.read());
    }
}
1
2
3
4
5
6

输出：

实例化了一个新的student对象：
我是:张三,年龄：19
1
2

在使用this调用类的构造方法时，应注意以下几点：

<1>只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用其他构造方法。

<2>在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。

举例：

class student1 {
    private String name;
    private int age;

    public student1() {
        System.out.println("实例化了一个新的student对象：");
    }

    public student1(String name, int age) {
        this();
        this.name = name;
        this.age = age;
    }

    public String read() {
        return "我是:" + name + ",年龄：" + age;
    }

    public student1(String name) {
        System.out.println("有参的构造方法被调用了");
        this(age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

编译未通过，报错如下：

<3>不能在一个类的两个构造方法中使用this互相调用

举例：

class student1{
    public static void main(String[] args){

    }
    public student1(){
        this("张三");
        System.out.println("无参的构造方法被调用了");
    }
    public student1 (String name){
        this();
        System.out.println("有参的构造方法被调用了");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

编译未通过，报错如下：

代码块：

代码块，简单来说，就是用“{}”括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为4种：普通代码块，构造块，静态代码块，同步代码块。

普通代码块：

普通代码块就是直接在方法或语句中定义的代码块。

举例：

//虽然定义了两个变量名相同的变量，但是由于代码块将变量的作用域分割开了，所以并不影响使用这两个变量名相同的变量
public class student1 {
    public static void main(String[] args) {
        {
            int age = 18;
            System.out.println("这是普通代码块,age:" + age);
        }

        int age = 30;
        System.out.println("age:" + age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

输出：

这是普通代码块,age:18
age:30
1
2

构造块：

构造代码块是直接在类中定义的代码块。

举例：

class student1{
    String name;
    public student1(){
        System.out.println("我是student类的构造方法");
    }
    //直接定义在类中的代码块为构造代码块
    {//定义在成员位置----与构造方法，成员属性同级
        System.out.println("我是构造代码块");
    }
}
1
2
3
4
5
6
7
8
9
10

public class Example{
    public static void main(String[]args){
        student1 stu1=new student1();
        student1 stu2=new student1();
    }
}
1
2
3
4
5
6

输出：

我是构造代码块
我是student类的构造方法
我是构造代码块
我是student类的构造方法
1
2
3
4

通过输出结果，我们可以得出如下结论：

<1>在实例化student1类对象stu1,stu2时，构造块的执行顺序大于构造方法（这里和构造块写在前面还是后面无关）。例如上述实例，我们就将其写在了后面。

<2>每当实例化一个student1类对象，都会在执行构造方法之前执行构造代码块。