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

https://www.cnblogs.com/chihirotan/p/6044056.html

https://www.cnblogs.com/dolphin0520/p/3799052.html