【Java】构造器及其内存分析

构造器

1. package com.star2;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class Person {
7.     //构造器：没有任何参数的构造器我们叫做：空参构造器--》空构造器
8.     public Person(){
9.         /*age = 19;
10.         name = "lili";
11.         height = 169.5;*/
12.     }
13.     //属性：
14.     String name;
15.     int age;
16.     double height;
17.     //方法：
18.     public void eat(){
19.         System.out.println("我喜欢吃饭");
20.     }
21. }

1. package com.star2;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class Test {
7.     //这是一个main方法，是程序的入口：
8.     public static void main(String[] args) {
9.         //创建一个Person类的具体的对象/实例/实体：
10.         /*
11.         创建对象的过程：
12.         1.第一次遇到Person的时候，进行类的加载（只加载一次）
13.         2.创建对象，为这个对象在堆中开辟空间
14.         3.为对象进行属性的初始化动作
16.         new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
17.         调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
18.         可以自己显式 的将构造器编写出来：
19.         构造器的格式：
20.         [修饰符] 构造器的名字(){
22.         }
23.         构造器和方法的区别：
24.         1.没有方法的返回值类型
25.         2.方法体内部不能有return语句
26.         3.构造器的名字很特殊，必须跟类名一样
28.         构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。
29.         调用构造器的目的是给属性进行赋值操作的。
31.         注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。
32.         实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写
33.          */
34.         Person p = new Person();
35.         System.out.println(p.age);
36.         System.out.println(p.name);
37.         System.out.println(p.height);
39.         Person p2 = new Person();
40.         System.out.println(p2.age);
41.         System.out.println(p2.name);
42.         System.out.println(p2.height);
43.     }
44. }

构造器的重载

1. package com.star3.star2;
2. /**
3.  * @Auther: Starshine
4.  */
5. public class Person {
7.     //属性：
8.     String name;
9.     int age;
10.     double height;
12.     //空构造器
13.     public Person(){
15.     }
16.     public Person(String name,int age,double height){
17.         //当形参名字和属性名字重名的时候，会出现就近原则：
18.         //在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
19.         this.name = name;
20.         this.age = age;
21.         this.height = height;
22.     }
23.     public Person(String a,int b){
24.         name = a;
25.         age = b;
26.     }
28.     //方法：
29.     public void eat(){
30.         System.out.println("我喜欢吃饭");
31.     }
32. }

1. package com.star3.star2;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class Test {
7.     //这是一个main方法，是程序的入口：
8.     public static void main(String[] args) {
9.         /*
10.         1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
11.         2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作
12.         3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
13.         4. 当形参名字和属性名字重名的时候，会出现就近原则：
14.         在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
16.          */
18.         Person p = new Person();
19.         /*p.age = 19;
20.         p.name = "lili";
21.         p.height = 180.4;*/
23.         Person p2 = new Person("lili",19,180.4);
24.         System.out.println(p2.age);
25.         System.out.println(p2.height);
26.         System.out.println(p2.name);
28.     }
29. }

内存分析

代码1

public class Person {         int  id;         int  age;         public static void main(String args[]){                 Person p1= new Person();         } }

内存分析：

代码2

1. public class Person {
2.         int id;
3.         int age;
4.         String school;
5.         public Person (int a,int b,String c){
6.                 id=a;
7.                 age=b;
8.                 school=c;
9.         }
10.         public static void main(String args[]){
11.                 Person p= new Person(1,20, "海淀");
12.         }
13. }
14. 

代码3

class Person{         int id;         int age;         String school;         Person (int a,int b,String c){                 id=a;                 age=b;                 school=c;         }         public void setAge(int a){                 age=a;         } }

public class Test {     public static void main(String[] args) {                   Test t=new Test();                   int age=40;                   Person tom=new Person(1,20,"海淀");                   Person jack=new Person(2,30,"朝阳");                   t.change1(age);                   t.change2(tom);                   t.change3(jack);                   System.out.println(age); //40                   System.out.println("id:"+jack.id+",age:"+jack.age+",school:"+jack.school); //id:2,age:66,school:"朝阳"     }     public void change1(int i){                 i=3366;     }     public void change2(Person p){               p=new Person(3,22,"西城");     }     public void change3(Person p){         p.setAge(66);     } }

 

this

【1】创建对象的过程：

（1）在第一次遇到一个类的时候，对这个类要进行加载，只加载一次。

（2）创建对象，在堆中开辟空间

（3）对对象进行初始化操作，属性赋值都是默认的初始值。

（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值

this:

从上面的效果能够看到：this指代的就是当前对象：

内存：