1.常用关键字汇总
访问权限修饰符 | Public | default(并无该修饰符，默认啥也不写) | protected | private | |
异常处理关键词 | try | catch | finallly | throw | throws |
包的关键词 | package | import | |||
有关实例的关键词 | new | this | super | instanceof | |
类之间关系的关键词 | implements | extends | |||
定义类,函数,变量的关键词 | abstract | final | static | synchronized |
2.访问权限修饰符
修饰符 | 当前类 | 同包 | 子类 | 其他包 |
public | Y | Y | Y | Y |
protected | Y | Y | Y | N |
default(默认,不写) | Y | Y | N | N |
private | Y | N | N | N |
注:Y(可以),N(不可以)
无需文字多言，只需记住上图规律，用时想图即可
3.异常处理关键字
3.1.异常简记
程序从编写代码到上线运行，分为编辑阶段和运行阶段，在每个阶段中都可能会出现一些问题，称为异常
异常根据软硬件的区分又分为错误【error】和异常【exception】，异常体系最大的类Throwable，一般error不是程序员考虑的问题，我们需要考虑的是exception
3.2.异常的处理方案(简单理解)
3.2.1.自己处理(代码编写者处理)
try&catch&finally
单个异常处理:
try{
//可能出现问题的代码
int a = 1/0;
} catch(ArithmeticException exception){
//处理方案
exception.printStackTrace();
}
System.out.println("--over--");多个异常处理：
多catch处理:
try{
print(null);
//可能出现问题的代码
int a = 1/0;
} catch(ArithmeticException exception){
//处理方案
exception.printStackTrace();
} catch(NullPointerException exception){
exception.printStackTrace();
}
System.out.println("--over--");直接catch(更大范围的异常):
try{
print(null);
//可能出现问题的代码
int a = 1/0;
}catch(Exception exception){
exception.printStackTrace();
}finally 关键字可加可不加，如果有需求(无论结果如何，某段代码最后得实现)
try{
print(null);
//可能出现问题的代码
int a = 1/0;
}catch(Exception exception){
exception.printStackTrace();
}finally{
System.out.println("I hate BUG!!!");
}3.2.2.谁用谁处理(调用者处理)
throw,throws
■throw 抛出异常
■throws 声明异常
注:如果该方法中有多个异常需要抛出，在声明的时候使用逗号隔开
public void print(int[] arr,int index) throws NullPointerException,ArrayIndexOutofBoundsException {
if(arr == null){
throw new NullPointerException();
}
if(index >= arr.length){
throw new ArrayIndexOutofBoundsException();
}
}疑问？？？
什么时候应该捕获，什么时候需要抛出？
简单理解：由于调用者导致的问题，应该抛出去，如果是方法本身就存在的问题，那应该捕获
4.包的关键字(了解)
■package(包):
1、标注某个类的来源(简单理解)
2、package 语句（如果出现）必须是 Java 源文件中的第一个非注释性文本。
■import(引入):
1、若有多个工程多个项目，有重复的类名，虽说影响可能性不大但是有不确定性，用import来避免不确定性
2、import 关键字使一个包中的一个或所有类在当前 Java 源文件中可见
5.有关实例的关键字
■new:创建实例(简单理解)
■this:代指当前对象(简单理解)
■super:代指父类对象(简单理解)
■instanceof:判断该实例是否是该类型，返回boolean类型(简单理解)
5.1.new
1.用于创建类的新实例,例Object obj = new Object();
2.new关键字后面必须是类名加构造方法参数（带括号）
3.=左侧的类型必须要与实例化的类或接口有赋值兼容关系
5.2.this
用于引用当前实例，当引用可能不明确，这时最好用this代表
5.3.super
1.代表引用super关键字的类的超类
2.代表了父类空间的引用
3.子类中访问同名的属性或方法时,默认用的是子类的属性或方法，若要用父类的方法可用super.接方法(属性)进行调用
5.4.instanceof
instanceof 严格来说是 Java 中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
boolean result = obj instanceof Class
其中 obj 为一个对象， Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或 间接子类，或者是其接口的实现类，结果result 都返回 true ，否则返回 false 。
6.类之间关系的关键字
■extends
在类的声明中，通过extends来继承一个类，注意Java最多只能继承一个类
public class Dog extends Animal{
/**
* dog的特有功能：看门
*/
public void lookDoor() {
System.out.println(getName()+"看门有一手");
}
}■implements
实现接口, 接口的方法一般为空的, 必须重写才能使用,implements可以实现多个接口，声明实现接口时要将多个接口以逗号隔开
public class Computer implements IUsb,XXX{
@Override
public void joinMouse(){
System.out.println("接入一个牧马人鼠标");
}
@Override
public void joinKeyBoard(){
System.out.println("接入一个青轴键盘");
}
}7.定义类，函数，变量的关键字
■abstract(抽象，简单了解)
1.被修饰的类为抽象类，抽象类不可实例化，可以通过方法的覆盖来实现多态的属性，抽象类将事物的共性的东西提取出来,由子类继承去实现,代码易扩展、易维护
2.被修饰的方法为抽象方法，没有默认实现（实体），抽象方法不能用private修饰，因为抽象方法必须被子类实现（覆写），而private权限对于子类来 说是不能访问的，所以就会产生矛盾
3.需注意，采用 abstract方法的类本来就是抽象类，并且必须声明为abstract
■final(最终)
1.对于一个final变量，若是基本数据类型，其数值初始化后不可变；若是引用类型，初始化后不可再指向另一个对象
2.final修饰的类，表明该类不可被继承，且该类中的所有成员方法都会被隐式地指定为final方法
3.使用final类的原因有两个，一是把方法锁定，以防任何类继承；第二个是效率（早期java会将final方法转为内嵌调用，先版本已经不需要这些优化）---记着无用，但是面试时候会显得更牛x些
■static(静态,简单记)
1.static可以用在成员变量，代码块，内部类及成员方法
2.static方法不属于对象，可以用类名直接调用，被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享
3.静态代码块随着类的加载而执行，只执行一次，用处不多，例需要统计一下类加载时候的日志信息，就可以将这部分代码语句写在static静态代码块里面
4.)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变，在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
5.static（内部）类可以被其他类实例化和引用（即使它是顶级类）
■synchronized（线程、同步）
1.用于需要用到同步的方法或语句块，保证线程安全
2.synchronized关键字防止被选中的代码的线程安全
3.用于实例方法（静态方法），执行时该实例（类）将被锁定
注:synchronized很重要，建议线程方面加强学习，日后工作开发中线程安全是很重要的问题，这里只大致叙述以对付无聊的面试官，希望对你们有所帮助.....
