03. Java基础之初始化

一. 用构造器确保初始化

         构造器是一种特殊类型的方法，因为它没有返回值。这与返回值为空（void）明显不同。对于空返回值，尽管方法本身不会自动返回什么，但仍然可以选择让它返回别的东西。构造器则不会返回任何东西，你别无选择（new表达式确实返回了对新建对象的引用，但构造器本身并没有任何返回值）。假如构造器具有返回值，并且允许人们自行选择返回类型，那么势必得让编译器知道该如何处理此返回值。

1. 一个类中，可以变量、方法名和构造器都同名

public class Test {
    public String Test = "hello";

    public Test() {
        System.out.println("no param constructor");
    }

    public Test(String name) {
        System.out.println("param constructor");
    }

    public void Test() {
        System.out.println("Test.Test()");
    }

    public static void main(String args[]) {
        Test test = new Test();
        Test test2 = new Test("name");
        System.out.println(test.Test);
        System.out.println(test2.Test);
        test.Test();
        test2.Test();
    }
}

no param constructor
param constructor
hello
hello
Test.Test()
Test.Test()

2. 方法重载

    每个重载的方法都必须有一个独一无二的参数类型列表。

    如果传入的数据类型（实际参数类型）小于方法中声明的形式参数类型，实际数据类型就会提升。char类型不同，如果无法找到正好接受char参数的方法，就会直接提升为int型。

大小参数传入举例：

public class Test {
    public void f(int a) {
        System.out.println(a);
    }
    public static void main(String args[]) {
        Test test=new Test();
        test.f('a');//print 97
        test.f(2.0);//compile error, double can't treat as int
    }
}

note:如果传入的实际参数较大，就得通过类型转换来执行窄化转换。如果不这样做，编译器就会报错。

note:不能用返回值区分重载方法，因为void f()和int f()在调用的时候，我们会认为模糊，不知道调用了哪一个，那么机器就更加的糊涂了。java不知道调用哪一个f().

3. 默认构造器

如果已经定义了一个构造器（无论是否有参数），编译器就不会帮你自动创建默认构造器。

public class Test {
    public Test(int a)
    {
        
    }
    public static void main(String args[]) {
        Test test=new Test(1);
        Test test2=new Test();//compile error
    }
}

4. this关键字

（1）方法调用

public class Banana {
    void peel(int i) {
        
    }

}


public class BananaPeel {
    public static void main(String args[]) {
        Banana a=new Banana(),
                b=new Banana();
        a.peel(1);
        b.peel(2);
    }

}

上面的peel是如何知道是被a还是b调用呢？原来是编译器做了一些幕后工作。它暗自把“所操作对象的引用”作为第一个参数传递给了peel()。所以上述两个方法的调用变成了这样：

Bannana.peel(a,1);

Bannana.peel(b,1);

这是内部的表示形式，我们并不可以这么写。由于这个引用是编译器偷偷传入的，所以没有标识符可以用。但是，为此专门有了this. this关键字只能在方法内部使用，表示“调用方法的哪个对象”的引用。如果在方法内部调用同一个类的另一个方法，就不必加this，直接调用就可以。

（2）构造器调用

public class Test {
    public Test() {
        System.out.println("no parm");
    }
    public Test(int i)
    {
        this();//直接调用无参构造器
        System.out.println("parm");
    }
    public static void main(String args[]) {
        Test test=new Test(1);
        
    }
}

no parm
parm

note:调用有参构造器时，采用this(2);即可

（3）vs static

static方法就是没有this的方法。在static方法的内部不能调用非static方法，反过来可以。使用static方法时，由于不存在this，所以不是通过“向对象发送消息”的方式来完成的。

5. 成员初始化

    对于方法的局部变量，Java以编译错误的形式来保证它得到初始化。成员变量，即使没有显示初始化，也会默认给个指定值。

