java部分关键字总结
abstract
抽象，用于定义抽象类，抽象函数。
抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。
用法规则：
-
用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，这个方法叫做抽象方法；
-
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；
-
abstract类可以扩展（增加子类），但不能直接实例化；
-
一旦类中包含了abstract方法，那类该类必须声明为abstract类。
-
抽象类中不一定要包含abstract方法。
用法示例：
abstract int add(int x,int y);
int sub(int x,int y) {
return x-y;
}
}
class B extends A {
int add(int x,int y) { //子类必须重写父类的add方法
return x+y;
}
}
public class Example5_12 {
public static void main(String args[]) {
B b=new B();
int sum=b.add(30,20); //调用子类重写的add方法
int sub=b.sub(30,20); //调用子类继承的sub方法
System.out.println("sum="+sum); //输出结果为sum=50
System.out.println("sum="+sub); //输出结果为sum=10
A a; //抽象类声明对象
a = b; //a是b的上转型对象
sum=a.add(30,20); //调用子类重写的方法
sub=a.sub(30,20); //调用子类继承的方法
System.out.println("sum="+sum); //输出结果为sum=50
System.out.println("sum="+sub); //输出结果为sum=10
}
}
interface
接口，用于声明新的java接口，接口是方法的集合.接口就是用来被继承，被实现的，修饰符一般用public
用法规则：
-
常量：接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上。
-
方法：接口的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上。(但是在后续的1.8版本中 取消了该定义 即接口之中也能有实现的方法)
-
接口引用可以指向实现该接口的对象
用法示例：
[修饰符] (abstract) interface 接口名[extends 父接口1,父接口2...] //接口可继承多个父接口（即：接口是多继承的）;abstract若没写，系统会自动加上
{
0个到多个常量定义...
0个到多个抽象方法的定义...
}
//定义一个接口Output
interface Output
{
//接口里只能把属性定义成常量
int MAX_CACHE_LINE = 50;//主要是定义存储空间
//接口里定义的只能是public的抽象方法
void out();
void getData(String msg);
}
//定义一个接口Product
interface Product
{
int getProduceTime(int a);
}
//让printer类实现定义的接口
public class Printer implements Output,Product
{
private String [] printData = new String[MAX_CACHE_LINE];
private int dataNum =0;
public void out()//重写父接口Output的方法
{
while(dataNum>0)
{
System.out.println("打印机打印"+printData[0]);
System.arraycopy(printData,1,printData,0,--dataNum);
}
}
public void getData(String msg)//重写父接口Output的方法
{
if(dataNum>=MAX_CACHE_LINE)
{
System.out.println("已满");
}
else
{
printData[dataNum++] = msg;
}
}
public int getProduceTime(int a)//重写父接口Product的方法
{
return a = a;
}
public static void main(String[] args)
{
//父接口可声明变量，但是不能创建实例，多态：声明的是Output，但是创建的实例是Printer
Output O= new Printer();
O.getData("xiuxiu");
O.out();//直接调用输出的方法
//父接口可声明变量，但是不能创建实例，多态：声明的是Output，但是创建的实例是Printer
Product p = new Printer();
System.out.println(p.getProduceTime(82));
//所有接口类型的引用变量都可以直接赋值给Object类型的变量
Object obj = p;
Object obj1 = O;
}
}
接口和抽象类的异同
相同：
1、都有抽象方法。
2、都不能创建实例。
3、子类继承其后都必须全部实现其内的抽象方法，如果没有全部实现的话，类只能定义成抽象类。
不同：
1、接口里只能有抽象方法，抽象类里可以有普通方法。（1.8之后不是了）
2、接口类里的属性默认有修饰语public static final，但是抽象类中的属性可以是普通的。
3、接口没有初始化块，抽象类里有。
4、接口可以有多个父接口，但是抽象类只能有一个父类。
final
用法规则
用于变量、方法、类。
-
对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
-
当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
-
使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。类中所有的private方法都隐式地指定为final。
用法示例
class Person{
public final String getName(){
return "personal loan"
}
}
class loan extends Person{
@Override
public final Stirng getName(){
return "cheap personal loan";//compilation error: overridden method is final
}
}
使用final的好处：
-
final关键字提高了性能。JVM和Java应用都会缓存final变量。
-
final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
-
使用final关键字，JVM会对方法、变量及类进行优化。
static
在《Java编程思想》P86页有这样一段话：
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
用于定义静态成员变量或方法，也就是成为附属于类的变量或方法。因此可以从类外部直接调用，而不用先实例化该类。类的成员变量在类的所有实例中只存在一个。
一句话就是方便在没有创建对象的情况下来进行调用（方法/变量）。
用法规则
-
修饰成员变量和成员方法: 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。
-
静态代码块: 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次
-
静态内部类（static修饰类的话只能修饰内部类）： 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
-
静态导包(用来导入类中的静态资源，1.5之后的新特性): 格式为：
import static这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。 -
static不会影响作用域
-
static是不允许用来修饰局部变量
用法示例
public class Test extends Base{
static{
System.out.println("test static");
}
public Test(){
System.out.println("test constructor");
}
public static void main(String[] args) {
new Test();
}
}
class Base{
static{
System.out.println("base static");
}
public Base(){
System.out.println("base constructor");
}
}
输出结果：
base static
test static
base constructor
test constructor
this
this关键字用于引用类的当前实例。
用法规则
-
this 调用本类中的其他构造方法时，也要放在首行。
-
this不能用在static方法中。
用法示例
class Manager {
Employees[] employees;
void manageEmployees() {
int totalEmp = this.employees.length;
System.out.println("Total employees: " + totalEmp);
this.report();
}
void report() { }
}
super
super关键字用于从子类访问父类的变量和方法。
用法规则：
-
super 调用父类中的其他构造方法时，调用时要放在构造方法的首行！
-
super不能用在static方法中。
用法示例：
public class Super {
protected int number;
protected showNumber() {
System.out.println("number = " + number);
}
}
public class Sub extends Super {
void bar() {
super.number = 10;
super.showNumber();
}
}
synchronized
(待补充)
volatile
（待补充）
参考文章：
https://www.cnblogs.com/yihujiu/p/5990622.html
https://blog.csdn.net/rain722/article/details/78929943
