海豹突击队(Navy SEAL)，全称美国海军海豹突击队，是世界十大特种部队之一，SEAL取自Sea(海)、Air(空)、Land(陆)之意。在许多人眼里，最厉害的兵种就是特种兵，而海豹突击队也是世界上最神秘、最具震慑力的特种作战部队之一，各种特殊行动都被当做题材拍成了电影。
2011年5月1日，海豹突击队在得到美国奥巴马总统的命令后，击毙了本拉登，整个行动只持续了40分钟。
今天野要买推荐的是一款美国品牌Vasque的徒步登山靴，5.7折拿下。
在“本拉登行动”中，海豹突击队穿的就是美国本土品牌Vasque的一款靴。
我也很好奇，如此厉害又神秘的海豹突击队，行动时会采用哪些装备？一位前海豹突击队队员，分享了他的经验：“每次行动前，最重要的就是检查自己的装备是否齐全，而其实行动中，每位队员们的装备并不相同”。
No.10 帽子
圆边帽、战术棒球帽、头巾、巴拉克拉瓦盔式帽，根据行动不同选择适合的帽子，但无论哪种行动，帽子是必备。
No.9 战术背心
同样，根据不同行动，战术背心的种类也不同。
No.8 手表
手表是每位队员的必要装备，大多数人选择电子表，行动之前确保电子表静音，并贴一层胶带，确保不发出亮光。
No.7 墨镜
除非雨天，行动时都需要佩戴墨镜，抵挡沙石迷眼、防止强光阻碍射击。
No.6 水袋
水的重要性就不用多说了。
No.5 逃生套装
逃生工具也是每次行动重要的一环，其中包括：信号反光镜、小型滤水器、地图、取火装置、当地货币以及金、银币。
No.4 格斗刀
行动时，没有人离得开一把好刀，不仅因格斗所需，也是生存必备。
No.3 武器和瞄准镜
据说，本拉登就倒在EOTech下(全息瞄准镜，美国品牌，一种直接观察弹着点并用弹着点作为瞄准标志的速瞄瞄具，瞄准快而射击精准，全息瞄准镜采用两点一线瞄准，而不是传统概念的三点一线)。
No.2 战术背包
一定要有一款好的战术背包，以便科学地携带你的所有装备，否则你的装备将会成为行动中的累赘。
No.1 轻装靴
无疑，位列第一的就是保护好双脚，一款好靴子至关重要，如果行动中因足部问题而无法行进，整个任务就无法完成。在“本拉登行动”中，海豹突击队使用的就是 Vasque Juxt Multisport Shoe这款靴子。
今天野心推荐的这款靴
是美国户外品牌Vasque的一款经典防水户外靴。
轻量中帮，牛皮，结实耐用，双密度EVA鞋垫，脚感舒适。
VIBRAM大底耐磨强抓地。
热爱户外活动的朋友都知道，身处有着无限可能的野外，装备就像同行的队友，值得信赖尤其重要。
Navy Seal都信任的品牌，一定是你户外徒步可靠的搭档。

前言
什么情况下会触发类加载的进行呢？本文将结合代码demo谈谈几种情况，希望对大家有帮助。
类加载时机
什么情况需要开始类加载过程的第一阶段：加载？Java虚拟机规范中并没有进行强制约束，这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范则严格规定了以下几种情况必须立即对类进行初始化，如果类没有进行过初始化，则需要先触发其初始化。
创建类的实例
为了验证类加载，我们先配置一个JVM参数
-XX:+TraceClassLoading 监控类的加载复制代码
在IDE配置如下：
demo代码：
运行结果：
结论：
new ClassLoadInstance实例时，发现ClassLoadInstance被加载了，因此 new创建实例对象，会触发类加载进行。
访问类的静态变量
demo代码：
运行结果：
结论：
访问类ClassLoadStaticVariable的静态变量i时，发现ClassLoadStaticVariable类被加载啦，因此访问类的静态变量会触发类加载。
注意：
访问final修饰的静态变量时，不会触发类加载，因为在编译期已经将此常量放在常量池了。
访问类的静态方法
demo代码：
运行结果：
结论：
访问类ClassLoadStaticMethod的静态方法method时，发现ClassLoadStaticMethod类被加载啦，因此访问类的静态方法会触发类加载。
反射
demo代码：
运行结果：
结论：
反射得到类ClassLoadStaticReflect时，发现ClassLoadStaticReflect类被加载啦，因此反射会触发类加载。
当初始化一个类时，发现其父类还未初始化，则先触发父类的初始化
demo代码：
运行结果：
看了运行结果，是不是发现，网上那道经典面试题(讲讲类的实例化顺序？)也很清晰啦。 先父类静态变量/静态代码块-> 再子类静态变量/静态代码块->父类构造器->子类构造器结论：
实例化子类ClassLoadSub的时候，发现父类ClassLoadSuper先被加载，因此当初始化一个类时，发现其父类还未初始化，则先触发父类的初始化
虚拟机启动时，定义了main()方法的那个类先初始化
demo代码：
运行结果：
结论：
虚拟机启动时，即使有ClassLoadSub，ClassLoadSuper，ClassLoadTest等类被加载， 但ClassLoadTest最先被加载，即定义了main()方法的那个类会先触发类加载。
练习与小结
触发类加载的六大时机，我们都分析完啦，是不是不做个题都觉得意犹未尽呢？接下来，我们来分析类加载一道经典面试题吧。
运行结果：
分析：
SingleTon.getInstance()，调用静态方法，触发SingleTon类加载。
SingleTon类加载初始化，按顺序初始化静态变量。
先执行private static SingleTon singleTon = new SingleTon(); ，调用构造器后，count1，count2均为1；
按顺序执行 public static int count1; 没有赋值，所以count1依旧为1；
按顺序执行 public static int count2 = 0;所以count2变为0.
原文：https://juejin.im/post/5d872bdfe51d4561eb0b275b

	

