Java中常用关键字包括：static、extends、super、final、abstract、interface、implements。下面分别讲述这几个关键字：
具体解析链接：https://blog.csdn.net/TSY_1222/article/details/83150782
具体解析链接：https://blog.csdn.net/TSY_1222/article/details/83305714
重写父类的方法：解析链接：https://blog.csdn.net/TSY_1222/article/details/83384070
当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法、构造方法。具体用法如下：
1、使用super关键字调用父类的成员变量和成员方法。具体格式如下：
super.成员变量
super.成员方法([参数1，参数2······])
例如Test01.java
public class Test01 { public static void main(String[] args) { Dog dog = new Dog(); dog.shout(); dog.printName(); } } class Animal{ String name = "动物"; void shout(){ System.out.println("动物发出叫声"); } } class Dog extends Animal{ //定义Dog类继承动物类 String name = "犬类"; void shout(){ //重写父类的shout()方法 super.shout(); //调用父类被重写的方法 } void printName(){ System.out.println("name = "+super.name); //访问父类的成员变量 } } /* 运行结果： 动物发出叫声 name = 动物 */从运行结果可以看出，子类通过super关键字可以成功地访问父类成员变量、成员方法。
2、使用super关键字调用父类的构造方法。具体格式如下：
super([参数1，参数2······])
例如Test02.java:
public class Test02{ public static void main(String[] args) { Dog dog = new Dog(); //实例化子类Dog对象 } } class Animal{ public Animal(String name){ //定义Animal类有参的构造方法 System.out.println("这是一只"+name); } } class Dog extends Animal{ //定义Dog类继承动物类 public Dog(){ super("哈巴狗"); //调用父类有参的构造方法 } } /* 运行结果： 这是一只哈巴狗 */从运行结果可以看出，Dog类的构造方法被调用时父类的构造方法也被调用了。
注意：通过super关键字调用父类的构造方法的代码必须位于子类的第一行，并且只能出现一次。
final关键字可用于修饰类、变量、方法，它有“这是无法改变的”或者“最终”的含义。具有以下特性：
final修饰的类不能继承final修饰的方法不能被子类重写final修饰的变量(成员变量、局部变量)是常量，只能赋值一次Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰，abstract可以修饰类、方法，使用abstract关键字修饰的类为抽象类。具体格式如下：
abstract void shout() //定义抽象方法shout()
在定义抽象类是需注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需要使用abstract关键字修饰即可。另外，抽象类是不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法没有方法体，不可以被调用。如果想调用抽象类中定义的方法，则需创建一个子类，在子类中将抽象类中的抽象方法进行实现。
例如Test03.java:
public class Test03 { public static void main(String[] args) { Dog dog = new Dog(); dog.shout(); } } abstract class Animal{ //Animal为抽象类。不能被实例化 abstract void shout(); //只有方法头，没有方法体 } class Dog extends Animal{ //Dog类继承Animal类，为Animal的子类，可以被实例化 void shout(){ System.out.println("汪汪······"); } } /* 运行结果： 汪汪······ */
如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另一种方式定义，即接口。在定义接口时，需要用interface关键字来声明，具体示例如下：
interface Animal{
public static final int ID = 1; //定义全局变量
public abstract void breathe(); //定义抽象方法
public abstract void run(); //定义抽象方法
}
<———>
完全相等
interface Animal{
int ID = 1; //定义全局变量
void breathe(); //定义抽象方法
void run(); //定义抽象方法
}
上面的代码中，Animal为一个接口，且左右列都相等，因为接口中定义的方法和变量都包含一些默认修饰符。
接口中定义的方法默认使用“public abstract”来修饰，即抽象方法接口中的变量默认用“public static final”来修饰，即全局变量由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法，则需定义一个类，并使用implements关键字实现接口中所有的方法。
例如Test04.java:
public class Test04 { public static void main(String[] args) { Dog dog = new Dog(); dog.breathe(); dog.run(); } } interface Animal{ int ID = 1; //定义全局变量 void breathe(); //定义抽象方法breathe() void run(); //定义抽象方法run() } class Dog implements Animal{ //Dog类实现Animal接口 public void breathe(){ System.out.println("狗在呼吸"); } public void run(){ System.out.println("狗在跑"); } } /* 运行结果： 狗在呼吸 狗在跑 */从上述代码中看到，Dog类实现Animal接口用的implements关键字，说明implements关键字的作用是一个类实现某个接口。
在Test04中演示的是类与接口的实现关系，在程序中，还有接口与接口的关系，需用到extends关键字去继承。
例如Test05.java:
public class Test05{ public static void main(String[] args) { Dog dog = new Dog(); dog.breathe(); dog.run(); dog.LiveOnland(); } } interface Animal{ int ID = 1; //定义全局变量 void breathe(); //定义抽象方法breathe() void run(); //定义抽象方法run() } interface LandAnimal extends Animal{ //接口继承接口 void LiveOnland(); //定义抽象方法LiveOnland() } class Dog implements Animal{ //Dog类实现Animal接口 public void breathe(){ System.out.println("狗在呼吸"); } public void run(){ System.out.println("狗在跑"); } public void LiveOnland(){ System.out.println("狗生活在陆地上"); } } /* 运行结果： 狗在呼吸 狗在跑 狗生活在陆地上 */
