Monodyee

这个屌丝很懒，什么也没留下！

热门标签

Java常用关键字_java关键字

作者：Monodyee | 2024-03-05 22:39:22

踩

java关键字

一、前言

本文介绍六个关键字：static、final、extends、implements、this、super，下面具体介绍各个关键字及需要注意的点。

二、Java 51个关键字

记住1：两个保留字：const和goto (保留字：现在没用，以后用得上)

记住2：所有的关键字都是小写，一旦有大写的，一定不是关键字

三、关键字static

static是java中的一个关键字（key words）,其表示的含义在于被static修饰的域、方法、代码块为类所有，而不是为代码所有，使用类名调用（亦可使用对象名调用），static域加载时仅加载一次。

第一点，非static方法、代码块内可以有非static域、方法、代码块，也可以有static域、方法、代码块；但是static方法、代码块内可以只能出现static域、方法、代码块，即static域、方法、代码块仅出现在static环境（static方法、代码块）下，static域只能出现在static方法或代码块中，static方法只能在static方法或代码块中被调用。如图1所示。

图1 外层环境与内部变量之间的关系

第二点，static方法可以用类名调用，也可以用对象名调用，但是非static方法只能由对象名调用调用，因为非static方法只有在对象存在时才有意义，如图2所示。

图2 static方法和非static方法调用方式

类变量
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。类变量：使用 static 关键字修饰的成员变量。

・定义格式：

static 数据类型变量名；

静态方法

当 static 修饰成员方法时，该方法称为类方法。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。类方法：使用 static 关键字修饰的成员方法，习惯称为静态方法。

・定义格式：

修饰符 static 返回值类型方法名 (参数列表){// 执行语句}

・静态方法调用的注意事项：

1. 静态方法可以直接访问类变量和静态方法。(静态方法只能访问静态成员。)

2. 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

3. 静态方法中，不能使用 this 关键字。


public class MyClass {
 
    int num; // 成员变量
    static int numStatic; // 静态变量
 
    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }
 
    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态不能直接访问非静态
//        System.out.println(num); // 错误写法！
 
        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }
 
}

・调用格式
被 static 修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：// 访问类变量类名.类变量名；// 调用静态方法类名.静态方法名(参数)；

静态原理图解

static 修饰的内容是随着类的加载而加载的，且只加载一次。

存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

它优先于对象存在，所以，可以被所有对象共享。

静态代码块
静态代码块：定义在成员位置，使用 static 修饰的代码块{ }。位置：类中方法外。执行：随着类的加载而执行且执行一次，优先于 main 方法和构造方法的执行。格式：