在java中用{}括起来的称为代码块，代码块可分为以下四种：
一.简介
1.普通代码块：
类中方法的方法体
2.构造代码块：
构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。
3.静态代码块：
用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。
4.同步代码块：
使用synchronized(){}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。
二.静态代码块和构造代码块的异同点
相同点：都是JVM加载类后且在构造函数执行之前执行，在类中可定义多个，一般在代码块中对一些static变量进行赋值。
不同点：静态代码块在非静态代码块之前执行。静态代码块只在第一次new时执行一次，之后不在执行。而非静态代码块每new一次就执行一次。
三.示例
普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般语句的执行顺序由他们在代码中出现的次序决定，先出现先执行。
private static Long parseLong(String s) {if ("无".equals(s)) return 0L;        try {return Long.valueOf(s);        } catch (Exception e) {return 0L;        }
    }public class Test {public static void main(String[] args) {
            {int x = 3;                System.out.println("普通代码块内的变量x=" + x);            }int x = 1;            System.out.println("主方法内的变量x=" + x);            {int y = 7;                System.out.println("普通代码块内的变量y=" + y);            }
        }
    }/* * 运行结果  普通代码块内的变量x=3 *      主方法内的变量x=1 *      普通代码块内的变量y=7 */
构造代码块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。如果存在多个构造代码块，执行顺序由他们在代码中出现的次序决定，先出现先执行。
public class Test1 {
        {
            System.out.println("第一构造块");        }public Test1(int i) {
            System.out.println("第" + i + "次调用" + "构造方法");        }
        {
            System.out.println("第二构造块");        }public static void main(String[] args) {new Test1(0);            new Test1(1);            new Test1(2);        }
    }/* * 执行结果 第一构造块 *      第二构造块 *      第0次调用构造方法 *      第一构造块 *      第二构造块 *      第1次调用构造方法 *      第一构造块 *      第二构造块 *      第2次调用构造方法 */
静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。
注意：
1.静态代码块不能存在于任何方法体内。
2.静态代码块不能直接访问实例变量和实例方法，需要通过类的实例对象来访问。
public class Test3 {public static String STATIC_FIELD = "静态属性";        // 静态块        static {
            System.out.println(STATIC_FIELD);            System.out.println("静态代码块1");        }public String field = "非静态属性";        // 非静态块        {
            System.out.println(field);            System.out.println("非静态代码块2");        }public InitOderTest() {
            System.out.println("无参构造函数");        }public static void main(String[] args) {
            InitOderTest test = new InitOderTest();        }// 非静态块        {
            System.out.println(field);            System.out.println("非静态代码块1");        }// 静态块        static {
            System.out.println(STATIC_FIELD);            System.out.println("静态代码块2");        }
    }/* * 运行结果 静态属性 *      静态代码块1 *      静态属性 *      静态代码块2 *      非静态属性 *      非静态代码块2 *      非静态属性 *      非静态代码块1 *      无参构造函数 */
