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

构造器的重载

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

注意

如果一个类写了有参构造器，那么一定要写无参构造器，不然会出问题。