类的初始化

一、基本概念

1. 方法重载

• 原因一： 成员方法，需要不同的参数来调用
• 原因二：构造方法，需要不同的参数来初始化对象

# 条件
0. 方法名字相同
1. 方法参数个数不同
2. 方法参数顺序不同： 不推荐使用，代码难以维护

返回值不能区别，因为有时候有返回值，但可以不处理返回值，编译器无法区分

2. this

• 指向当前对象的引用

- 如果调用当前类的其他成员方法，其他成员变量，this可以省略
- 只有当明确的要返回当前对象的时候，才会使用this
- 将当前对象传递给其他的方法的参数
- this调用当前构造器，只能调用一次，且只能放在第一行

要是在代码中出现大量的static，需要重新考虑自己设计，
因为不是面向对象

package com.day.dreamer.queue;

public class Demo04 {
    public static void main(String[] args) {
        Person person = new Person().increment().increment().increment();
        System.out.println(person.getNumber());
    }
}

class Person {

    private int number = 0;

    public int getNumber() {
        return number;
    }


    public void method01() {
        /*1. 如果调用当前类的其他成员方法，其他成员变量，this可以省略*/
        this.method02();
    }

    public void method02() {
    }

    /*2. 只有当明确的要返回当前对象的时候，才会使用this
     *    可以通过链式编程的方法来写改程序*/
    public Person increment() {
        number++;
        return this;
    }

    /*3. 将当前对象传递给其他的方法的参数*/
    public void work(){
        work01(this);
    }

    public void work01(Person person) {
    }
}

二、初始化

1. 变量

• 初始化和创建是绑定在一起的
• 局部变量：没有默认值，通过编译器错误来显示提醒
• 成员变量：会默认给值，保证不会发生空指针问题

2. 成员变量初始化

1. 直接赋值
2. 调用方法
3. 构造方法

1.1 成员变量加载顺序：从上到下逐行加载

class Student {
    /*1*/
    public String name = "erick";

    /*2*/
    public int age;

    public Student(int age) {
        this.age = age;
    }

    /*3调用方法
    *   3.1 Illegal forward reference*/
    public int sum;

    private int num01 = toDouble(num02);// 报错

    private int num02 = toDouble(1);

    public int toDouble(int original) {
        return original * 2;
    }
}

3. 初始化顺序

3.1 静态数据变量

• 类加载后，就会对静态成员变量和静态代码块进行初始化
• 初始化顺序：按照声明顺序从上到下
• 初始化会存储一份，后续new的新对象，不再创建

class Student {

    /*静态成员变量和静态代码块，从上倒下，依次加载*/
    private static Girl first = new Girl("first");

    static {
        Girl second = new Girl("second");
    }

    private static Girl second = new Girl("third");
}

class Girl {
    public Girl(String name) {
        System.out.println("girl is coming: " + name);
    }
}

3.2 非静态数据变量

• 成员变量及非静态代码块
• 成员变量执行顺序从上到下

3.3 构造器

1. 通过new来触发，或者访问某个类的静态成员时候在堆上为类分配足够的空间
2. 存储空间被清零，给默认值
3. 执行所有字段的初始化
4. 执行构造器

4. 数组

• 可以先初始化，待到数组运行的时候，得到数组的具体长度

public class Demo05 {
    public static void main(String[] args) {
        int[] arr = new int[getLength()];
        System.out.println(arr.length);
    }

    private static int getLength() {
        return 10;
    }
}

5. 可变参数

• 如果是可变参数，那么将其封装到数组里面
• 如果传入的是数组，则直接使用，编译器就没有再去转换了
• 可以传递 0-n个参数

6. 枚举值

• 天生和switch绝配

public class Demo05 {
    public static void main(String[] args) {
        ADDRESS address = ADDRESS.CHINA_XIAN;
        System.out.println(address);
        System.out.println(address.toString());
        System.out.println(address.ordinal());

        /*3. 枚举值的数组, 按照声明顺序*/
        ADDRESS[] values = ADDRESS.values();
    }
}

enum ADDRESS {
    /*1. 编译器会自动创建： toString, 输出枚举名字： CHINA_XIAN
     * 2. 编译器会自动创建： ordinal， 输出顺序，按照声明顺序0-n*/
    CHINA_XIAN,
    CHINA_SHANGHAI,
    US_WEST,
    US_EASE
}

三、访问权限

• 类库的提供者，改动的时候不得影响任何现有方法，因为那样会破坏客户端程序的代码
• 改动的时候，到底那些域被客户端调用了呢？无从得知
• 因此引入访问权限控制符

public
protected： 包及子类
default: 包访问权限
privte

1. 基本注意点

# 编译单元
1. 一个java源文件，就是一个编译单元
2. 一个编译单元只能有一个public类，且类名和文件名相同

# 输出文件
1. 一个java文件，里面每个类都会被编译成一个 class文件
2. 少量java文件，编译后会出现大量的class文件
3. Java运行程序是一组可以打包并压缩成一个jar包的class文件
4. Java解释器负责这些文件的查找，装载，解释

2. 权限修饰符的方法

• 在一个类中，最好能按照public， protected，default，private的顺序来书写，这样提高代码的可读性