public class Test {
    public String aString;
    public void f()
    {
        int a;
                int c;//只是定义，但没使用，因此不会报错
        int b;
        b=4;
        System.out.println(b);//4
        System.out.println(a);//compile error
    }
    public static void main(String args[]) {
        Test test=new Test();
        System.out.println(test.aString);//null
        
    }
}

6. 构造器初始化

无法阻止自动化初始化的执行，它将在构造器被调用之前发生。比如：

public class Counter{

     int i;

     Counter() {i=7;}

}

    那么i首先会被置0，然后变成7。对于所有基本类型和对象引用，包括在定义时已经指定初值的变量，这种情况都是成立的；因此，编译器不会强制你一定要在构造器的某个地方或在使用它们之前对元素进行初始化-----因为初始化早已经得到了保证。

（1）初始化顺序

在类的内部，变量定义的先后顺序决定了初始化顺序。即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。比如：

public class Window {
    public Window(int marker) {
        System.out.println("Window("+marker+")");
    }
}

public class House {
    Window w1=new Window(1);
    public House() {
        System.out.println("House()");
        w3=new Window(33);
    }
    Window w2=new Window(2);
    void f(){
        System.out.println("f()");
    }
    Window w3=new Window(3);
}

public class Test {
    public static void main(String args[]) {
        House house=new House();
        house.f();
    }
}

Window(1)
Window(2)
Window(3)
House()
Window(33)
f()

 （2）静态数据的初始化

无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。

public class Bowl {
    public Bowl(int marker) {
        System.out.println("Bowl("+marker+")");
    }
    void f1(int marker) {
        System.out.println("f1("+marker+")");
    }
}

public class Table {
    static Bowl bowl1=new Bowl(1);
    public Table() {
        System.out.println("Table()");
        bowl1.f1(1);
    }
    void f2(int marker) {
        System.out.println("f2("+marker+")");
    }
    static Bowl bowl2=new Bowl(2);
}

public class Cupboard {
    Bowl bowl3=new Bowl(3);
    static Bowl bowl4=new Bowl(4);
    public Cupboard() {
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }
    void f3(int marker) {
        System.out.println("f3("+marker+")");
    }
    static Bowl bowl5=new Bowl(5);
}

public class Test {
    public static void main(String args[]) {
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }
    static Table table=new Table();
    static Cupboard cupboard=new Cupboard();
}

Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)

（3）静态代码块

和其它静态初始化动作一样，静态代码块只执行一次：当首次生成这个类的一个对象时，或者首次访问属于那个类的静态数据成员时（即便从未生成过那个类的对象）。比如：

public class Cup {
    public Cup(int marker) {
        System.out.println("Cup("+marker+")");
    }
    void f(int marker) {
        System.out.println("f("+marker+")");
    }

}

public class Cups {
    static Cup cup1;
    static Cup cup2;
    static {
        cup1=new Cup(1);
        cup2=new Cup(2);
    }
    public Cups() {
        System.out.println("Cups()");
    }

}


public class Test {
    public static void main(String args[]) {
        System.out.println("Inside main");
        Cups.cup1.f(99);
    }
    static Cups cups1=new Cups();
    static Cups cups2=new Cups();
}

Cup(1)
Cup(2)
Cups()
Cups()
Inside main
f(99)

（4）普通代码块 和 静态代码块

相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，

　　　　一般在代码块中对一些static变量进行赋值。

不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。

　　　　静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new

　　　　一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。

package b;

public class Cups {
    public Cups() {
        System.out.print("默认构造方法！-->");
    }

    // 非静态代码块
    {
        System.out.print("非静态代码块！-->");
    }

    // 静态代码块
    static {
        System.out.print("静态代码块！-->");
    }

    public static void test() {
        {
            System.out.println("普通方法中的代码块！");
        }
    }
}

public class Test {
    /**
     * 区别两次new静态与非静态代码块执行情况
     */
    public static void main(String[] args) {
        Cups c1 = new Cups();
        c1.test();

        Cups c2 = new Cups();
        c2.test();
    }
}

静态代码块！-->非静态代码块！-->默认构造方法！-->普通方法中的代码块！
非静态代码块！-->默认构造方法！-->普通方法中的代码块！

