题记:以前总是对不会的东西逃避,但是不会早晚有一天还是会找到你,今天以此笔记做记!分析两种情况的加载顺序,一种:单独类的加载顺序。二:子类继承父类的加载顺序一:单独类的加载顺序静态变量、静态代码块(从上到下的顺序加载)类的非静态变量,非静态块(从上到下的顺序加载)构造函数二:子类继承父类的加载顺序父类静态变量、父类静态代码块(从上到下的顺序加载)子类静态变量、子类静态代码块(从上到下的顺序加载)父            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-11-23 14:56:19
                            
                                38阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            类加载加载过程:加载,验证,准备,解析,初始化,过程交叉执行,例如先验证class字节流是否符合规范,属于验证,验证通过后再加载到方法区,形成一种特殊的数据结构,这是属于加载,然后对数据结构验证是否符合Java语言规范,验证语义是否会对虚拟机造成危害,验证是否指针地址等等。此处的加载和验证交叉进行。其它过程也存在交叉。准备阶段,为静态变量开辟空间保存,赋值初值0,false,null。解析,字面量            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-29 19:22:18
                            
                                61阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            最近在总结一些和JVM相关的知识,现在总结一下关于父类和子类加载顺序的问题。简而言之就是先静态后非静态,先父类后子类,具体顺序如下:
