重拾java之路-关键字

三、运算

参数传递

Java 参数是以值传递的形式传入方法，而非引用传递。（对于对象，传递的则是引用的地址值）

在方法中改变对象的字段值会改变原始对象的字段值，因为引用的是同一个对象。而如果在方法中将指针引用了其它对象，则该指针作用域仅限于该方法。（这也是Java值传递带来的结果）

public class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        func(dog);
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        System.out.println(dog.getName());          // A
    }

    private static void func(Dog dog) {
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        dog = new Dog("B");
        System.out.println(dog.getObjectAddress()); // Dog@74a14482
        System.out.println(dog.getName());          // B
    }
}

隐式类型转换

Java不能隐式执行向下转型，double类型的字面量1.1是不能直接赋值给float变量的。

short类型使用诸如 += 的运算符，内部会进行隐式类型转换，因此不会报错。

short s = 1;
// s = s + 1; // 会报错
s += 1; // 等价于(short)(s + 1)

四、关键字

final

1.数据

作用于数据上时，声明为常量。
对于基本类型，final使得数值不变。
对于引用类型，final使得引用不变，但是引用的对象本身还是可以修改的（指针）

如果是类的属性（实质也是变量），则初始化不会被隐式赋值，因此需要直接赋值；或者通过构造方法来赋值（如果同时还有static关键字存在，则只能直接赋值），同样也只能进行一次赋值操作。

2.方法

作用于方法上时，声明方法不允许被子类重写。

PS：private方法隐式被指定为final。因此，子类中定义的方法与父类中的private方法相同，此时子类的方法不是重写，而是新的定义。

3.类

作用于类上，声明类不能被继承。

static

1.静态变量

静态变量又称为类变量，由所有实例共享，直接由类名来访问。
PS：静态变量在内存中只存在一份。

与之对应的实例变量则与实例同生死。

public class A {

    private int x;         // 实例变量
    private static int y;  // 静态变量

    public static void main(String[] args) {
        // int x = A.x;  // 实例变量不能使用类名访问
        A a = new A();
        int x = a.x;
        int y = A.y;
    }
}

2.静态方法

静态方法不依赖于任何实例，因此方法中不能出现this与super关键字，同时，也不能是抽象方法。（因为必须有实现）

3.静态语句块

静态语句块只在类初始化的时候运行一次，语句块中的值也是静态常量。

public class A {
	static final int test;
	
    static {
        System.out.println("running only once");
        test = 100;
    }

    public static void main(String[] args) {
        A a1 = new A(); // 静态语句块只在此处运行一次
        A a2 = new A();
        
		System.out.println(A.test);
    }
}

4.静态内部类

非静态内部类需要先创建外部类的实例，才能用实例来创建非静态内部类。静态内部类则可以直接创建实例。

public class OuterClass {

    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass(); // 先创建外部类实例，再利用实例来创建内部类实例
        StaticInnerClass staticInnerClass = new StaticInnerClass(); // 直接创建静态内部类实例
    }
}

5.静态导包

导入静态变量和方法时不用再指明 ClassName，简化代码。

import static java.lang.System.out;

public class StaticImport {
    public static void main(String[] args) {
        out.println("simplify the statement"); // 简化语句
    }

}

6.初始化顺序

静态块（静态变量）–> 实例变量 （匿名块） --> 构造方法 --> 静态方法。

对于静态块，只加载一次（之前也提到过）。
对于构造方法（类似于python中的__init__()方法），每创建一个实例就会加载一次。
对于静态方法，则是需要调用时才会执行。

对于存在继承的情况，初始化顺序如下：

1. 父类（静态变量、静态块）
2. 子类（静态变量、静态块）
3. 父类（实例变量、匿名块）
4. 父类（构造函数）
5. 子类（实例变量、匿名块）
6. 子类（构造函数）