以下代码演示了创建一个对象并调用方法各个代码块之间的优先关系：
public class Person {static{
System.out.println("1.我是静态块，优先于构造块执行！
    并且只有创建第一个对象的时候执行一次！");
    }
    {
System.out.println("2.我是构造块，优先于构造方法执行！
    每创建一个对象执行一次！");
    }public Person() {
        System.out.println("3.我是构造方法，每创建一个对象执行一次");    }public void function1(){
System.out.println("我是非静态方法中的普通代码块，
    方法被调用时执行！");
    }public static void function2(){
System.out.println("我是静态方法中的普通代码块，
    方法被调用时执行，晚于静态块执行！");
    }
}
测试类：
public class HelloWrold {public static void main(String[] args) {new Person().function1();        new Person().function1();        System.out.println("=================");        Person.function2();        Person.function2();    }
}
运行结果：
我们可以看出：静态块总是最先执行的，并且只有在创建该类的第一个实例的时候才会执行一次；第二执行的是构造块；第三执行的是构造方法。
总结
以上就是本文关于详解java中的四种代码块的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

Java对象初始化
这是一道阿里巴巴的关于Java对象初始化的面试题，堪称经典，代码很简单（编写格式做了些修改），但是需要面试者对Java中对象初始化有一个透彻的认识，那么通过这道面试题，对我有点启发，所以希望在这里分享给大家，希望能给迷惘的初学者一起指引，下面我们直入主题，先看看代码：
public class InitializeDemo {
    private static int k = 1;
    private static InitializeDemo t1 = new InitializeDemo("t1");
    private static InitializeDemo t2 = new InitializeDemo("t2");
    private static int i = print("i");
    private static int n = 99;
    static {
        print("静态块");
    }
    private int j = print("j");
    {
        print("构造块");
    }
    public InitializeDemo(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }
    public static int print(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
    public static void main(String args[]) {
        new InitializeDemo("init");
    }
}
做些小补充，这也是很多Java学习者最初都能接触到的一些但是不是很理解的概念：
核心理念：
静态属性和静态代码块都是在类加载的时候初始化和执行，两者的优先级别是一致的，且高于非静态成员，执行按照编码顺序。
非静态属性和匿名构造器在所有的构造方法之前执行，两者的优先级别一致，执行按照编码顺序。
以上执行完毕后执行构造方法中的代码。
读者仔细揣摩上面三条句子，也就是Java对象初始化的顺序，也就明白以上程序的输出结果为什么如下：
j   i=0    n=0
构造块   i=1    n=1
t1   i=2    n=2
j   i=3    n=3
构造块   i=4    n=4
t2   i=5    n=5
i   i=6    n=6
静态块   i=7    n=99
j   i=8    n=100
构造块   i=9    n=101
init   i=10    n=102
如果还是没有明白，就看下面详解，一下详解的顺序就是按照上文的核心理念的顺序来执行的（建议读者把自己带入JVN的世界里，跟着JVM一步一步往下面走）：
运行main方法的时候，JVM会调用ClassLoader来加载InitializeDemo类，那么一起源于这次加载。
上面有四个静态属性，所以会按顺序逐一初始化这四个静态属性。
private static int k = 1; 此时将k初始化为1。
private static InitializeDemo t1 = new InitializeDemo("t1");创建InitializeDemo对象，那么按照核心理念中的顺序，先执行private int j = print("j");，打印出j，然后执行构造
块，最后执行构造方法。
5.private static InitializeDemo t2 = new InitializeDemo("t2");同步骤4。
6.private static int i = print("i");打印i。
7.private static int n = 99;直到这一步，n才被赋值为99，之前是从默认的0开始++的。
8.静态属性初始化完毕，代码走到静态块，打印出静态块，此时n=99。
9.静态属性和静态块执行完毕，然后执行main方法中的代码new InitializeDemo("init");
10.main方法中创建对象，先初始化非静态属性，private int j = print("j");打印j，然后执行构造块，最后执行构造方法。
不知道我解说清楚了没有，只要把握住核心理念，碰到在复杂的问题也都不会怕了。
用一个公式概括一下Java对象初始化执行优先级别：
（静态属性=静态代码块）> （非静态属性 = 构造块）> 构造方法
总结一下核心理念：
静态只在类加载的时候执行，且执行一次。
非静态只在实例化的时候执行，且每次实例化都执行。
静态在非静态之前执行。
静态属性和静态块的执行顺序取决于编码顺序，对它们一视同仁。
非静态属性和构造块的执行顺取决于编码顺序，对它们也一视同仁。
最后执行构造方法。
上面的总结有点绕对吧，问题进一步简化的话，就更好理解了：
读者将静态代码块视为一个静态属性，将构造块视为一个非静态属性，那么问题简化到了这种路线“静态属性-->非静态属性-->构造方法“
不积跬步无以至千里，祝愿大家学习进步，乐于分享~ ~
更多关于Java的技术和资讯可以关注我的专栏：
Java架构筑基​zhuanlan.zhihu.com
专栏免费给大家分享Java架构的学习资料和视频