Java常用关键字

Java常用关键字
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200701215010728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTc3NzU1,size_16,colo

public（公共的）
1、public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
2、可以在其他任何类或包中引用 public 类、方法或字段。
3、除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

protected（受保护的）
1、protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
2、可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或字段。
3、除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

private（受保护的）
1、private 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
2、只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。
3、只能在本类内访问类成员。

用于定义类、函数、变量修饰符的关键字

abstract（生命抽象）
1、abstract关键字可以修改类或方法。
2、abstract类可以扩展（增加子类），但不能直接实例化。
3、abstract方法不在声明它的类中实现，但必须在某个子类中重写。
4、采用 abstract方法的类本来就是抽象类，并且必须声明为abstract。

final（最终、不可改变）

1、主要应用在三个地方：变量、方法、类。
2、对于一个final变量。如果是基本数据类型的变量，则其数值一旦初始化之后便不能更改；如果是引用类型的变量，则对其初始化之后便不能让其再指向另一个对象。
3、当final修饰一个类时，表明这个类不能被继承，final类中所有成员方法都会被隐式地指定为final方法。
4、使用final方法的原因有两个。**第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率，**在早期的java实现版本中，会将final方法转换为内嵌调用。但如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的java版本已经不再需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

static（静态）

1、在Java语言中，static主要有4中使用情况：成员变量、成员方法、代码块和内部类。
2、(1)static成员变量(类变量)
虽然Java语言中没有全局的概念，但可以通过static 关键字来达到全局的效果。Java类态变量属于类，提供了两种类型的交量。用satic关键字修饰的静态交量和没有satie关键字的实明安量静在内存中只有一个副本(所有实例都指向同一一个内存地址)，只要静态变量所在的类被加载， 这个静态变量就会被分配空间，因此，就可以被使用了。对静态变量的引用有两种方式，分别为“类静态变量”和“对象静态变量”。
实例变量属于对象，只有对象被创建后，实例变量才会被分配空间，才能被使用，它在内存中存在多个副本。只能用“对象.静态变量”的方式来引用。
(2) static 成员方法
与变量类似，Java类同时也提供了static方法与非static方法。static 方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。
static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被创建，即使已经被创建了，也无法确定调用哪个对象的方法。同理，static 方法也不能访问非static类型的变量。实现了单例。
(3).Static代码块
Static代码块又叫静态代码块，在类中独立于成员变量和成员函数的代码块。它不在任何一个方法体内，JVM在加载类的时候执行静态代码块，多个存在则顺序执行，常用来初始化静态变量。而且只被执行一次，如果是在主类中，会优先于main方法执行。
(4).Static内部类
被static修饰的类相当于外部类，但是内部类不能与外部类的类名相同，只有内部类才能被定义为static（可以理解为内部类也是类的一个成员）。

3、Java中提供了static方法和非static方法。static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用。
static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被创建，即使已经被创建了，也无法确定调用哪个对象的方法。同理，static方法也不能访问非static类型的变量。
4、static代码块在类中是独立于成员变量和成员函数的代码块的。注意：这些static代码块只会被执行一次
5、static（内部）类可以被其他类实例化和引用（即使它是顶级类）。
6、static与final结合使用表示的意思：
对于变量，若使用static final修饰，表示一旦赋值不能修改，并且通过类名可以访问。
对于方法，若使用static final修饰，表示该方法不可被覆盖，并且可以通过类名直接访问。

**synchronized（线程、同步）

1、synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。
2、synchronized 关键字可防止代码的关键代码段一次被多个线程执行。
3、如果应用于静态方法，那么，当该方法一次由一个线程执行时，整个类将被锁定。
4、如果应用于实例方法，那么，当该方法一次由一个线程访问时，该实例将被锁定。
5、如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。**
（1）请你谈谈关于Synchronized和lock ：
synchronized是Java的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。JDK1.5以后引入了自旋锁、锁粗化、轻量级锁，偏向锁来有优化关键字的性能。
Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
由于定义类与类之间关系的的关键字
（2） 请你介绍一下Syncronized锁，如果用这个关键字修饰一个静态方法，锁住了什么？如果修饰成员方法，锁住了什么？
synchronized修饰静态方法以及同步代码块的synchronized (类.class)用法锁的是类，线程想要执行对应同步代码，需要获得类锁。
synchronized修饰成员方法，线程获取的是当前调用该方法的对象实例的对象锁。
extends（继承、扩展）
1、extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。
2、子类继承父类的所有 public 和 protected 变量和方法。
3、子类可以重写父类的任何非 final 方法。
4、一个类只能扩展一个其他类。

