在定义变量时，不要使用关键字或者保留字，否则会出现一些莫名其妙的情况。

11.Java 关键字和保留字

一、概念

Java 关键字（Key Word）：  对 Java 的编译器有特殊的意义，他们用来表示一种数据类型或者表示程序的结构.

保留字（Reserve Word）：即它们在 Java 现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在 Java 中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在 Java 中定义为变量名称等，因为容易混淆。

注意：关键字和保留字均不能用作变量名、方法名、类名、包名和参数。

二、具体的保留字

goto、const

三、具体的关键字（51 个）

1. 访问修饰符（3 个）

public、protected、private

作用：用来修饰类（接口、抽象类）、方法、属性、构造方法、常量、主函数

2. 类、接口、抽象类（9 个）

class、interface、abstract—— 定义

extends—— 继承类、implements—— 实现接口

new—— 新建一个对象、super—— 调用父类方法、this—— 指代当前对象

instanceof—— 通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。

3. 数据类型（13 个）

void—— 没有返回值

byte、short、int、long—— 整型数据

float、double—— 浮点型数据

char—— 字符型数据

boolean—— 判断型数据

enum—— 枚举

null、true、false—— 值类型

4. 线程（2 个）

synchronized—— 线程同步（修饰方法、代码块，方法、代码块的同步）

volatile—— 线程同步（修饰属性，属性的同步）

1 关于volitate关键字，描述不正确的是() 
A 用volitate 修饰的变量， 每一次的更新对其他的线程都是可见的； 
B 对volitate 的操作是原子性的 
C 对volitate 的操作不会造成阻塞 
D 不依赖其他的锁机制，多线程环境下的技数器可以用volitate 来实现 
注解： 一旦一个共享变量（类的成员变量，类的静态成员变量）被volitate修饰，那么，其就具备了两层含义： 
1) 保证了不同的线程对这个变量进行操作的时候的可见性；即一个线程修改了某个变量， 这个新的值对于其他的线程来说是立即 
可见的。 
2) 禁止进行指令的重排序(volatile关键字能确保变量在线程中的操作不会被重排序而是按照代码中规定的顺序进行访问) 
volatile 只提供了保证访问该变量，每一次读取改变量的时候都是从内存中读取，并不会使用寄存器缓存该值. 
对该变量的修改，volatile 并不提供原子性的保证； 
由于及时更新，volitate 可能导致另一线程访问最新变量值，无法跳出循环的情况， 
多线程下，计数器必须使用保护锁； 
*注：原子性解释1：原子性就是说一个操作不可以被中途cpu暂停然后调度, 即不能被中断, 要不就执行完, 要不就不执行. 
如果一个操作是原子性的,那么在多线程环境下, 就不会出现变量被修改等奇怪的问题。 
原子性解释2：原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型） 
这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++； 这个操作实际是a = a + 1；
是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。
一个操作是原子操作，那么我们称它具有原子性。Java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。
比如：AtomicInteger、AtomicLong、AtomicReference等。

5. 异常（5 个）

throw—— 抛出方法代码中的异常给方法自身。使用位置：方法中间

throws—— 抛出方法中的异常给调用者。使用位置：方法外部

try—— 捕获 {} 中代码是否有发生异常

catch—— 处理 try 捕获的异常

finally—— 不管有没有异常发生都会执行的代码块

6. 返回（1 个）

return

7. 循环、条件（10 个）

if、else、switch、case、break、default、continue、while、do、for

8. 包（2 个）

package、import

9. 瞬时的（1 个）

transient 关键字只能修饰变量，而不能修饰方法和类。

我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，
我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，
打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，
这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，
将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

10. 断言（1 个）

assert

11. 调用底层代码（C\C++）（1 个）

native

12、不可变的 ——final（1 个）

修饰属性、常量、局部变量、参数 —— 作用：数据是不可改变的

修饰类 —— 作用：修饰的类不能被继承

修饰普通方法 —— 作用：修饰的方法不能被重写

13. 静态的 ——static（1 个）

修饰属性、常量

修饰内部类

修饰普通方法

作用：所有使用 static 关键字修饰的内容会最先执行。static 修饰的内容在内存中只有唯一的一份（存储在静态内存空间中）。

14. 格式规范 ——strictfp（1 个） 即 strict float point (精确浮点)。

修饰类、接口或方法。

修饰方法时，该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制，符合 IEEE-754 规范。

修饰类或接口时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。

严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。

如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字 strictfp.
示例 1
　　下面的示例演示了一个使用 strictfp 修饰符声明的类
！

package com.magical;   
  
// Example of precision control with strictfp   
public strictfp class MyClass {   
    public static void main(String[] args)   
    {   
        float aFloat = 0.6710339f;   
        double aDouble = 0.04150553411984792d;   
        double sum = aFloat + aDouble;   
        float quotient = (float)(aFloat / aDouble);   
        System.out.println("float: " + aFloat);   
        System.out.println("double: " + aDouble);   
        System.out.println("sum: " + sum);   
        System.out.println("quotient: " + quotient);   
    }   
} 

package com.magical;