7.继承与初始化

public class Insect {
    private int i=9;
    protected int j;
    public Insect() {
        System.out.println("i="+i+",j="+j);
        j=39;
    }
    private static int x1=printInit("static Insect.x1 initialized");
    static int printInit(String s) {
        System.out.println(s);
        return 47;
    }
}

public class Beetle extends Insect{
    private int k=printInit("Beetle.k initialized");
    public Beetle() {
        System.out.println("k="+k);
        System.out.println("j="+j);
    }
    private static int x2=printInit("static Beetle.x2 intialized");
    public static void main(String args[]) {
        System.out.println("Beetle Constructor");
        Beetle beetle=new Beetle();
    }

}

static Insect.x1 initialized
static Beetle.x2 intialized
Beetle Constructor
i=9,j=0
Beetle.k initialized
k=47
j=39

二. 在构造器中调用方法----易混淆

         在构造器没有完成初始化，而这个构造器里面又调用了方法，这会造成一些不好的设计现象。应该尽量避免此类发生。

       先看以下实例，从而更好的理解：

package com.test.c;

public abstract class A {
    public A()
    {
        print();
    }
    public abstract void print();

}

package com.test.c;

public class B extends A{
    public int a=3;

    public void print() {
        System.out.println(a);
        
    }
    public static void main(String args[])
    {
        B b=new B();
        b.print();
    }
    

}

输出：

     0

     3

分析：

在类的初始化时，jvm会先给对象分配一块空间，所有的成员都被暂时赋值为0，对象引用赋值为null，这时int值还是0，然后从基类开始调用构造方法，在基类的构造方法中，调用了print()方法，注意此时调用的print()是导出类的方法。

看似是调用了基类的print（）的方法，其实是调用了自身的方法，调用某类的方法是需要该类的实例，但导出类中根本没有基类的实例成员。 
在完成基类构造方法的调用之前，导出类的其他成员都不会初始化，此时int值是0，所以最终先输出：0 
完成基类构造方法调用后，然后进行自身的成员变量的初始化，这时int值被赋为3。然后调用自身的构造方法，在构造方法里调用了重写的抽象方法print()，所以此时再输出：3

 三. 重要知识点

1. 为何基类构造器总会被先调用？

构造器是为了初始化才会有的。
什么是初始化？就是说一些准备工作，我有那些属性、方法，
子类继承父类就是要使用父类里的东西（属性、方法），但是怎么才能知道父类里有什么呢？
那就要先把父类初始化一下，然后父类就具有了相应的属性和方法。
父类初始化完成了，表示具有一些东西了，这时候，子类才会初始化自己。

 2. static final变量和static变量的区别？

前者不会引起类加载，后者会引起类加载

public class Person {
    public int a=1;
    public static int b=2;
    public final static int c=3;
    static {
        System.out.println("hello");
    }

}


public class Test2 {
    public static void main(String args[]) {
//        System.out.println(Person.b);//print hello, 2,static导致了类加载
        System.out.println(Person.c);//print 3,final staitc不会导致类加载
    
    }

}

 3. 哪些操作会造成类加载初始化？

 4. 总结所有的初始化顺序：

静态变量-->静态代码块-->普通代码块-->构造器

public class Base {
    public Base() {
        System.out.println("this is constructor");
    }
    public int a=1;
    public static int b=2;
    public final static int c=3;
    {
        System.out.println("ha"+b);
        System.out.println("ha"+c);
        
    }
    static {
        System.out.println("hello"+b);//静态代码块里面不能调用非静态变量或方法
        System.out.println("hello"+c);
    }

    
}

public class Test {
    public static void main(String args[]) {
        Base base=new Base();
        Base base2=new Base();
    }
}

//静态变量-->静态代码块-->普通代码块-->构造器
//hello2
//hello3
//ha2
//ha3
//this is constructor
//ha2
//ha3
//this is constructor

参考文献：

thinking in java