implements(实现)

1、implements 关键字在 class 声明中使用，以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。2、类必须提供在接口中所声明的所有方法的实现。
3、一个类可以实现多个接口。

由于定义建立实例及引用实例，判断实例的关键字
new （新，创建）

1、new 关键字用于创建类的新实例。
2、new 关键字后面的参数必须是类名，并且类名的后面必须是一组构造方法参数（必须带括号）。
3、参数集合必须与类的构造方法的签名匹配。
4、= 左侧的变量的类型必须与要实例化的类或接口具有赋值兼容关系。

this（本类）

1、this 关键字用于引用当前实例。
2、当引用可能不明确时，可以使用 this 关键字来引用当前的实例。

super（父类、超类）

1、super 关键字用于引用使用该关键字的类的超类。
2、作为独立语句出现的 super 表示调用超类的构造方法。
3、super.() 表示调用超类的方法。只有在如下情况中才需要采用这种用法：要调用在该类中被重写的方法，以便指定应当调用在超类中的该方法。

instanceof（实例）

1、instanceof 关键字用来确定对象所属的类。

用于处理异常的关键字
try（捕获异常）

1、try 关键字用于包含可能引发异常的语句块。
2、每个 try 块都必须至少有一个 catch 或 finally 子句。
3、如果某个特定异常类未被任何 catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。

catch（处理异常）

1、catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。
2、开始和结束标记 { 和 } 是 catch 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。

finally（必须执行）

1、finally关键字用来定义始终在try-catch-finally语句中执行的块。
2、finally块通常包含清理代码，用在部分执行try块后恢复正常运行。
3、finally块的return语句优先执行。

throw（抛出一个异常对象）

1、throw 关键字用于引发异常。
2、throw 语句将 java.lang.Throwable 作为参数。Throwable 在调用栈中向上传播，直到被适当的 catch 块捕获。
3、引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。

throws（声明一个异常可能被抛出）

1、throws 关键字可以应用于方法，以便指出方法引发了特定类型的异常。
2、throws 关键字将逗号分隔的 java.lang.Throwables 列表作为参数。
3、引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。
4、要在 try-catch 块中包含带 throws 子句的方法的调用，必须提供该方法的调用者。

用于包的关键字
package（包）

1、package 关键字指定在 Java 源文件中声明的类所驻留的 Java 包。
2、package 语句（如果出现）必须是 Java 源文件中的第一个非注释性文本。

例:java.lang.Object。
如果 Java 源文件不包含 package 语句，在该文件中定义的类将位于“默认包”中。请注意，不能从非默认包中的类引用默认包中的类。

import（引入）

1、import 关键字使一个包中的一个或所有类在当前 Java 源文件中可见。可以不使用完全限定的类名来引用导入的类。
2、当多个包包含同名的类时，许多 Java 程序员只使用特定的 import 语句（没有“*”）来避免不确定性。

请你介绍一下volatile？

volatile关键字是用来保证有序性和可见性的。这跟Java内存模型有关。比如我们所写的代码，不一定是按照我们自己书写的顺序来执行的，编译器会做重排序，CPU也会做重排序的，这样的重排序是为了减少流水线的阻塞的，引起流水阻塞，比如数据相关性，提高CPU的执行效率。需要有一定的顺序和规则来保证，不然程序员自己写的代码都不知带对不对了，所以有happens-before规则，其中有条就是volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；有序性实现的是通过插入内存屏障来保证的。可见性：首先Java内存模型分为，主内存，工作内存。比如线程A从主内存把变量从主内存读到了自己的工作内存中，做了加1的操作，但是此时没有将i的最新值刷新会主内存中，线程B此时读到的还是i的旧值。加了volatile关键字的代码生成的汇编代码发现，会多出一个lock前缀指令。Lock指令对Intel平台的CPU，早期是锁总线，这样代价太高了，后面提出了缓存一致性协议，MESI，来保证了多核之间数据不一致性问题。

r_FFFFFF,t_70#pic_center)添加链接描述