public class ClassName{static {// 执行语句}}

作用：给类变量进行初始化赋值。

四、关键字final

4.1 概要

Java语言中final是一个关键字（key words）,其表示的三个含义：final修饰的变量是常量，final修饰的类不可继承，final修饰的方法不可重写。

final关键字三个特性：final修饰的变量为常量、final修饰的类不可继承、final修饰的方法不可重写。

4.2 final修饰的变量为常量

4.2.1 基本类型与引用类型

对于final修饰的变量，应该对基本类型和引用类型分开讨论：

4.2.1.1 基本类型（byte short int long float double boolean char)

基本类型为栈内存（-128~127情况下），一旦被final关键字修饰，其变量属性变为只读，不再进行写操作，否则编译报错。

4.2.1.2 引用类型（类、接口、数组）

引用类型为堆内存，一旦被final关键字修饰，则引用不再改变，但是引用所指向的对象是可以被修改的，Java语言并未提供任何方式使用对象恒定不变。示意代码如下：


public class FinalData {
private final Value value=new Value(22);
public static void main(String[] args) {
	FinalData finalData=new FinalData();
	
	//finalData.value=new Value(33);   //编译报错    value为final类型   
	finalData.value.i++; // 编译通过  value所指向的对象可以修改 
}
}
class Value{
	int i;
	public Value(int i){
		this.i=i;
	}
}

4.2.2 初始化时机

4.2.2.1 final变量定义时初始化

final变量定义时初始化常见，定义时直接赋值即可，不再赘言。

4.2.2.2 final变量构造函数中初始化（空白final）

因为被final修饰的变量一定要在使用前被初始化，所以如果没在定义操作，一定在构造函数中初始化，这种情况称为空白final。示例代码如下：


public class FinalData {
	private final int i;//基本类型示意
private final Value value;//引用类型示意
public FinalData(){ //  无参构造函数    空白final
	i=1;
	value=new Value(1);
}
public FinalData(int x){//有参构造函数  空白final
	i=x;
	value=new Value(x);
}
 
public static void main(String[] args) {
	new FinalData();
	new FinalData(22);
 
}
}
class Value{
	int i;
	public Value(int i){
		this.i=i;
	}
}

4.3 final修饰的类不可继承

类使用final关键字修饰之后，该类不可被继承，可以起到保护该类的作用。实例代码如下：


final class FinalFatherClass{
	
}
class SonClass extends FinalFatherClass{  //编译报错   final类不允许继承
	
}

4.4 final修饰的方法不可重写


class FinalFatherClass{
	final void f(){
		System.out.println("FinalFatherClass f()");
	}
}
class SonClass extends FinalFatherClass{  
	final void f(){//编译报错    
// 子类中某一方法的方法签名（方法名+形参列表）与父类相同，即可认为子类中该方法重写父类方法
//因final方法不可被重写，顾此处编译报错
		System.out.println("SonClass f()");
	}
}

值得注意的是，子类虽不能重写父类final函数，但是可以继承父类final函数，示意代码如下：


public class TestFinal {
public static void main(String[] args){
	FinalFatherClass son=new SonClass();
	son.f();    //打印  FinalFatherClass f()
	//因为子类未重写父类final函数，也不能重新父类final函数    
	//但子类可以继承父类final函数，所以调用父类 f()  打印  FinalFatherClass f() 
 
}
}
class FinalFatherClass{
	final void f(){
		System.out.println("FinalFatherClass f()");
	}
}
class SonClass extends FinalFatherClass{ 
	
}

从上面可以看到，final修饰的方法在特定的访问权限下可以被继承。

这是因为，方法是否被final修饰与方法的访问权限是两回事，没有任何关系，被final修饰的方法和未被final修饰的方法都可以自由的指定访问权限。

我们有兴趣去谈论final关键字和访问权限关键字在修饰方法的过程的起到的作用，如下表（声明：final和访问权限是两个独立的概念，没有任何比较意义，所有本表仅方便读者理解，不可作为正统知识）：

小结 private<final<protect （仅适用于方法）

从表中可以看到，protect修饰的方法在子类中可见，所有可以被子类继承，亦可以被子类重写；

final修饰的方法可以被子类继承，但不可被子类重写（这里final方法的访问权限为默认的default、protected、public均可，只要保证子类可见即可）;

private修饰的方法由于仅本类可见，故不能被子类继承，亦不能被子类重写。

4.5 private与final对比

实际上，Java语言中，所有被private关键字修饰的方法都隐式的被final关键字修饰，（正如上表所示，private实现了final方法不可重写的功能，并附加不可继承功能。）（再次声明：final和访问权限是两个独立的概念，没有任何比较意义，所有上表仅方便读者理解，不可作为正统知识）可以对private方法添加final关键字，但是这种做法没有任何意义。代码示例如下：


public class TestFinal {
public static void main(String[] args){
	FinalFatherClass fatherClass=new FinalFatherClass();
 
SonClass sonClass=new SonClass();
//fatherClass.f();   //f() 为final方法  被private修饰后 仅本类可见  所有不能到TestFinal类中调用
//sonClass.f();
 
//fatherClass.g();   //g() 虽然不是final方法  但被private修饰后 也是仅本类可见  所有不能到TestFinal类中调用
//sonClass.g();
 
//小结：java中，private方法已经隐式的包含final关键字     所以final关键字有无并不重要
}
}
class FinalFatherClass{
	private final void f(){
		System.out.println("FinalFatherClass f()");
	}
	private void g(){
		System.out.println("FinalFatherClass g()");
	}
}
class SonClass extends FinalFatherClass{ 
	private final void f(){
		System.out.println("SonClass f()");
	}
	private void g(){
		System.out.println("SonClass g()");
	}
}

4.6 面试金手指（已经组织好语言，背下来）

本文介绍final关键字，分别介绍了：

final关键字修饰变量，将变量变成常量，一般用来设置全局变量；

final关键字修饰类，将类变为不可以被继承的类；

final关键字修饰方法，将方法变为不可被重写的方法（但是可以被继承，只要是在该方法的访问控制权限允许的情况下）；

最后讨论final关键字和访问控制权限的关系，对比了private和final，从某种意义上来说，final是介于protected和private之间的一种访问权限（虽然不准确，但是至少可以这样理解）。

五、关键字extends和implements

Java中单继承多实现，先继承后实现（即当一个类既要继承又要实现的时候，顺序是先继承后实现 eg: extends A implements B）。

5.1 类继承类（单继承）


class SuperA {
	
}
class SuperB{
	
}
class Sub extends SuperA{//类继承类   只能继承一个类   单继承
	
}

5.2 类实现接口（多实现）


interface InterfaceA {
	
}
interface InterfaceB{
	
}
class Sub implements InterfaceA,InterfaceB{//类实现接口  可以实现多个接口  Java多实现
	
}

5.3 接口继承接口（多继承）

接口继承接口容易被人遗忘，一般我们只记得类继承类和类实现接口，但接口直接也可以相互继承，而且还是多继承。


interface InterfaceA {
	
}
interface InterfaceB{
	
}
interface InterfaceC extends InterfaceA,InterfaceB{//接口继承接口  可以多继承
	
}

六、关键字this与super

6.1 this与super(面试金手指，背下来)

this表示当前类所指对象，super表示父类对象的引用

6.2 代码分析

6.2.1 父类构造函数和子类构造函数

代码示意：


public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
	}
 
}
 
