6.11、面向对象3构造器

类的成员之三：构造器(Constructor)

我们 new 完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要
挨个为它们再赋值，太麻烦了。我们能不能在 new 对象时，直接为当前对象的
某个或所有成员变量直接赋值呢？

可以，Java 给我们提供了构造器（Constructor)，也称为构造方法。

1.1 概念

构造方法是一种特殊的方法,它是一个与类同名且没有返回值类型的方法
构造方法的主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时,就会自动调用构造方法
构造方法与普通方法一样也可以重载.

10.1 构造器的作用

new 对象，并在 new 对象的时候为实例变量赋值。
举例：Person p = new Person(“Peter”,15);

构造器的语法格式

1.2、 形式
与类同名,且没有返回值类型,可以含参也可以不含参

1.3 练习：构造方法创建对象/构造方法赋值

创建包: cn.tedu.oop
创建类: TestConstructor.java

package cn.tedu.oop;
/*本类用于测试构造方法*/
public class TestConstructor {
    public static void main(String[] args) {
        //4.创建Perosn类的对象进行测试
        /*1.每次new(实例化)对象时，都会自动触发对应类的构造方法*/
        /*2.每一个类都会默认存在一个没有参数的构造方法
        * 但是，如果你提供了其他的构造函数，默认的无参构造会被覆盖
        * 所以，我们要手动的提供无参构造，这样才能不传参数，也能创建对象*/
        Person p = new Person();
        System.out.println(p.age);
        System.out.println(p.name);
        System.out.println(p.address);
        p.eat();
        //6.创建Person类的第二个对象
        /*4.每次创建对象时，都会执行构造方法
        * 构造方法的作用：用来创建对象的*/
        Person p2 = new Person();
        //8.触发含参构造
        Person p3 = new Person(88);
        System.out.println(p3.name);
        Person p4 = new Person("张三",18,"柳树下");
        System.out.println(p4.name);
        System.out.println(p4.age);
        System.out.println(p4.address);
    }
}
//1.创建Person类，用来描述人这一类事物
class Person{
    //2.属性--成员变量
    String name;//姓名
    int age;//年龄
    String address;//住址
    //8.创建本类的全参构造
    //右键->Generate->Constructor->Shift全选所有属性->OK
    public Person(String name, int age, String address) {
        this.name = name;//局部变量name的值赋值给this指定的成员变量name
        this.age = age;//局部变量age的值赋值给this指定的成员变量age
        this.address = address;//局部变量address的值赋值给this指定的成员变量address
        System.out.println("我是Person类的全参构造");
    }

    /*3.构造方法的格式：没有返回值类型并且与类名同名的方法*/
    //5.创建本类的无参构造
    public Person(){
        System.out.println("我是Person类的无参构造~");
    }
    //7.创建本类的含参构造
    public Person(int n){
        System.out.println("我是Person类的含参构造"+n);
    }

    //3.功能--方法
    public void eat(){
        System.out.println("干饭不积极，思想有问题~");
    }
}

说明：

1. 构造器名必须与它所在的类名必须相同。
2. 它没有返回值，所以不需要返回值类型，也不需要 void。
3. 构造器的修饰符和修饰符类名的修饰符相同，不能被其他任何修饰。比如，不能被 static、final、synchronized、abstract、native 修饰，不能有 return 语句返回值。

10.3 使用说明

当我们没有显式的声明类中的构造器时，系统会默认提供一个无参的构造器并且该构造
器的修饰符默认与类的修饰符相同

当我们显式的定义类的构造器以后，系统就不再提供默认的无参的构造器了。
在类中，至少会存在一个构造器。

2 构造代码块与局部代码块
2.1形式：
{ 代码… }

2.2 构造代码块的特点
位置: 在类的内部,在方法的外部
作用: 用于抽取构造方法中的共性代码
执行时机: 每次调用构造方法前都会调用构造代码块
注意事项: 构造代码块优先于构造方法加载

2.3局部代码块
位置: 在方法里面的代码块
作用: 通常用于控制变量的作用范围,出了花括号就失效
注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

2.4练习：测试代码块的加载顺序

创建包: cn.tedu.oop
创建类: TestBlock.java

package cn.tedu.oop;
/*本类用于测试代码块
执行顺序：构造代码块->构造方法->普通方法->局部代码块,分析：
1.当创建对象时，会触发构造函数
2.创建对象时，也会触发构造代码块，并且构造代码块优先于构造方法执行
3.我们创建好对象后才能通过对象调用普通方法
4.如果普通方法里有局部代码块，才会触发对应的局部代码块 */
public class TestBlock {
    public static void main(String[] args) {
        //5.分别触发3个构造函数创建对象
        Pig p1 = new Pig();//触发的是无参构造
        Pig p2 = new Pig("佩奇");//触发的是含参构造
        Pig p3 = new Pig("肉包子",5);//触发的是全参构造
        //6.通过创建好的对象进行测试
        System.out.println(p1.age);//0,默认值
        System.out.println(p2.age);//0,默认值
        System.out.println(p3.age);//5，创建对象时赋值的
        p1.eat();
        p2.eat();
        p3.eat();
    }
}
//1.创建一个小猪类用来测试
class Pig{
    //2.定义属性
    String food;//食物
    int age;//年龄

    //7.创建本类的构造代码块
    {
        /*构造代码块：{}
        * 1.位置：类里方法外
        * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
        * 3.作用：用于提取所有构造方法的共性功能*/
        System.out.println("我是一个构造代码块");
        System.out.println("黑猪肉！");
    }

    //4.1创建本类的无参构造
    public Pig(){
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的无参构造");
    }
    //4.2创建本类的含参构造
    public Pig(String s){
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的含参构造"+s);
    }
    //4.3创建本类的全参构造
    //右键->Generate->Constructor->Shift全选所有属性->ok
    public Pig(String food, int age) {
        //System.out.println("黑猪肉~");
        System.out.println("我是Pig类的全参构造");
        this.food = food;
        this.age = age;
    }

    //3.创建普通方法
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        //8.创建本类的局部代码块
        {
            /*局部代码块：{}
            1.位置：方法里
            2.执行时机：调用本局部代码块所处的方法时才会执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
            * */
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
    }
}

类中属性赋值过程

1、在类的属性中，可以有哪些位置给属性赋值？
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过"对象.属性"或"对象.方法"的方式，给属性赋值

2、这些位置执行的先后顺序是怎样？
顺序：① - ② - ③ - ④ 3、说明：
上述中的①、②、③在对象创建过程中，只执行一次。
④ 是在对象创建后执行的，可以根据需求多次执行。