Java中类的执行顺序
目录标题
- 变量的分类
-
- 按数据类型分类
- 按声明的位置分类
- 成员变量 （属性）VS 局部变量
- 类变量（静态变量）
- 常量
- JVM一个类的加载过程？
- 一个类被初始化的过程？
- 创建一个对象时，发生了什么。
-
- 1.静态代码
- 2.非静态代码
- 3.静态代码和非静态代码同时存在
- 4.继承
- 5.属性赋值的顺序
- 总结
变量的分类
按数据类型分类
基本数据类型对应的包装类
按声明的位置分类
成员变量 （属性）VS 局部变量
1.相同点：
-
1.1 定义变量的格式：数据类型 变量名 = 变量值 1.2 先声明，后使用 1.3 变量都其对应的作用域
2.不同点：
-
2.1 在类中声明的位置的不同 属性：直接定义在类的一对{}内 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量 -
2.2 关于权限修饰符的不同 属性：可以在声明属性时，指明其权限，使用权限修饰符。 常用的权限修饰符：private、public、缺省、protected --->封装性 目前，大家声明属性时，都使用缺省就可以了。 局部变量：不可以使用权限修饰符。 -
2.3 默认初始化值的情况： 属性：类的属性，根据其类型，都默认初始化值。 整型（byte、short、int、long：0） 浮点型（float、double：0.0） 字符型（char：0 （或'\u0000'）） 布尔型（boolean：false） 引用数据类型（类、数组、接口：null） 局部变量：没默认初始化值。 意味着，我们在调用局部变量之前，一定要显式赋值。 特别地：形参在调用时，我们赋值即可。 -
2.4 在内存中加载的位置： 属性：加载到堆空间中 （非static） 局部变量：加载到栈空间
类变量（静态变量）
static:静态的
1.可以用来修饰的结构：主要用来修饰类的内部结构
属性、方法、代码块、内部类
2.static修饰属性：静态变量（或类变量）
-
2.1 属性，是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量) 实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。 -
2.2 static修饰属性的其他说明： ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用 ② 静态变量的加载要早于对象的创建。 ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。 ④ 类变量 实例变量 类 yes no 对象 yes yes -
2.3 静态属性举例：System.out; Math.PI;
常量
final：最终的
1.可以用来修饰：类、方法、变量
2.具体的：
-
2.1 final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类 -
2.2 final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass(); -
2.3 final 用来修饰变量：此时的"变量"就称为是一个常量
1. final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
2. final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final 用来修饰属性：全局常量
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发方法，静态代码块和静态成员变量的执行顺序是由代码位置决定的，谁写前面就先执行谁。
先执行静态代码，后执行main方法
public class Son{
static {
System.out.println("执行静态代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
静态变量和静态代码块按顺序执行
public class Main {
private static Person person = new Person();
static {
System.out.println("执行静态代码块");
}
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
class Person {
public Person() {
System.out.println("静态成员变量");
}
}
class Son {
static {
System.out.println("执行静态代码块");
}
private static Person person = new Person();
public static void main(String[] args) {
System.out.println("执行main()方法");
}
}
class Person {
public Person() {
System.out.println("静态成员变量");
}
}
类中定义静态成员变量对象，会先创建对象
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("成员变量");
}
}
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("执行成员变量");
}
}
创建多少个对象，就会执行多少次代码块，创建多少个成员变量。非静态代码块和非静态成员变量的执行顺序是由代码位置决定的，谁写前面谁先执行。
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();
Son son2 = new Son();
}
}
class Person {
public Person() {
System.out.println("执行成员变量");
}
}
3.静态代码和非静态代码同时存在
静态属于类，所以叫类变量，类方法，类代码块。非静态属于对象，成员变量，实列变量，方法。
先执行静态代码（只执行一次），再执行非静态代码（创建几个对象执行几次）。
static修饰的变量或代码块或方法类中只有一份（放在元空间里），所以每个对象用的也是同一份，不加static修饰的代码每个对象各有一份（放在栈里）。
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();
//new Leaf();
}
}
1、首先加载Root，则Root中的静态代码和静态成员变量会优先执行（按顺序）。
2、加载Mid，则Mid中的静态代码块和静态成员变量会优先执行。
3、加载Leaf，则Leaf中的静态代码块和静态成员变量会优先执行。
4、类加载完成之后，创建对象，先创建Root对象，创建对象前，先创建对象的资源。
5、执行Root构造器，完成对象创建。
6、创建Mid对象前，先创建对象的资源。
7和8、创建Mid构造器，完成对象创建。
9、创建Leaf对象前，先创建对象的资源。
10、执行Leaf构造器，完成对象创建。
5.属性赋值的顺序
-
①默认初始化
-
②显式初始化/⑤在代码块中赋值（按顺序判断是2还是5）
-
③构造器中初始化
-
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
-
执行的先后顺序：① - ② / ⑤ - ③ - ④
总结
由父及子，静态先行。main方法后，对象实例化时，先创建对象的资源（非静态代码块和非静态变量），然后构造器。
父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器