class Game {
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
 
}
 
class BallGame extends Game {
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
}

输出结果：


=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall

6.2.1.1 附加：默认调用父类无参构造函数


public class Test1 {
 
    public static void main(String[] args) {
        System.out.println("=====无参构造函数=====");
        new BallGame();
        System.out.println("=====带参构造函数=====");
        new BallGame("basketBall");
    }
 
}
 
class Game {
    public Game() {
        System.out.println("Game non-parameter constructor");
    }
 
    public Game(String name) {
        System.out.println("Game parameter constructor: " + name);
    }
 
}
 
class BallGame extends Game {
    public BallGame() {
        super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
        System.out.println("BallGame non-parameter constructor");
    }
 
    public BallGame(String name) {
      //  super(name);
        System.out.println("BallGame parameter constructor: " + name);
    }
}

运行结果：


=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game non-parameter constructor
BallGame parameter constructor: basketBall

6.2.2 父类字段和子类字段

代码示意：


public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
 
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);
	}
}

输出结果：


=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall
=====打印字段=====
父类字段： This is an interesting game
子类字段： This is an interesting ballgame

6.2.3 父类方法和子类方法

代码示意：


public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
		System.out.println("=====打印方法调用=====");
		_ballGame_noParameter.displayFunction();
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
	
    protected void  playing() {
	    System.out.println("This game is so interesting");
    }
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);//此处this可以省略
	}
	
	protected void  playing() {
		System.out.println("This ballgame is so interesting");
	}
	
	public void displayFunction(){
		System.out.print("父类方法： ");
		super.playing();
		System.out.print("子类方法： ");
		this.playing();//此处this可以省略
	}
}

输出结果：


=====无参构造函数=====
Game non-parameter constructor
BallGame non-parameter constructor
=====带参构造函数=====
Game parameter constructor: basketBall
BallGame parameter constructor: basketBall
=====打印字段=====
父类字段： This is an interesting game
子类字段： This is an interesting ballgame
=====打印方法调用=====
父类方法： This game is so interesting
子类方法： This ballgame is so interesting

6.2.4 this和super同时出现

子类构造函数中可以同时出现super和this关键字，但是super和this不能同时调用构造函数，代码示意：


public class Test_thisAndSuper {
 
	public static void main(String[] args) {
		System.out.println("=====无参构造函数=====");
		BallGame _ballGame_noParameter=new BallGame();
		System.out.println("=====带参构造函数=====");
		new BallGame("basketBall");
		System.out.println("=====打印字段=====");
		_ballGame_noParameter.displayField();
		System.out.println("=====打印方法调用=====");
		_ballGame_noParameter.displayFunction();
		
	}
 
}
 
class Game {
	protected String _description="This is an interesting game";
	public Game() {
		System.out.println("Game non-parameter constructor");
	}
 
	public Game(String name) {
		System.out.println("Game parameter constructor: " + name);
	}
	
 
protected void  playing() {
	System.out.println("This game is so interesting");
}
}
 
class BallGame extends Game {
	protected String _description="This is an interesting ballgame";
	public BallGame() {
		super();// 此行代码 可有可无 Java中，子类构造函数可以隐式调用父类无参构造函数
		System.out.println("BallGame non-parameter constructor");
	}
 
	public BallGame(String name) {
		super(name);
		System.out.println("BallGame parameter constructor: " + name);
	}
	public BallGame(String test1,String test2){
		//super(test1);
		//this(test1);  super()和this()都要放在第一行  自相矛盾  编译时报错
		//小结:super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法，
		
		//理论解释：因为在一个构造方法中，只能访问一次其它的构造方法（不管是父类的还是子类的）所以此时不能同时用super和this关键字来调用构造方法，只能根据需求选其一。
		//简单理解：调用构造函数时，两个都要放第一，自相矛盾
	}
	public void displayField(){
		System.out.println("父类字段： "+super._description);
		System.out.println("子类字段： "+this._description);//此处this可以省略
	}
	
	protected void  playing() {
		System.out.println("This ballgame is so interesting");
	}
	
	public void displayFunction(){
		System.out.print("父类方法： ");
		super.playing();
		System.out.print("子类方法： ");
		this.playing();//此处this可以省略
	}
}

输出结果：

因不可同时调用父类构造函数和子类构造函数，无输出结果

小结（面试金手指，this与super同时出现）

1、super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法；

