1)String类能否被继承?
Sting是这样定义的:public final class String extends Object,里边有final关键字,所以不能被继承。
2)关于静态初始化的考题
在初始化阶段,Java虚拟机执行类的初始化语句,为类的静态变量赋予初始值。
在类被加载进来后,在链接的准备阶段,JVM会为该类所有的类变量(static 变量)分配内存,并设置初始化默认值,比如对象=null, int =0啥的。
在程序中,静态变量的初始化有两种途径:
1.在静态变量的声明处进行初始化;
2.在静态代码块中进行初始化。
初始化执行顺序是按它们在类文件中出现的顺序来决定的,例子如下:
在位置1(第一条语句),这个会导致mInstance在JVM对类的初始化阶段,就会去通过调用类的构造器去创建一个Singleton对象,
给人一种对象构造先于静态初始化的感觉,其实还是遵守向静态初始化,后对象初始化的顺序。
在构造完mInstance对象后,再去初始化counter1 和 counter2.
注意:在这种情况下,Singleton构造器先于静态初始化代码被调用,要注意该Singleton构造器不能使用后面尚未完成初始化的静态变量(比如counter1 ),否则就可能引起错误。
private static Singleton mInstance = new Singleton();// 位置1
package com.mengdd.classloader;
class Singleton {
// private static Singleton mInstance = new Singleton();// 位置1
// 位置1输出:
// counter1: 1
// counter2: 0
public static int counter1;
public static int counter2 = 0;
private static Singleton mInstance = new Singleton();// 位置2
// 位置2输出:
// counter1: 1
// counter2: 1
private Singleton() {
counter1++;
counter2++;
}
public static Singleton getInstantce() {
return mInstance;
}
}
public class Test1 {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstantce();
System.out.println("counter1: " + Singleton.counter1);
System.out.println("counter2: " + Singleton.counter2);
}
}
可见将生成对象的语句放在两个位置,输出是不一样的(相应位置的输出已在程序注释中标明)。
这是因为初始化语句是按照顺序来执行的。
结论:
静态变量的声明语句,以及静态代码块都被看做类的初始化语句,Java虚拟机会按照初始化语句在类文件中的先后顺序来依次执行它们。
类的初始化步骤
1.假如这个类还没有被加载和连接,那就先进行加载和连接。
先初始化直接的父类。
依次执行这些初始化语句。
类的初始化时机
Java程序对类的使用方式可以分为两种:
1.主动使用
2.被动使用
首次主动使用时才初始化它们。
主动使用的六种情况:
1.创建类的实例。
new Test();
2.访问某个类或接口的静态变量,或者对该静态变量赋值。
int b = Test.a;
Test.a = b;
3.调用类的静态方法
Test.doSomething();
4.反射
Class.forName(“com.mengdd.Test”);
5.初始化一个类的子类
class Parent{
}
class Child extends Parent{
public static int a = 3;
}
Child.a = 4;
6.Java虚拟机启动时被标明为启动类的类
java com.mengdd.Test
除了以上六种情况,其他使用Java类的方式都被看作是对类的被动使用,都不会导致类的初始化。
接口的特殊性
这条规则并不适用于接口。
在初始化一个类时,并不会先初始化它所实现的接口。
在初始化一个接口时,并不会先初始化它的父接口。
因此,一个父接口并不会因为它的子接口或者实现类的初始化而初始化,只有当程序首次使用特定接口的静态变量时,才会导致该接口的初始化。
final类型的静态变量
final类型的静态变量是编译时常量还是变量,会影响初始化语句块的执行。
如果一个静态变量的值是一个编译时的常量,就不会对类型进行初始化(类的static块不执行);
如果一个静态变量的值是一个非编译时的常量,即只有运行时会有确定的初始化值,则就会对这个类型进行初始化(类的static块执行)。
例子代码:
package com.mengdd.classloader;
import java.util.Random;
class FinalTest1 {
public static final int x = 6 / 3; // 编译时期已经可知其值为2,是常量
// 类型不需要进行初始化
static {
System.out.println("static block in FinalTest1");
// 此段语句不会被执行,即无输出
}
}
class FinalTest2 {
public static final int x = new Random().nextInt(100);// 只有运行时才能得到值
static {
System.out.println("static block in FinalTest2");
// 会进行类的初始化,即静态语句块会执行,有输出
}
}
public class InitTest {
public static void main(String[] args) {
System.out.println("FinalTest1: " + FinalTest1.x);
System.out.println("FinalTest2: " + FinalTest2.x);
}
}
主动使用的归属明确性
只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时,才可以认为是对类或接口的主动使用。
package com.mengdd.classloader;
class Parent {
static int a = 3;
static {
System.out.println("Parent static block");
}
static void doSomething() {
System.out.println("do something");
}
}
class Child extends Parent {
static {
System.out.println("Child static block");
}
}
public class ParentTest {
public static void main(String[] args) {
System.out.println("Child.a: " + Child.a);
Child.doSomething();
// Child类的静态代码块没有执行,说明Child类没有初始化
// 这是因为主动使用的变量和方法都是定义在Parent类中的
}
}
ClassLoader类
调用ClassLoader类的loadClass()方法加载一个类,并不是对类的主动使用,不会导致类的初始化。
package com.mengdd.classloader;
class CL {
static {
System.out.println("static block in CL");
}
}
public class ClassLoaderInitTest {
public static void main(String[] args) throws Exception {
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> clazz = loader.loadClass("com.mengdd.classloader.CL");
// loadClass方法加载一个类,并不是对类的主动使用,不会导致类的初始化
System.out.println("----------------");
clazz = Class.forName("com.mengdd.classloader.CL");
}
}