java api文档怎么看_怎么看懂一段陌生的java代码

这里主要是自己的一些经验，也是自己想把阅读代码的思路理一理，将来读代码的时候更加清晰。常用的关键字肯定得有一些积累，也不用看很多很难的，就那些入门级的教程足够了。

我们可以从构成得粒度进行一定的总结，比如按照从小到大的粒度，一般学语言都是按照这个结构。基本数据类型，循环控制语句，方法，有了这三者其实简单的代码基本都能看懂。剩下的其实就是一些语言特性了，一方面比如一些高级的语法，有时候自己实现很复杂，但调用自带的就那么一行。另一方面就是设计模式了，在面对这个的时候入门教程可能就不那么管用了，有点像：已知1+1=2，请你求出太阳的质量。因为基础语法，高级方法都能熟练之后记住就好，设计模式除了需要记忆还有一些需要理解的地方。但是当你区看设计模式的时候，又会触发一个超级支线任务jvm，也就是java虚拟机，Java代码细节的加载顺序有时候对一种设计模式的影响十分重要，因此也得需要了解一些。下面会简要地介绍一些，以及给出几个例子，错误的地方，大家多多指正。

基础类型

这里都是以byte为单位，1byte = 8bit

byte：1，short：2，int：4，long：8，float：4，double：8，boolean(true/false)，char：2

一个基本的二进制byte，然后五个与数字有关的从小的整数到大的整数，从小的带小数点的数到大的带小数点的数，逻辑运算以及字符类型。这里不像学c语言的时候还会告诉你机器不同数据类型的大小可能会有变化，因为java虚拟机的作用，都可以转成一致的，这就是Java的可移植性高的原因。想想可移植性这一条就不用专门去作为语言特性背下来了，自然而然就记住了。

循环控制

for，while，if else，continue，break

• for对应的有高级的foreach语句，对于数组的遍历就不用使用下标了，直接就能遍历。
• while对应的有do while与while do
• if else有各种嵌套，if， else if ，else
• continue，在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
• break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。跳出最里层的循环，并且继续执行该循环下面的语句

switch感觉用的不算很多，可以大致浏览下就行，需要注意的是continue和break有时候可能会忘记这两者的区别，会对循环的使用造成破坏性的影响。如果你找不出这段循环代码以及带了continue或者break出错的地方，基本上就是continue或者break放错了位置。

整体结构

这里按照结构看，大概就是属性，方法，对象，类，抽象类，接口。对象在这中间类似于一个承上启下的关键。类的实例是对象，对象有属性和方法。

后面三者你也可以按照抽象的层次看，越往后越抽象。属性和方法，类比一个人就是名字之类的和这个人会做什么动作的关系；注意并不是变量与函数的关系，虽然可以粗略地归进去，但有时候你的属性值永不改变比如名字。抽象类和接口一般对阅读一段代码来说没什么影响，对于一个项目来说，你大概可以认为是这两个一个是黄河的发源地，一个是长江的发源地。我没记错的话，好像是长江更长一些。继承可以使用 extends 和 implements 这两个关键字来实现继承。extends 对应类，implements对应接口。

到这里基本上一个普通的方法就能看懂了，java里叫方法，c里叫函数。然后就是语言特性了，比如修饰符。

修饰符（初级部分）

public，private，proteced

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

外部类不用private和protected修饰的原因大概是，类的设计就是用来使用的，你都封闭了还用什么呢。你要是有的不想给别人看，那你把你的某些属性和某些方法藏起来私有化就好了就好了。

abstract

• 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。说到这个可能又会被面试问道，抽象类和接口的区别

final

• final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

static

• static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
• static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

修饰符（高级部分）

所谓高级部分，我的划分标准大概就是从单线程转到多线程。

synchronized

• synchronized 关键字声明的方法同一时间只能被一个线程访问。

transient

• 序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

volatile

• volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

先看看第一个例子：

public 

首先有三个类，Logger，UserController，OrderController；Logger有一个构造函数Logger()，名字和类名一样的是构造函数，还有一个log()方法。后面两个类就都有一个创建Logger()对象的过程，创建了Logger()对象logger后都调用了log()方法，也就是写东西进去。但是构造方法里把文件路径写死了，如果正好那两个类里都同时执行操作，那就会两个写操作但是会写一个文件，那就会发生覆盖了。再看下面这一段：

public 

这里主要是要注意private static final Logger instance =new Logger(); 和之前的创建对象方式完全不同了。这里使用了三个关键字private，static，final，private很好理解，保证了对象只在此类中能够使用，同时也封装了Logger类的构造方法，保证不会再其他地方创建出新的对象，全部都私有化了。那么static关键字呢，先看看下面这个例子：

public 

从运行结果可以看到，当执行类的hashCode()方法时候，Collection中的static块并没有被初始化，当主函数中调用了Collection中的某个静态变量，这时候这个类才被初始化。并且先输出的静态代码块里的，然后再调用输出了值。我们可以稍微讲讲类的执行顺序，首先静态变量以及方法是属于类的，不属于对象；然后这里面还有个内部静态类，同样都是静态的则按照顺序执行。不是静态的则等到创建对象，进行调用才执行。

因此上面的代码里首先实行main(),main也是静态的方法，因为你需要把一些执行的操作放在里面，如果main不是静态的那它又要在哪个方法里去创建对象实例呢，因此不如直接设置一个源头。你可以尝试将前面的main和Collection换个顺序，发现结果并没有什么变化，但是你直接在main前面加一个static代码块的话，则这个静态代码块会先执行。也就是其实main既是一种特殊的静态方法其实也是一种普通的特殊方法。

内部静态类不会自动初始化，只有调用静态内部类的方法，静态域，或者构造方法的时候才会加载静态内部类。

这就是static的部分，与之前那两句话描述出来的是不是很不一样。

然后是final关键字，final修饰的变量值不会改变。但是在多线程的环境中，它还会保证两点，1. 其他线程所看到的final字段必然是初始化完毕的。 2. final修饰的变量不会被程序重排序。看下面的例子：

public 

由于a,b之间没有数据依赖性，普通域（普通变量）a可能会被重排序到构造函数之外，线程B就有可能读到的是普通变量a初始化之前的值（零值），这样就可能出现错误。而final域变量b，根据重排序规则，会禁止final修饰的变量b重排序到构造函数之外，从而b能够正确赋值，线程B就能够读到final变量初始化后的值。

因此回到最开始的那个private static final Logger instance =new Logger(); 表明初始化类加载时就初始化了一个对象，并且所有线程都共用这一个，final保证初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能重排序，也就保证了多线程访问不会覆盖。

然后这个例子，就是单例模式里经典的饿汉式写法。

参考博客：

https://blog.csdn.net/riemann_/article/details/96390511

https://blog.csdn.net/qq_43279637/article/details/84982874

https://www.jianshu.com/p/4ba9bea12264

https://www.runoob.com/java/java-modifier-types.html