1. 父类静态变量
2. 父类静态代码块(若有多个按代码先后顺序执行)
3. 子类静态变量
4. 子类静态代码块(若有多个按代码先后顺序执行)            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-19 09:59:32
                            
                                110阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            类加载执行顺序:public class ClassLoaderOrder {
	public static void main(String[] args) {
		new Child();
	}
}
class Base{
	public static String str = "父类静态全局属性";
	public String str1 = "父类普通全局属性";
	static{            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-23 10:41:44
                            
                                84阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                                                                    &nbs            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-18 11:14:47
                            
                                41阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1. 类加载和类加载器介绍 2. 父类和子类加载顺序及实际案例 3. 子类父类加载顺序面试            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                            精选
                                                        
                            2023-03-14 16:35:35
                            
                                354阅读
                            
                                                        
                                点赞
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            直接上代码:代码1:  public class ConstroctTest {
    private static ConstroctTest test = new ConstroctTest();
    //静态变量sta1    未赋予初始值
    public static int sta1;
    //静态变量sta1    赋予初始值20
    public static i            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-27 11:09:45
                            
                                32阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            # Java中子类父类的加载顺序
在Java中,类的加载顺序涉及父类与子类之间的关系,这对于理解Java的类加载机制和构造函数的执行顺序至关重要。文章将通过代码示例以及解释来帮助大家更好地理解这一概念。
## 类加载的基本概念
Java中的类加载指的是将类的字节码读入内存,并为其创建Class对象的过程。类加载通常发生在程序运行时,遵循以下几个阶段:
1. **加载** - 将类的字节码读            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2024-08-08 16:33:34
                            
                                76阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            ## Java子类父类main加载顺序解析
### 流程图
```mermaid
stateDiagram
    [*] --> Subclass
    Subclass --> Superclass
    Superclass --> Main
```
### 步骤
| 步骤 | 描述 |
| --- | --- |
| 1 | 子类加载 |
| 2 | 父类加载 |
| 3 |            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2024-03-27 05:13:47
                            
                                28阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            父的成员变量->构造方法->子的成员变量->子的构造方法
注意 如果父亲的构造方法中有被子类覆盖的init方法,当调用init方法的时候由于子的成员变量还未赋值,所以init中使用已经定义的成员变量进行操作是不正确的,把成员 new出来当然没问题啦。
使用子的定义的函数当然没关系啦,因为函数是被声明的的。 声明的可以拿来new 赋值,未被初始化的定义不能用的。/* &n            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-08 14:59:41
                            
                                32阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            复制代码 代码如下:class Parent {
// 静态变量
public static String p_StaticField = "父类--静态变量";
// 变量(其实这用对象更好能体同这一点,如专门写一个类的实例)
//如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化
public String p_Field = "父类--变量";
// 静态初始化块
stati            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-01 18:20:50
                            
                                32阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            class Parent {
    // 静态变量
    public static String p_StaticField = "父类--静态变量";
    // 变量(其实这用对象更好能体同这一点,如专门写一个类的实例)
  
    //如果这个变量放在初始化块的后面,是会报错的,因为你根本没有被初始化
    public String p_Field = "父类--变量";            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-22 12:34:16
                            
                                93阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            有个朋友在CSDN评论区问我,java子类和父类初始化时各个代码块的执行顺序,我本来写好了一大段回复,点击发表回复,结果没有回复成功,我写的评论也不见了。。。csdn的评论区编辑体验本来就不好,然后还有这种回复失败的问题,这体验真是一言难尽,干脆再写一篇文章,从字节码层面来看这个顺序问题,希望可以帮到更多朋友。吐槽完毕,回归正题。要明白子类和父类的初始化执行顺序,只需要知晓以下三点,就不会再弄错了            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-24 19:34:55
                            
                                77阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            本文主要通过代码的实现,来研究下载Java中,继承的时候,父类和子类中代码的加载顺序。一,无继承的时候: 首先我们先写几个类,其中类ClassA作为测试主体。// 1,对象类,测试主体
public class ClassA {
//	public static  ClassA classa = new ClassA();
		
	static{
        System.out.p            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-10 08:10:17
                            
                                31阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            什么时候类加载 
第一次需要使用类信息时加载。类加载的原则:延迟加载,能不加载就不加载。 
触发类加载的几种情况: 
(1)、调用静态成员时,会加载静态成员真正所在的类及其父类。通过子类调用父类的静态成员时,只会加载父类而不会加载子类。(2)、第一次 new 对象的时候 加载(第二次再 new 同一个类时,不需再加载)。(3)、加载子类会先加载父类。(覆盖父类方法时所抛出的异常不能超过父类定义的范            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-01-17 15:25:30
                            
                                51阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            C#构造函数里的base和this的区别  关于静态构造函数、构造函数的题,写出下面程序的输出结果
class A
{
 static A()
 {
     Console.WriteLine("A静态构造函数");
 }
 public A()
 {
     Console.WriteLine("A构造函数");
     fun1();
 }
 public virtual void fu            
                
         
            
            
            
            super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。super也有三种用法:1.普通的直接引用与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。2.子类中的成员变量或方法与父类中的成员变量或方法同名  class Country {
    String name;
    void value() {            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-21 23:56:39
                            
                                100阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            先写了四个类,很简单的类:目标是测试类的静态变量初始化,静态代码调用,成员变量初始化,构造函数调用的先后顺序。// 辅助输出类public class Print {
public Print(String str) {
System.out.println(str);
}
}// 接口类public interface InterfaceDemo {
Object so1 = new Print            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-26 20:36:48
                            
                                32阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1.类的加载机制类的加载机制:将编译之后对应的.class文件加载进内存中,并对数据进行校验,解析和初始化,最终形成可被虚拟机直接使用的Java类型。类加载总共有七个步骤: 装载(加载)–>验证–>准备–>解析–>初始化–>使用–>卸载2.类中的成员Java类中的类成员包括:属性,方法,代码块,构造器,内部类 属性,方法,代码块由是否有static修饰分为静态和            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-19 09:56:31
                            
                                213阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1、一般来说,类的代码在初次使用时被加载。通常指创建第一个对象时(构造器其实也是static方法),或者访问类的static域或static方法时会发生加载。2、当类加载器开始加载第一个类的过程中如果发现该类具有基类它将继续进行加载,直至所有的基类被加载完成3、然后根基类的static初始化会被执行,然后是下一个导出类static域,以此类推,直至所有相关类的static域加载初始化完成。4、至此            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-19 21:32:03
                            
                                70阅读