在一个类中有静态代码块，构造代码块，有默认值，有构造函数，且它们都为类的成员变量做了赋值操作，而在创建对象的时候也为对象做了赋值 。
我知道结果肯定是创建对象的时候也为对象做了赋值
可我有点迷糊它们在给类的成员变量做赋值操作的先后顺序？求解！

1.静态代码块
2.默认初始化
3.构造代码块
4.构造方法

这是我学习时自己整理后截的图它们的流程图里很清楚了

在给你加点料，呵呵，我想你应该还不是很清楚
构造代码块运行顺序

1. //静态代码块先执行，构造代码块执行，对象内执行
   
2. class person
   
3. {
   
4.         //静态代码块先执行，构造代码块执行，对象内执行
   
5.         person()
   
6.         {
   
7.                 System.out.println("构造函数3");
   
8.         }
   
9.         static
   
10.         {
    
11.                 System.out.println("静态代码块1");
    
12.         }
    
13.        
    
14.         {
    
15.                 System.out.println("构造代码块2");
    
16.         }
    
17.        
    
18.        
    
19. }
    
20. public class personDemo2
    
21. {
    
22.         public static void main(String[] args)
    
23.         {
    
24.                 person p =new person();
    
25.         }
    
26. }
    
27. 执行结果：打印
    
28. 静态代码块1
    
29. 构造代码块2
    
30. 构造函数3
    

复制代码

1. class Persons {
   
2.         String Str1="name";
   
3.         static String Str2="Str2";
   
4.         Persons()
   
5.         {
   
6.                 Str1+="构造函数";
   
7.                 Str2+="构造函数";
   
8.                 System.out.println("构造函数");
   
9.         }
   
10.         static
    
11.         {
    
12.                 Str2+="静态代码块";//静态代码块中只能给静态变量赋值
    
13.                 System.out.println("静态代码块");
    
14.         }
    
15.         {
    
16.                 Str1+="构造代码块";
    
17.                 Str2+="构造代码块";
    
18.                 System.out.println("构造代码块");
    
19.         }
    
20. 
    
21. }
    
22. class personDemo
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26.                 Persons p=new Persons();
    
27.                 System.out.println(p.Str1);
    
28.                 System.out.println(Persons.Str2);
    
29.         }
    
30. }

复制代码

运行结果：

静态代码块
构造代码块
构造函数
name构造代码块构造函数
Str2静态代码块构造代码块构造函数

代码的执行顺序为：静态代码块，构造代码块，构造函数

这个不得不说在毕老师的基础视频里讲解的很详细，总结如下：

class Person
{
        private String name;
        private int age;
        private static  String country = "cn";
        Person(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
       
        {
                System.out.println(name+".."+age);
        }
        public void setName(String name)
        {
                this.name = name;
        }

        public void speak()
        {
                System.out.println(this.name+"..."+this.age);
        }

        public static void  showCountry()
        {
                System.out.println("country="+country);
        }
}

class  PersonDemo
{
        public static void main(String[] args)
        {
                Person p = new Person("zhangsan",20);
        }
}


/*
Person p = new Person("zhangsan",20);

该句话都做了什么？
1、因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中；
2、执行该类中的static代码块（静态代码块），如果有的话，给Person.class类进行初始化；
3、在堆内存中开辟空间，分配内存地址；
4、在堆内存中建立对象的特有属性，并进行默认初始化；
5、对属性进行显示初始化；
6、对对象进行够早代码块初始化；
7、对对象进行对应的构造函数初始化；
8、将内存地址付给栈内存中的P变量。
*/

谢谢各位大侠！哦明白了！