Java中类的执行顺序
Java中类的执行顺序
文章目录
- Java中类的执行顺序
-
- 一、JVM一个类的加载过程？
- 二、一个类被初始化的过程？
-
- 1.静态代码
- 2.非静态代码
- 3.静态代码和非静态代码同时存在
- 4.继承执行顺序
- 5.继承以及多态的金典例题
一、JVM一个类的加载过程？
一个类从加载到jvm内存，到从jvm内存卸载，它的整个生命周期会经历7个阶段：
1、加载（Loading）
2、验证（Verification）
3、准备（Preparation）
4、解析（Resolution）
5、初始化（Initialization）
6、使用（Using）
7、卸载（Unloading）
其中验证、准备、解析三个阶段统称为连接（Linking）；
加载：classpath、jar包、网络、某个磁盘位置下的类的class二进制字节流读进来，在内存中生成一个代表这个类的java.lang.Class对象放入元空间（方法区，永久代），此阶段我们程序员可以干预，我们可以自定义类加载器来实现类的加载；
验证：验证Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证虚拟机的安全；准备：类变量赋默认初始值，int为0，long为0L，boolean为false，引用类型为null；常量赋正式值；
解析：把符号引用翻译为直接引用；
初始化：当我们new一个类的对象，访问一个类的静态属性，修改一个类的静态属性，调用一个类的静态方法，用反射API对一个类进行调用，初始化当前类，其父类也会被初始化… 那么这些都会触发类的初始化；
使用：使用这个类；
卸载：
1.该类所有的实例都已经被GC，也就是JVM中不存在该Class的任何实例；
2.加载该类的ClassLoader已经被GC；
3.该类的java.lang.Class 对象没有在任何地方被引用，如不能在任何地方通过反射访问该类的方法；
二、一个类被初始化的过程？
类的初始化阶段，Java虚拟机才真正开始执行类中编写的Java程序代码；
进行准备阶段时，变量已经赋过一次系统要求的初始零值，而在初始化阶段，才真正初始化类变量和其他资源；
创建一个对象时，发生了什么？
1.静态代码
静态代码的执行一定先于main发方法，静态代码块和静态成员变量的执行顺序是由代码位置决定的，谁写前面就先执行谁。
（1）先执行静态代码，后执行main方法
public class Son{
static {
System.out.println("执行静态代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
（2）静态变量和静态代码块按顺序执行
public class Son{
private static int i=print("i");
static {
System.out.println("执行静态代码块");
}
public static int print(String str){
System.out.println(str);
return 1;
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
调换顺序之后：
结论：静态类变量和静态代码块的执行顺序是按照代码顺序
（3）类中定义静态成员变量对象，会先创建对象
class Son {
private static Person person = new Person();//person是成员变量对象
static {
System.out.println("执行静态代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
class Person {
public Person() {
System.out.println("静态成员变量");
}
}
2.非静态代码
只有在创建Son对象的时候，才会执行非静态代码和非静态成员变量
class Son {
private Person person = new Person();//person是成员变量对象
{
System.out.println("执行代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
class Person {
public Person() {
System.out.println("成员变量");
}
}
package javabase.test1;
class Son {
private Person person = new Person();//person是成员变量对象
{
System.out.println("执行代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
Son son = new Son();
}
}
class Person {
public Person() {
System.out.println("执行成员变量");
}
}
3.静态代码和非静态代码同时存在
静态属于类，所以叫类变量，类方法，类代码块。非静态属于对象，成员变量，实列变量，方法。
先执行静态代码（只执行一次），再执行非静态代码（创建几个对象执行几次）。
static修饰的变量或代码块或方法类中只有一份（放在元空间里），所以每个对象用的也是同一份，不加static修饰的代码每个对象各有一份（放在栈里）。
package javabase.test1;
class Son {
private static Person person1 = new Person();//person是成员变量对象
private Person person2 = new Person();//person是成员变量对象
static {
System.out.println("执行静态代码块");
}
{
System.out.println("执行代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
Son son = new Son();
Son son2 = new Son();
}
}
class Person {
public Person() {
System.out.println("执行成员变量");
}
}
4.继承执行顺序
实例化子类对象时，涉及到父类、子类中静态代码块、非静态代码块、构造器的加载顺序：
class Root {
private String s1 = "成员变量";
private static String s2 = "成员变量";
static {
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root() {
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root {
static {
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid() {
//super();省略了super()
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg) {
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："
+ msg);
}
}
class Leaf extends Mid {
static {
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf() {
//通过super调用父类中有一个字符串参数的构造器
super("msg");
System.out.println("Leaf的构造器");
}
}
public class LeafTest {
public static void main(String[] args) {
new Leaf();
}
}
5.继承以及多态的金典例题
子类能调用起来的方法包括：本身的方法和所继承父类的方法
输出：
package com.oop.duotai;
public class Test {
public static void main(String[] args) {
A a1=new A();
A a2=new B();
B b=new B();
C c=new C();
D d=new D();
System.out.println("1---------"+a1.show(b)); //A and A
System.out.println("2---------"+a1.show(c)); //A and A
System.out.println("3---------"+a1.show(d)); //A and D
System.out.println("4---------"+a2.show(b)); //B and A 多态，此时看着是A类型，b自动转为A类型，但是show已经被重写，所以调用子类的方法 B and A
System.out.println("5---------"+a2.show(c)); //B and A 多态，此时看着是A类型，c自动转为A类型，但是show已经被重写，所以调用子类的方法 B and A
System.out.println("6---------"+a2.show(d)); //A and D
System.out.println("7---------"+b.show(b)); //B and A //b能调用起来的方法包括：本身和父类的方法
System.out.println("8---------"+b.show(c)); //B and A
System.out.println("9---------"+b.show(d)); //A and D
//8-------b此时继承了A的方法，public String show(Object obj)这个方法子类特有，并不是父类继承的，所以调用了父类的方法String show(D obj)
}