Java面向对象-构造方法,this关键字

Java面向对象-构造方法,this关键字

构造方法

概念：构造方法是一个特殊的方法，这个特殊方法用于创建实例时执行初始化操作；

上代码：

1 package com.java1234.chap03.sec04;
2
3 /**
4  * 定义人类
5  * @author user
6  *
7  */
8 public class People {
9
10     // 定义属性
11     private String name; // 实例化对象时，默认值是null
12     private int age; // 实例化对象时，默认值是0
13
14     /**
15      * 默认构造方法
16      */
17     People(){
18         System.out.println("默认构造方法！");
19     }
20
21
22
23     public void say(){
24         System.out.println("我叫："+name+"，我今年："+age);
25     }
26
27     public static void main(String[] args) {
28         People people=new People();
29         people.say();
30     }
31 }

运行输出：

默认构造方法！

运行结果

调用的是有参数的构造方法

我们把两个构造方法注释了，运行的话，依然没问题。

2，假如有构造方法，系统不会自动生成构造方法；

假如我们单独去掉无参数的构造方法，上代码：

1 package com.java1234.chap03.sec04;
2
3 /**
4  * 定义人类
5  * @author user
6  *
7  */
8 public class People {
9
10     // 定义属性
11     private String name; // 实例化对象时，默认值是null
12     private int age; // 实例化对象时，默认值是0
13
14
15     /**
16      * 有参数的构造方法
17      * @param name2
18      * @param age2
19      */
20     People(String name2,int age2){
21         System.out.println("调用的是有参数的构造方法");
22         name=name2;
23         age=age2;
24     }
25
26     public void say(){
27         System.out.println("我叫："+name+"，我今年："+age);
28     }
29
30     public static void main(String[] args) {
31         People people=new People();
32         //People people=new People("张三",20);
33         people.say();
34     }
35 }

我们会发现编译报错了：



The constructor People() is undefined

说找不到People()构造方法

this关键字

this表示当前对象

1，使用this调用本类中的属性和方法；

2，使用this调用构造方法；

我们上面的例子

1 People(String name2,int age2){
2     System.out.println("调用的是有参数的构造方法");
3     name=name2;
4     age=age2;
5 }

构造方法的属性名和类里的属性名不一致； 假如说我们搞成一致；



这里警告的意思 是自己赋值给自己 没有意义，这里的name和age变量 作用范围在方法里 所以和类里的属性名搭不上边；

我们如何才行指定类里的属性呢，这时候this关键字派上用场了。

我们可以用this关键字类执行当前对象 this.属性 实现；

上代码：

1 package com.java1234.chap03.sec04;
2
3 /**
4  * 定义人类
5  * @author user
6  *
7  */
8 public class People {
9
10     // 定义属性
11     private String name; // 实例化对象时，默认值是null
12     private int age; // 实例化对象时，默认值是0
13
14     /**
15      * 默认构造方法
16      */
17     /*People(){
18         System.out.println("默认构造方法！");
19     }*/
20
21     /**
22      * 有参数的构造方法
23      * @param name
24      * @param age
25      */
26     People(String name,int age){
27         System.out.println("调用的是有参数的构造方法");
28         this.name=name;
29         this.age=age;
30     }
31
32     public void say(){
33         System.out.println("我叫："+name+"，我今年："+age);
34     }
35
36     public static void main(String[] args) {
37         // People people=new People();
38         People people=new People("张三",20);
39         people.say();
40     }
41 }

假如在我们还有需求，在构造方法中调用另外一个构造方法，比如默认构造方法里是基本的初始化，有参数的构造方法是附加初始化，

再调用有参数的构造方法时候，我们先调用无参数构造方法，实现基本初始化，然后再进行附加初始化，这时候this关键字又派上用场了，

我们调用this()就是调用无参数构造方法，括号里也可以加参数，来调用有参数的构造方法。

上代码：

1 package com.java1234.chap03.sec04;
2
3 /**
4  * 定义人类
5  * @author user
6  *
7  */
8 public class People {
9
10     // 定义属性
11     private String name; // 实例化对象时，默认值是null
12     private int age; // 实例化对象时，默认值是0
13
14     /**
15      * 默认构造方法
16      */
17     People(){
18         System.out.println("默认构造方法！");
19     }
20
21     /**
22      * 有参数的构造方法
23      * @param name
24      * @param age
25      */
26     People(String name,int age){
27         this(); // 调用无参数的构造方法
28         System.out.println("调用的是有参数的构造方法");
29         this.name=name;
30         this.age=age;
31     }
32
33     public void say(){
34         System.out.println("我叫："+name+"，我今年："+age);
35     }
36
37     public static void main(String[] args) {
38         // People people=new People();
39         People people=new People("张三",20);
40         people.say();
41     }
42 }

运行输出

默认构造方法！