java机制:类的加载详解(静态类,静态变量,静态方法,静态代码块,构造代码块,成员变量,成员方法,父类...)
“代码编译的结果从本地机器码转变为字节码，是存储格式发展的一小步，却是变成语言发展的一大步”，这句话出自《深入理解JAVA虚拟机》
一.源码编译
代码编译由JAVA源码编译器来完成。主要是将源码编译成字节码文件（class文件）。字节码文件格式主要分为两部分：常量池和方法字节码。
二.类的加载
类的生命周期是从被加载到虚拟机内存中开始，到卸载出内存结束。过程共有七个阶段，其中到初始化之前的都是属于类加载的部分.
加载----验证----准备----解析-----初始化----使用-----卸载
系统可能在第一次使用某个类时加载该类，也可能采用预加载机制来加载某个类，当运行某个java程序时，会启动一个java虚拟机进程，两次运行的java程序处于两个不同的JVM进程中，两个jvm之间并不会共享数据。
1、加载阶段
这个流程中的加载是类加载机制中的一个阶段，这两个概念不要混淆，这个阶段需要完成的事情有：
1）通过一个类的全限定名来获取定义此类的二进制字节流。
2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3）在java堆中生成一个代表这个类的Class对象，作为访问方法区中这些数据的入口。
由于第一点没有指明从哪里获取以及怎样获取类的二进制字节流，所以这一块区域留给我开发者很大的发挥空间。这个我在后面的类加载器中在进行介绍。
2、准备阶段
这个阶段正式为类变量（被static修饰的变量）分配内存并设置类变量初始值，这个内存分配是发生在方法区中。
1、注意这里并没有对实例变量进行内存分配，实例变量将会在对象实例化时随着对象一起分配在JAVA堆中。
2、这里设置的初始值，通常是指数据类型的零值。
private static int a = 3;
这个类变量a在准备阶段后的值是0，将3赋值给变量a是发生在初始化阶段。
3、初始化阶段
初始化是类加载机制的最后一步，这个时候才正真开始执行类中定义的JAVA程序代码。在前面准备阶段，类变量已经赋过一次系统要求的初始值，在初始化阶段最重要的事情就是对类变量进行初始化，关注的重点是父子类之间各类资源初始化的顺序。
java类中对类变量指定初始值有两种方式：1、声明类变量时指定初始值；2、使用静态初始化块为类变量指定初始值。
参考 Java中类的加载时机
java虚拟机规范虽然没有强制性约束在什么时候开始类加载过程，但是对于类的初始化，虚拟机规范则严格规定了有且只有四种情况必须立即对类进行初始化，遇到new、getStatic、putStatic或invokeStatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。
生成这4条指令最常见的java代码场景是：
1）使用new关键字实例化对象; 通过反射创建实例Class.forName(“com.mengdd.Test”);
2）读取一个类的静态字段（被final修饰、已在编译期把结果放在常量池的静态字段除外）
3）设置一个类的静态字段（被final修饰、已在编译期把结果放在常量池的静态字段除外）
4）调用一个类的静态方法
验证:
1）当类被初始化时，其静态代码块会执行。
class ClassLoadTime{
static{
System.out.println("ClassLoadTime类初始化时就会被执行！");
}
public ClassLoadTime(){
System.out.println("ClassLoadTime构造函数！");
}
}
class ClassLoadDemo{
public static void main(String[] args){
ClassLoadTime clt = new ClassLoadTime();
}
}
输出结果：
ClassLoadTime类初始化时就会被执行！
ClassLoadTime构造函数！2） 读取一个类的静态字段（被final修饰、已在编译期把结果放在常量池的静态字段除外）
class ClassLoadTime{
static{
System.out.println("ClassLoadTime类初始化时就会被执行！");
}
public static int max = 200; (防止测试类和此类不在一个包，使用public修饰符)
public ClassLoadTime(){
System.out.println("ClassLoadTime构造函数！");
}
}
class ClassLoadDemo{
public static void main(String[] args){
int value = ClassLoadTime.max;
System.out.println(value);
}
}
输出：
ClassLoadTime类初始化时就会被执行！
2003）设置一个类的静态字段（被final修饰、已在编译期把结果放在常量池的静态字段除外）
class ClassLoadTime{
static{
System.out.println("ClassLoadTime类初始化时就会被执行！");
}
public static int max = 200; (防止测试类和此类不在一个包，使用public修饰符)
public ClassLoadTime(){
System.out.println("ClassLoadTime构造函数！");
}
}
class ClassLoadDemo{
public static void main(String[] args){
ClassLoadTime.max = 100;
}
}
输出：
ClassLoadTime类初始化时就会被执行！4）调用一个类的静态方法
class ClassLoadTime{
static{
System.out.println("ClassLoadTime类初始化时就会被执行！");
}
public static int max = 200; (防止测试类和此类不在一个包，使用public修饰符)
public ClassLoadTime(){
System.out.println("ClassLoadTime构造函数！");
}
public static void method(){
System.out.println("静态方法的调用！");
}
}
class ClassLoadDemo{
public static void main(String[] args){
ClassLoadTime.method();
}
}
输出：
ClassLoadTime类初始化时就会被执行！
静态方法的调用！被final修饰静态字段在操作使用时，不会使类进行初始化，因为在编译期已经将此常量放在常量池。
测试：
class ClassLoadTime{
static{
System.out.println("ClassLoadTime类初始化时就会被执行！");
}
public static final int MIN = 10; (防止测试类和此类不在一个包，使用public修饰符)
}
class ClassLoadDemo{
public static void main(String[] args){
System.out.println(ClassLoadTime.MIN);
}
}
输出：
10子类调用或者设置父类的静态字段或者调用父类的静态方法时仅仅初始化父类，而不初始化子类。同样读取final修饰的常量不会进行类的初始化。
class Fu{
public static int value = 20;
static{
System.out.println("父类进行了类的初始化！");
}
}
class Zi{
static{
System.out.println("子类进行了类的初始化！");
}
}
class LoadDemo{
public static void main(String[] args){
System.out.println(Zi.value);
}
}
输出：
父类进行了类的初始化！
20 java类中各种成员的初始化时机，此处不一一测试：
类变量（静态变量）、实例变量（非静态变量）、静态代码块、非静态代码块 的初始化时机：
* 由 static 关键字修饰的（如：类变量[静态变量]、静态代码块）将在类被初始化创建实例对象之前被初始化，而且是按顺序从上到下依次被执行；
public static int value =34;
static{
System.out.println("静态代码块！");
}
public 类名(){
System.out.println("构造函数！");
}
一旦这样写，在类被初始化创建实例对象之前会先初始化静态字段value，然后执行静态代码块，当实例化对象时会执行构造方法中的代码
* 没有 static 关键字修饰的（如：实例变量[非静态变量]、非静态代码块）初始化实际上是会被提取到类的构造器中被执行的，但是会比类构造器中的
代码块优先执行到，其也是按顺序从上到下依次被执行。
public int value =34;
{
System.out.println("非静态代码块！");
}
public 类名(){
System.out.println("构造函数！");
}
在使用构造函数实例化一个对象时，会先初始化value，然后执行非静态代码块，最后执行构造方法里面的代码。
*在存在父类的时候，调用子类的构造时，会先调用父类的默认构造（空参构造），进行父类的初始化。用final修饰某个类变量时，它的值在编译时就已经确定好放入常量池了，所以在访问该类变量时，等于直接从常量池中获取，并没有初始化该类。
初始化的步骤
1、如果该类还没有加载和连接，则程序先加载该类并连接。
2、如果该类的直接父类没有加载，则先初始化其直接父类。
3、如果类中有初始化语句，则系统依次执行这些初始化语句。
在第二个步骤中，如果直接父类又有直接父类，则系统会再次重复这三个步骤来初始化这个父类，依次类推，JVM最先初始化的总是java.lang.Object类。当程序主动使用任何一个类时，系统会保证该类以及所有的父类都会被初始化。
4.Static 类,成员变量,成员方法,代码块,及加载顺序
在《Java编程思想》P86页有这样一段话：
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：
方便在没有创建对象的情况下来进行调用（方法/变量）。
很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
一.Static方法,变量,代码块
1）static方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。举个简单的例子：
在上面的代码中，由于print2方法是独立于对象存在的，可以直接用过类名调用。假如说可以在静态方法中访问非静态方法/变量的话，那么如果在main方法中有下面一条语句：
MyObject.print2();
此时对象都没有，str2根本就不存在，所以就会产生矛盾了。同样对于方法也是一样，由于你无法预知在print1方法中是否访问了非静态成员变量，所以也禁止在静态成员方法中访问非静态成员方法。
而对于非静态成员方法，它访问静态成员方法/变量显然是毫无限制的。
因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。
另外记住，即使没有显示地声明为static，类的构造器实际上也是静态方法。
2）static变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
static成员变量的初始化顺序按照定义的顺序进行初始化。
3）static代码块
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:
class Person{
private Date birthDate;
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
Date startDate = Date.valueOf("1946");
Date endDate = Date.valueOf("1964");
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}
isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和endDate两个对象，造成了空间浪费，如果改成这样效率会更好：
class Person{
private Date birthDate;
private static Date startDate,endDate;
static{
startDate = Date.valueOf("1946");
endDate = Date.valueOf("1964");
}
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}
因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。
4)static class
Java中的类可以是static吗？答案是可以。在java中我们可以有静态实例变量、静态方法、静态块。类也可以是静态的。
java允许我们在一个类里面定义静态类。比如内部类（nested class）。把nested class封闭起来的类叫外部类。在java中，我们不能用static修饰顶级类（top level class）。只有内部类可以为static。
静态内部类和非静态内部类之间到底有什么不同呢？下面是两者间主要的不同。
（1）内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。
（2）非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。
（3）一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。
基于上面的讨论，我们可以通过这些特性让编程更简单、有效。
/* 下面程序演示如何在java中创建静态内部类和非静态内部类 */
class OuterClass{
private static String msg = "GeeksForGeeks";
// 静态内部类
public static class NestedStaticClass{
// 静态内部类只能访问外部类的静态成员
public void printMessage() {
// 试着将msg改成非静态的，这将导致编译错误
System.out.println("Message from nested static class: " + msg);
}
}
// 非静态内部类
public class InnerClass{
// 不管是静态方法还是非静态方法都可以在非静态内部类中访问
public void display(){
System.out.println("Message from non-static nested class: "+ msg);
}
}
}
class Main
{
// 怎么创建静态内部类和非静态内部类的实例
public static void main(String args[]){
// 创建静态内部类的实例
OuterClass.NestedStaticClass printer = new OuterClass.NestedStaticClass();
// 创建静态内部类的非静态方法
printer.printMessage();
// 为了创建非静态内部类，我们需要外部类的实例
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
// 调用非静态内部类的非静态方法
inner.display();
// 我们也可以结合以上步骤，一步创建的内部类实例
OuterClass.InnerClass innerObject = new OuterClass().new InnerClass();
// 同样我们现在可以调用内部类方法
innerObject.display();
}
}二.static关键字的误区
1.static关键字会改变类中成员的访问权限吗？
有些初学的朋友会将java中的static与C/C++中的static关键字的功能混淆了。在这里只需要记住一点：与C/C++中的static不同，Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字。看下面的例子就明白了：
提示错误"Person.age 不可视"，这说明static关键字并不会改变变量和方法的访问权限。
2.能通过this访问静态成员变量吗？
虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？
public class Main {
static int value = 33;
public static void main(String[] args) throws Exception{
new Main().printValue();
}
private void printValue(){
int value = 3;
System.out.println(this.value);
}
}
//----------------------------------------
输出
33这里面主要考察队this和static的理解。this代表什么？this代表当前对象，那么通过new Main()来调用printValue的话，当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，根本不可能与this关联，所以输出结果是33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
3.static能作用于局部变量么？
在C/C++中static是可以作用域局部变量的，但是在Java中切记：static是不允许用来修饰局部变量。不要问为什么，这是Java语法的规定。
三.常见的笔试面试题
下面列举一些面试笔试中经常遇到的关于static关键字的题目，仅供参考，如有补充欢迎下方留言。
1.下面这段代码的输出结果是什么？
public class Test extends Base{
static{
System.out.println("test static");
}
public Test(){
System.out.println("test constructor");
}
public static void main(String[] args) {
new Test();
}
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}
//--------------------------------------------------
输出
base static
test static
base constructor
test constructor至于为什么是这个结果，我们先不讨论，先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。
2.这段代码的输出结果是什么？
public class Test {
Person person = new Person("Test");
static{
System.out.println("test static");
}
public Test() {
System.out.println("test constructor");
}
public static void main(String[] args) {
new MyClass();
}
}
class Person{
static{
System.out.println("person static");
}
public Person(String str) {
System.out.println("person "+str);
}
}
class MyClass extends Test {
Person person = new Person("MyClass");
static{
System.out.println("myclass static");
}
public MyClass() {
System.out.println("myclass constructor");
}
}
//--------------------------------------------------
输出
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor
类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。
3.这段代码的输出结果是什么？
public class Test {
static{
System.out.println("test static 1");
}
public static void main(String[] args) {
}
static{
System.out.println("test static 2");
}
}
//--------------------------------------
输出
test static 1
test static 2虽然在main方法中没有任何语句，但是还是会输出，原因上面已经讲述过了。另外，static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行），并且执行是按照static块的顺序执行的。