Java 三种获取class 的区别，Java 思考，长期有效

// fromJson(JsonReader reader, Type typeOfT) 【最终都是在这里】
// TypeToken typeToken = (TypeToken) TypeToken.get(typeOfT);

// 【TypeToken --得到–> TypeAdapter】
// TypeAdapter typeAdapter = getAdapter(typeToken);
// T object = typeAdapter.read(reader);

Gson 原理

https://blog.csdn.net/chunqiuwei/article/details/49401733

//在继承多态中：
// 1、对于方法的覆盖，new的谁就调谁，这就是多态。
// 2、对于成员变量的覆盖，this在哪个类就指向哪个类的成员变量，没有多态。

//因为静态方法是属于类的，动态方法属于实例对象
//Java 静态方法不能重写但可以被子类静态方法覆盖,静态方法可以被子类继承，但是不可以被子类重写

//静态方法是属于类的，即静态方法是随着类的加载而加载的，在加载类时，程序就会为静态方法分配内存，
// 而非静态方法是属于对象的，对象是在类加载之后创建的，也就是说静态方法先于对象存在，当你创建一个对象时，
// 程序为其在堆中分配内存，一般是通过this指针来指向该对象。静态方法不依赖于对象的调用，
// 它是通过‘类名.静态方法名’这样的方式来调用的。而对于非静态方法，在对象创建的时候程序才会为其分配内存，
// 然后通过类的对象去访问非静态方法。因此在对象未存在时非静态方法也不存在，静态方法自然不能调用一个不存在的方法。

在程序运行期间，类中的静态变量其内存空间对所有该类的实例是共享的，因此在某些时候，为了节省内存空间开销，共享资源，我们可以将类中的变量声明为静态变量。但是因为静态变量生命周期太长，并且不易被系统回收，所有如果使用不合理，就会适得其反，从而造成大量内存的浪费。因此建议在全部符合下列条件的情况下才使用静态变量：

静态不管是方法还是属性是类的信息
不是静态的就是对象的信息，因为类是早于对象的，所以。。。

方法区：JDK8之前，由永久代实现，主要存放类的信息、常量池、方法数据、方法代码等；JDK8之后，取消了永久代，提出了元空间，并且常量池、静态成员变量等迁移到了堆中；元空间不在虚拟机内存中，而是放在本地内存中。那么，方法区是不是就不属于虚拟机内存的一部分了？还是元空间只是方法区的一部分，还有一部分东西存放在方法区中？待了解。

将 Hotspot 中永久生成部分内容移动到 Java 堆，将其余部分移动到本机内存。

interface A {

//对于接口来说，成员变量就是public static
int a = 123;

//对于方法来说，除了 静态，私有还有 default 可以有函数体之外，其他的都没有函数体
//Java 抽象类 就是 类和接口的集合

// 常量
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
// 私有静态方法

//https://blog.csdn.net/tracydragonlxy/article/details/78082600 java接口的概述

}

Java有[类，接口，注解，枚举] 四种文件格式

静态代码块>构造代码块>构造函数>普通代码块

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Data data = new Data();

        Run a = new Run(data);
        Run b = new Run(data);


        new Thread(a).start();


        new Thread(b).start();
//https://blog.csdn.net/ztchun/article/details/60778950?tdsourcetag=s_pctim_aiomsg

//就是这一句导致内存得不到及时的刷新，所以要使用volatile
        Thread.sleep(1000);

        data.a = 0;
    }
}


class Data {
    int a = 1;
}


class Run implements Runnable {

    Data data;

    public Run(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (data.a == 1) {

        }
    }
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE,

    /**
     * Module declaration.
     *
     * @since 9
     */
    MODULE
}

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

1. @Target
2. @Retention
3. @Documented
4. @Inherited

线程的synchronized都是因为得到一个锁之后，通过互斥别人而执行，而死锁就是两个都得到对方想要的锁但是都不愿意放手

Java的classLoader每一个类几乎都一样（除非自定义）
https://blog.csdn.net/ThinkWon/article/details/104390752?tdsourcetag=s_pctim_aiomsg