// Example of precision control with strictfp
public strictfp class MyClass {
 public static void main(String[] args)
 {
  float aFloat = 0.6710339f;
  double aDouble = 0.04150553411984792d;
  double sum = aFloat + aDouble;
  float quotient = (float)(aFloat / aDouble);
  System.out.println("float: " + aFloat);
  System.out.println("double: " + aDouble);
  System.out.println("sum: " + sum);
  System.out.println("quotient: " + quotient);
 }
}


运行结果： 
float: 0.6710339 
double: 0.04150553411984792 
sum: 0.7125394529774224 
quotient: 16.167336

2019 年 6 月 26 日 09:24:34

1_基本语法之关键字和保留字_标识符_注释

关键字:提前被JAVA定义过,并赋值有特殊含义的单词

保留字:提前被JAVA定义过,但还没有给予赋值

abstract：用来定义类或者方法 具有抽象属性

assert:断言.用来程序调试

boolean：基本数据类型之一,布尔类型

break：提前跳出一个块

byte：基本数据类型之一,字节类型

case：switch语句中  表示一个分支

catch：try/catch语句中 用来捕捉异常(7.0之后支持捕捉多个异常)

char：基本数据类型之一，字节类型

class：声明为一个类

const：保留关键字，没有具体含义

continue：在循环语句中，跳出本次循环，回到开始出 执行下一次循环

default：表示默认。例如在switch/case语句中 表示一个默认的分支

do：用在do-while循环中-二话不说 先给你循环一次

double：基本数据类型之一，双精度浮点型（八个字节  64位）

else：if/else语句中 表示与if条件相对应的分支

enum：枚举

extends：继承，声明一个类是另一个类的子类，子类自动拥有成员变量成员方法 构造方法

final：生命这个变量或者方法或者类是最终属性，表示被修饰的变量不能再被赋值，方法不能被覆盖，类不能被定义为父类

finally：在try/catch finally ，表示无论如何也要执行的代码块

float：基本数据类型之一 单精度浮点型（四个字节 32位）

for：for循环开始的引导词

goto：保留关键字 没有具体含义

if：if/else条件循环 考试的引导词

implements：用以表示一个类实现了一个接口

import：表示要访问制定的类或者包

instanceof：用来测试一个对象是否是指定类的实例

int：基本数据类型之一 整数类型

interface：声明一个类为接口类型，当一个抽象类中的所有方法都是抽象的时候 他就变身为接口类型

long：基本数据类型之一 长整数类型（八个字节 64为）

native：本地方法---用以声明一个方法是由计算机相关的语言实现的（c/c++/fortran）实现的

new：用来创建新对象    只要有new关键字 就有新的对象生成

private：声明修饰对象为私用模式

protected：声明修饰对象为保护模式

public：声明修饰对象为公共访问模式

return：从成员方法中返回数据

short：基本数据类型之一 短整形（2个字节 16位）

static：声明修饰对象为静态的 静态方法可以使用  ClassName.methodName()方法调用  静态方法中只能调用使用静态变量

strictfp：用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE754规范

super：表示当前对象的父类型引用或者父类型的构造方法，super.name=父类引用 ，super()=父类构造

shitch：switch/case分支开头引导词

synchronized：表示代码块内的代码需要同步执行----同一时间内只能有一个线程(对象访问)

this：指向当前实力对象的引用

throw：直接抛出一个异常-------由类抛出给虚拟机

throws：生命在当前定义的成员方法中所有需要抛出的异常------由方法调用者抛出

transient：生命不用序列化的成员域

try：try/catch 语句尝试捕捉处理异常

void：表示被修饰的方法不需要返回值

volatile：表示两个或多个变量必须同步的发生变化

while：while（）{}条件循环

标识符：程序定义者给变量常量方法定义的名字

1.由26个字母 0-9是个数字下划线_和美元$符号组成   但是不能以数字开头(理论上符合这些都可以，但是集中有一些默认的规范)

2.不可以使用关键字

3.一定要见名知意 不要瞎胡起

注释

//单行

/*

　　多行

*/

文档
/**

*文档注释

*

*/

Java 中关键字和保留字

关键字

具有特殊用途的单词

保留字

现在还没有使用这两个单词作为关键字，但可能在未来的 Java 版本中使用这两个单词作为关键字

关键字：48 个

保留字：2 个

特殊直接量：3 个

关键字：

1. abstract
2. assert
3. boolean
4. break
5. byte
6. case
7. catch
8. char
9. class
10. continue
11. default
12. do
13. double
14. else
15. enum
16. extends
17. final
18. finally
19. float
20. for
21. if
22. implements
23. import
24. instanceof
25. int
26. interface
27. long
28. native
29. new
30. package
31. private
32. protected
33. public
34. return
35. short
36. static
37. strictfp
38. super
39. switch
40. synchronized
41. this
42. throw
43. throws
44. transient
45. try
46. void
47. volatile
48. while

保留字：

1. gogo
2. const

特殊直接量：

1. true
2. false
3. null

Java 中的关键字和保留字

关键字：

Java 语言中已经事先定义好了的，有着特殊含义和用途