2、理论解释：因为在一个构造方法中，只能访问一次其它的构造方法（不管是父类的还是子类的）所以此时不能同时用super和this关键字来调用构造方法，只能根据需求选其一；

3、简单理解：调用构造函数时，两个都要放第一，自相矛盾。

七、面试金手指

7.1 static关键字（定义+第一点main方法+第二点）

定义：static修饰的域、方法、代码块为类所有，而不是为对象所有；

调用：可以使用类名调用（亦可使用对象名调用）；

变量加载顺序：static域加载时仅加载一次（基础面试题第一篇，变量加载顺序）。

第一点，static方法、代码块内可以只能出现static域、方法、代码块，最常见的就是main方法，static方法只能出现static变量。

第二点，非static方法只能由对象名调用调用，因为非static方法只有在对象存在时才有意义。

7.2 final关键字（final变量、final类、final方法、final与private protected）

final关键字三个特性：final修饰的变量为常量、final修饰的类不可继承、final修饰的方法不可重写。

第一，final修饰的变量为常量

对于final修饰的变量，应该对基本类型和引用类型分开讨论：

基本类型为栈内存（-128~127情况下），一旦被final关键字修饰，其变量属性变为只读，不再进行写操作，否则编译报错。


FinalData finalData=new FinalData();	
//finalData.value=new Value(33);   //编译报错    value为final类型   
finalData.value.i++; // 编译通过  value所指向的对象可以修改

final变量的两个初始化时机：final变量定义时初始化、final变量构造函数中初始化（空白final）

第二， final修饰的类不可继承

第三，final修饰的方法不可重写，但是可以被继承，子类可见

ps:方法是否被final修饰与方法的访问权限是两回事，没有任何关系，被final修饰的方法和未被final修饰的方法都可以自由的指定访问权限。

附加：对于final方法 private<final<protect （仅适用于方法）

protect修饰的方法在子类中可见，所有可以被子类继承，亦可以被子类重写；

final修饰的方法可以被子类继承，但不可被子类重写（这里final方法的访问权限为默认的default、protected、public均可，只要保证子类可见即可）;

private修饰的方法由于仅本类可见，故不能被子类继承，亦不能被子类重写；

ps:对于方法，所有被private关键字修饰的方法都隐式的被final关键字修饰，可以对private方法添加final关键字，但是这种做法没有任何意义。

7.3 extends和implements关键字（记住三点）

类继承类（单继承）

类实现接口（多实现）

接口继承接口（多继承）

7.4 this和super关键字（记住五点:概要+构造函数+子类字段+子类方法+this与super同时出现）

this表示当前类所指对象，super表示父类对象的引用

第一，对于构造函数，对于super() 和 super(xxx) 默认调用父类无参构造函数

第二，子类字段和父类字段


public void displayField(){
	System.out.println("父类字段： "+super._description);
	System.out.println("子类字段： "+this._description);
}

第三，子类方法和父类方法


public void displayFunction(){
	System.out.print("父类方法： ");
	super.playing();
	System.out.print("子类方法： ");
	this.playing();//此处this可以省略
}

第四，this与super同时出现

1、super和this可以同时出现，即使是在子类构造方法中也可以同时出现，但是不同同时调用构造方法；

3、简单理解：调用构造函数时，两个都要放第一，自相矛盾。

原文：一文解析Java常用关键字 - 知乎 (zhihu.com)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/194300

Java常用关键字_java关键字

一、前言

二、Java 51个关键字

三、关键字static

四、关键字final

4.1 概要

4.2 final修饰的变量为常量

4.2.1 基本类型与引用类型

4.2.1.1 基本类型（byte short int long float double boolean char)

4.2.1.2 引用类型 （类、接口、数组）

4.2.2 初始化时机

4.2.2.1 final变量定义时初始化

4.2.2.2 final变量构造函数中初始化（空白final）

4.3 final修饰的类不可继承

4.4 final修饰的方法不可重写

4.5 private与final对比

4.6 面试金手指（已经组织好语言，背下来）

五、关键字extends和implements

5.1 类继承类（单继承）

5.2 类实现接口（多实现）

5.3 接口继承接口（多继承）

六、关键字this与super

6.1 this与super(面试金手指，背下来)

6.2 代码分析

6.2.1 父类构造函数和子类构造函数

6.2.1.1 附加：默认调用父类无参构造函数

6.2.2 父类字段和子类字段

6.2.3 父类方法和子类方法

6.2.4 this和super同时出现

七、面试金手指

7.1 static关键字（定义+第一点main方法+第二点）

7.2 final关键字（final变量、final类、final方法、final与private protected）

7.3 extends和implements关键字（记住三点）

7.4 this和super关键字（记住五点:概要+构造函数+子类字段+子类方法+this与super同时出现）

原文：一文解析Java常用关键字 - 知乎 (zhihu.com)

4.2.1.2 引用类型（类、接口、数组）