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 }

运行输出:

默认构造方法!

我叫:null,我今年:0
 
 

 

这里我们发现: 实例化对象的时候,String类型的默认值是null,int基本类型的默认值是0 ;

People(){} 构造方法 

特点 1,没有返回值类型,区别于其他一般方法;

       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     People(){
18         System.out.println("默认构造方法!");
19     }
20      
21     /**
22      * 有参数的构造方法
23      * @param name2
24      * @param age2
25      */
26     People(String name2,int age2){
27         System.out.println("调用的是有参数的构造方法");
28         name=name2;
29         age=age2;
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 }

运行结果

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

我叫:张三,我今年:20
 
 

这里我们定义了一个有参数的构造方法,参数有name2 age2,当调用构造方法的时候,用于赋值给name和age属性;

 

 

注意点:

1,假如没有构造方法,系统会自动生成一个默认的无参构造方法;

 

上代码,我们去掉刚才定义的People(){} 

 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 name2
24      * @param age2
25      */
26     /*People(String name2,int age2){
27         System.out.println("调用的是有参数的构造方法");
28         name=name2;
29         age=age2;
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 }

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

 

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 }

运行输出

默认构造方法!

调用的是有参数的构造方法
我叫:张三,我今年:20

 

 

 

 

 

 

 

 

 

 

 

 

posted on 2016-10-17 16:41  eaglezb  阅读(1647)  评论(0编辑  收藏  举报

导航