java中50个关键字以及各⾃⽤法⼤全
关键字和保留字的区别
正确识别java语⾔的关键字（keyword）和保留字（rerved word）是⼗分重要的。Java的关键字对java的编译器有特殊的意义，他们⽤来表⽰⼀种数据类型，或者表⽰程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
识别java语⾔的关键字，不要和其他语⾔如c/c++的关键字混淆。
标志符包含关键字⽽关键字⾥⾯⼜包含两个保留字，根据java⽂档true、fal、null不属于关键字但是属于标志符，规定的关键字只有50个包含两个保留字，但是这53个都属于标志符。
1.保留字（rerved words）：是语⾔已经定义过的字，⼀些保留字可能没有相对应的语法，考虑到扩展性，为了向后兼容不能再将其作为变量名。const和goto是java的保留字。 所有的关键字都是⼩写
2.50个关键字（keywards）：在语⾔中有特殊的含义成为语法的⼀部分。
abstract asrt boolean break byte
高中英语学习方法ca catch char class const continue default do double el
enum extends final finally float
for goto if implements import instanceof int interface long native new package private protected public
return strictfp short static super
switch synchronized this throw throws
transient try void volatile while
关键字的分类
关键字分为：访问控制、类⽅法和变量修饰符、程序控制语句、错误处理、包相关、基本类型、变量引⽤。
访问控制 修饰符的关键字（共3个）：
关键字意思备注，常⽤
public公有的可跨包，（默认选择）
丫髻沙大桥
protected受保护的当前包内可⽤
工厂节能降耗方案private私有的当前类可⽤
（1）private：可以应⽤于类、⽅法或字段（类中声明的变量），只能在声明的类内部中引⽤这些类、⽅法或字段，在外部或者对于⼦类⽽⾔是不可见的，类的默认访问范围是package访问，除⾮存在特殊的访问控制修饰符。可以从⼀个包中的任何类访问类成员 。
（2）protected：应⽤于类、⽅法或字段（类中声明的变量），可以在声明 protected 类、⽅法或字段的类、同⼀个包中的其他任何类以及任何⼦类（⽆论⼦类是在哪个包中声明的）中引⽤这些类、⽅法或字段。所有类成员的默认访问范围都是 package 访问，也就是说，除⾮存在特定的访问控制修饰符，否则可以从同⼀个包中的任何类访问类成员。 当前类、同包、⾮同包的⼦类。
（3）public：应⽤于类、⽅法或字段（在类中声明的变量）的访问控制修饰符。 可能只会在其他任何类或包中引⽤ public 类、⽅法或字
段。所有类成员的默认访问范围都是 package 访问，也就是说，除⾮存在特定的访问控制修饰符，否则，可以从同⼀个包中的任何类访问类成员。 所有类均可访问。
类、⽅法和变量修饰符：
定义类、接⼝、抽象类和实现接⼝、继承类的关键字、实例化对象（共6个）
关键字意思备注，常⽤
class类public class A(){} 花括号⾥有已实现⽅法体，类名需要与⽂件名相同
interface接⼝public interface B(){} 花括号⾥有⽅法体，但没有实现，⽅法体句⼦后⾯是英⽂分号“:”结尾
abstract声明抽象public abstract class C(){} 介于类与接⼝中间，可以有也可以没有已经实现的⽅法体
implements实现⽤于类或接⼝实现接⼝public class A interface B(){}
extends继承⽤于类继承类 public class A extends D(){}
new创建新对象 A a=new A(); A表⽰⼀个类
（1）class：⽤来声明新的 Java类，该类是相关变量和/或⽅法的集合。类是⾯向对象的程序设计⽅法的基本构造单位。类通常代表某种实际实体，如⼏何形状或⼈。类是对象的模板。每个对象都是类的⼀个实例。要使⽤类，通常使⽤ new 操作符将类的对象实例化，然后调⽤类的⽅法来访问类的功能。
（2） interface ：⽤来声明新的 接⼝，接⼝是⽅法的集合。接⼝是 Java 语⾔的⼀项强⼤功能。任何类都可声明它实现⼀个或多个接⼝，这意味着它实现了在这些接⼝中所定义的所有⽅法。 实现了接⼝的任何类都必须提供在该接⼝中的所有⽅法的实现。⼀个类可以实现多个接⼝。
（3）abstract：可以修改类或⽅法。abstract类可以扩展（增加⼦类），但不能直接实例化。abstract⽅法不在声明它的类中实现，但必须在某个⼦类中重写。采⽤ abstract⽅法的类本来就是抽象类，并且必须声明为abstract。
（4）implements：在 class 声明中使⽤，以指⽰所声明的类提供了在 implements 关键字后⾯的名称所指定的接⼝中所声明的所有⽅法的实现。类必须提供在接⼝中所声明的所有⽅法的实现。⼀个类可以实现多个接⼝。
（5）extends：⽤在 class 或 interface 声明中，⽤于指⽰所声明的类或接⼝是其名称后跟有 extends 关键字的类或接⼝的⼦类。⼦类继承⽗类的所有 public 和 protected 变量和⽅法。 ⼦类可以重写⽗类的任何⾮ final ⽅法。⼀个类只能扩展⼀个其他类。
（6） new：⽤于创建类的新实例。 new 关键字后⾯的参数必须是类名，并且类名的后⾯必须是⼀组构造⽅法参数（必须带括号）。 参数集合必须与类的构造⽅法的签名匹配。 = 左侧的变量的类型必须与要实例化的类或接⼝具有赋值兼容关系。
修饰⽅法、类、属性和变量（共9个）
关键字意思备注，常⽤
static静态的属性和⽅法都可以⽤static修饰，直接使⽤类名.属性和⽅法名。 只有内部类可以使⽤static关键字修饰，调⽤直接使⽤类
名.内部类类名进⾏调⽤。 static可以独⽴存在。静态块
白银期货开户final 最终的不可
被改变的
⽅法和类都可以⽤final来修饰
final修饰的类是不能被继承的 修饰的⽅法是不能被⼦类重写。
常量的定义：final修饰的属性就是常量。
super 调⽤⽗类的
⽅法
常见public void paint(Graphics g){
super.paint(g); ··· }
this 当前类的⽗
类的对象
调⽤当前类中的⽅法（表⽰调⽤这个⽅法的对象）
this.addActionListener(al)：等等
native本地
strictfp严格，精准
synchronized线程，同步
transient短暂
volatile易失
（1） static：static 关键字可以应⽤于内部类（在另⼀个类中定义的类）、⽅法或字段（类的成员变量）。 通常，static 关键字意味着应⽤它的实体在声明该实体的类的任何特定实例外部可⽤。static（内部）类可以被其他类实例化和引⽤（即使它是顶级类）。在上⾯的⽰例中，另⼀个类中的代码可以实例化 MyStaticClass 类，⽅法是⽤包含它的类名来限定其名称，如 MyClass.MyStaticClass。 static 字段（类的成员变量）在类的所有实例中只存在⼀次。 可以从类的外部调⽤ static ⽅法，⽽不⽤⾸先实例化该类。这样的引⽤始终包括类名作为⽅法调⽤的限定符。模式：public final static <type> varName = <value>; 通常⽤于声明可以在类的外部使⽤的类常量。在引⽤这样的类常量时需要⽤类名加以限定。在上⾯的⽰例中，另⼀个类可以⽤ MyClass.MAX_OBJECTS 形式来引⽤ MAX_OBJECTS 常量。
（2）final：应⽤于类，以指⽰不能扩展该类（不能有⼦类）。final 关键字可以应⽤于⽅法，以指⽰在⼦类中不能重写此⽅法。⼀个类不能同时是 abstract ⼜是 final。abstract 意味着必须扩展类，final 意味着不能扩展类。⼀个⽅法不能同时是 abstract ⼜是 final。
abstract 意味着必须重写⽅法，final 意味着不能重写⽅法
（3）super ：⽤于引⽤使⽤该关键字的类的超类。 作为独⽴语句出现的 super 表⽰调⽤超类的构造⽅法。 super.<methodName>() 表⽰调⽤超类的⽅法。只有在如下情况中才需要采⽤这种⽤法：要调⽤在该类中被重写的⽅法，以便指定应当调⽤在超类中的该⽅法。
（4） this ：⽤于引⽤当前实例。 当引⽤可能不明确时，可以使⽤ this 关键字来引⽤当前的实例。
（5）native ：以指⽰该⽅法是⽤ Java 以外的语⾔实现的。Java的不⾜除了体现在运⾏速度上要⽐传统的C++慢许多之外，Java⽆法直接访问到 底层（如系统硬件等)，为此Java使⽤native⽅法来扩展Java程序的功能。
可以将native⽅法⽐作Java程序同Ｃ程序的接⼝，其实现步骤：
１、在Java中声明native()⽅法，然后编译；
双阙 ２、⽤javah产⽣⼀个.h⽂件；
３、写⼀个.cpp⽂件实现native导出⽅法，其中需要包含第⼆步产⽣的.h⽂件（注意其中⼜包含了JDK带的jni.h⽂件）；
４、将第三步的.cpp⽂件编译成动态链接库⽂件；
５、在Java中⽤System.loadLibrary()⽅法加载第四步产⽣的动态链接库⽂件，这个native()⽅法就可以在Java中被访问了。
（6） strictfp：strictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进⾏浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运⾏环境在对浮点运算的表达式是采取⼀种近似于我⾏我素的⾏为来完成这些操作，以致于得到的结果往往⽆法令⼈满意。⽽⼀旦使⽤了strictfp来声明⼀个类、接⼝或者⽅法时，那么所声明的范围内Java的编译器以及运⾏环境会完全依照浮点规范IEEE-754来执⾏。因此如果想让浮点运算更加精确，⽽且不会因为不同的硬件平台所执⾏的结果不⼀致的话，那就请⽤关键字strictfp。可以将⼀个类、接⼝以及⽅法声明为strictfp，但是不允许对接⼝中的⽅法以及构造函数声明strictfp关键字。
（7） synchronized：可以应⽤于⽅法或语句块，并为⼀次只应由⼀个线程执⾏的关键代码段提供保护。 可防⽌代码的关键代码段⼀次被多个线程执⾏。 如果应⽤于静态⽅法，那么，当该⽅法⼀次由⼀个线程执⾏时，整个类将被锁定。 如果应⽤于实例⽅法，那么，当该⽅法⼀次由⼀个线程访问时，该实例将被锁定。 如果应⽤于对象或数组，当关联的代码块⼀次由⼀个线程执⾏时，对象或数组将被锁定。
（8） transient ：可以应⽤于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。当⼀个对象被串⾏化的时候，transient型变量的值不包括在串⾏化的表⽰中，然⽽⾮transient型的变量是被包括进去的。Java的rialization提供了⼀种持久化对象实例的机制。当持久化对象时，可能有⼀个特殊的对象数据成员，我们不想⽤rialization机制来保存它。为了在⼀个特定对
象的⼀个域上关闭rialization，可以在这个域前加上关键字transient。 transient是Java语⾔的关键字，⽤来表⽰⼀个域不是该对象串⾏化的⼀部分。当⼀个对象被串⾏化的时候，transient型变量的值不包括在串⾏化的表⽰中，然⽽⾮transient型的变量是被包括进去的。
（9） volatile ：⽤于表⽰可以被多个线程异步修改的成员变量。 注意：volatile 关键字在许多 Java 虚拟机中都没有实现。 volatile 的⽬标⽤途是为了确保所有线程所看到的指定变量的值都是相同的。Java 语⾔中的 volatile 变量可以被看作是⼀种 “程度较轻
的 synchronized”；与 synchronized 块相⽐，volatile 变量所需的编码较少，并且运⾏时开销也较少，但是它所能实现的功能也仅
是 synchronized 的⼀部分。
程序控制语句
条件循环（流程控制）（共12个）
关键字意思备注，常⽤if如果if(){} 如果⼩括号⾥⾯怎么怎么样 花括号就怎么怎么样el否则，或者常与if连⽤，⽤法相同
while当什么的时候while 怎么样就do什么 while(){}
for满⾜三个条件时for ( ; ; ){}
switch开关
switch(表达式)
{
ca 常量表达式1：语句1;
....
ca 常量表达式2：语句2;
档案管理要求
default：语句;
}
default就是如果没有符合的ca就执⾏它,default并不是必须的.
ca后的语句可以不⽤⼤括号.
switch语句的判断条件可以接受int,byte,char,short，不能接受其他类型.
ca 返回开关⾥的结
果
总经理助理岗位职责default默认
do运⾏长与while连⽤
break跳出循环
continue继续中断本次循环，并并开始下⼀次return返回return ⼀个返回值类型
instanceof实例⼀个⼆元操作符，和==，>，<；是同⼀类的。测试它左边的对象是否是它右边的类的实例，返回boolean类型的
数据
（1） if ：指⽰有条件地执⾏代码块。条件的计算结果必须是布尔值。 if 语句可以有可选的 el ⼦句，该⼦句包含条件为 fal 时将执⾏的代码。 包含 boolean 操作数的表达式只能包含 boolean 操作
数。
（2） el ：总是在 if-el 语句中与 if 关键字结合使⽤。el ⼦句是可选的，如果 if 条件为 fal，则执⾏该⼦句。
（3） while ：⽤于指定⼀个只要条件为真就会重复的循环。
（4） for ：⽤于指定⼀个在每次迭代结束前检查其条件的循环。 for 语句的形式为 for(initialize; condition; increment) 控件流进
⼊ for 语句时，将执⾏⼀次 initialize 语句。每次执⾏循环体之前将计算 condition 的结果。如果 condition 为 true，则执⾏循环体。 每次执⾏循环体之后，在计算下⼀个迭代的 condition 之前，将执⾏ increment 语句。
（5） switch ：⽤于基于某个表达式选择执⾏多个代码块中的某⼀个。 switch 条件的计算结果必须等于 byte、char、short 或 int。
ca 块没有隐式结束点。break 语句通常在每个 ca 块末尾使⽤，⽤于退出 switch 语句。 如果没有 break 语句，执⾏流将进⼊所有后⾯的 ca 和/或 default 块。
（6）ca ： ⽤来标记 switch 语句中的每个分⽀。 ca 块没有隐式结束点。break 语句通常在每个 ca 块末尾使⽤，⽤于退
出 switch 语句。 如果没有 break 语句，执⾏流将进⼊所有后⾯的 ca 和/或 default 块。
（7） default ：⽤来标记 switch 语句中的默认分⽀。 default 块没有隐式结束点。break 语句通常在每个 ca 或 default 块的末尾使⽤，以便在完成块时退出 switch 语句。 如果没有 default 语句，其参数与任何 ca 块都不匹配的 switch 语句将不执⾏任何操作。
（8） do：⽤于指定⼀个在每次迭代结束时检查其条件的循环。 do 循环体⾄少执⾏⼀次。 条件表达式后⾯必须有分号。
（9） break：⽤于提前退出 for、while 或 do 循环，或者在 switch 语句中⽤来结束 ca 块。 break 总是退出最深层的 while、for、do 或 switch 语句。
（10）continue ：⽤来跳转到 for、while 或 do 循环的下⼀个迭代。 continue 总是跳到最深层 while、for 或 do 语句的下⼀个迭代。
（11）return ：会导致⽅法返回到调⽤它的⽅法，从⽽传递与返回⽅法的返回类型匹配的值。 如果⽅法具有⾮ void 的返回类
型，return 语句必须具有相同或兼容类型的参数。 返回值两侧的括号是可选的。
（12）instanceof：⽤来确定对象所属的类。
错误处理
错误处理（共5个）
关键字意思备注，常⽤
catch处理异常
<+catch
程序的流程是：运⾏到try块中，如果有异常抛出，则转到catch块去处理。然后执⾏catch块后⾯的语句
<+catch+finally
程序的流程是：运⾏到try块中，如果有异常抛出，则转到catch块,catch块执⾏完毕后，执⾏finally块的代码，再执⾏
finally块后⾯的代码。
如果没有异常抛出，执⾏完try块，也要去执⾏finally块的代码。然后执⾏finally块后⾯的语句
<+finally
程序的流程是：运⾏到try块中，如果有异常抛出的话，程序转向执⾏finally块的代码。那末finally块后⾯的代码还会被执⾏吗？不会！因为你没有处理异常，所以遇到异常后，执⾏完finally后，⽅法就已抛出异常的⽅式退出了。
这种⽅式中要注意的是，由于你没有捕获异常，所以要在⽅法后⾯声明抛出异常
(来⾃⽹上的资料)
try捕获异常
finally 有没有异常都执⾏
throw 抛出⼀个异
常对象
⼀些可以导致程序出问题的因素,⽐如书写错误，逻辑错误或者是api的应⽤错误等等. 为了防⽌程序的崩溃就要预先检测这
些因素，所以java 使⽤了异常这个机制.
在java中异常是靠 "抛出" 也就是英语的"throw" 来使⽤的，意思是如果发现到什么异常的时候就把错误信息 "抛出"
throws 声明⼀个异
常可能被抛
主席台座次安排出
把异常交给他的上级管理，⾃⼰不进⾏异常处理
（1） catch ：⽤来在 try-catch 或 try-catch-finally 语句中定义异常处理块。 开始和结束标记 { 和 } 是 catch ⼦句语法的⼀部分，即使该⼦句只包含⼀个语句，也不能省略这两个标记。 每个 try 块都必须⾄少有⼀个 catch 或 finally ⼦句。 如果某个特定异常类未被任
何 catch ⼦句处理，该异常将沿着调⽤栈递归地传播到下⼀个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显⽰错误消息和堆栈跟踪信息。
（2） try ：⽤于包含可能引发异常的语句块。 每个 try 块都必须⾄少有⼀个 catch 或 finally ⼦句。 如果某个特定异常类未被任
何 catch ⼦句处理，该异常将沿着调⽤栈递归地传播到下⼀个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显⽰错误消息和堆栈跟踪信息。
（3）finally：⽤在异常处理的最后⼀个语句块，⽆论是否产⽣异常都要被执⾏。finally是对异常处理的最佳补充使代码总要被执⾏，使⽤finally可以维护对象的内部状态，并可以清理⾮内存资源。
（4） throw ：⽤于引发异常。 throw 语句将 java.lang.Throwable 作为参数。Throwable 在调⽤栈中向上传播，直到被适当
的 catch 块捕获。 引发⾮ RuntimeException 异常的任何⽅法还必须在⽅法声明中使⽤ throws 修饰符来声明它引发的异常。
（5） throws ：可以应⽤于⽅法，以便指出⽅法引发了特定类型的异常。 throws 关键字将逗号分隔的 java.lang.Throwables 列表作为参数。 引发⾮ RuntimeException 异常的任何⽅法还必须在⽅法声
明中使⽤ throws 修饰符来声明它引发的异常。 要在 try-catch 块中包
