Java中的几种关键字详细介绍（秋招总结篇）

前言：
本篇文章主要讲解Java中的几种关键字相关知识。该专栏比较适合刚入坑Java的小白以及准备秋招的大佬阅读。

如果文章有什么需要改进的地方欢迎大佬提出，对大佬有帮助希望可以支持下哦~

小威在此先感谢各位小伙伴儿了😁

以下正文开始

Java中的this关键字

Java 中的 this 关键字是一个引用类型变量，用于表示当前对象的引用。当方法中需要调用当前对象的成员变量或成员方法时，可以使用 this 关键字。

在 Java 类中，实例变量和局部变量可能会有相同的名称，因此使用 this 关键字可以区分它们。当代码中出现 this 关键字时，编译器会优先解析为实例变量，如果实例中不存在该变量，则解析为局部变量。

除了用于区分变量之外，this 关键字还可以用于以下几个方面：

• 在构造函数中调用其他的构造函数：
  在类中定义多个构造函数时，可以使用 this 关键字来调用同一类中的其他构造函数，以达到代码重用的目的。如果在一个构造函数中调用另一个构造函数，必须将 this() 作为构造函数的第一条语句使用。

• 返回当前对象
  在某些情况下，需要返回当前对象，可以使用 this 关键字来实现。例如，在链式编程中，每个方法调用都需要返回当前对象，这样可以使代码更加简洁明了。

• 传递当前对象给其他方法或构造函数
  在调用其他方法或构造函数时，可以将当前对象作为参数传递给它们，以便其他方法或构造函数能够访问和操作当前对象。

Java中的super关键字

super 关键字用于访问父类中的成员变量、成员方法和构造方法，在子类中使用 super 关键字可以引用父类的成员。super 有以下几种用法：

访问父类的成员变量

public class Parent {
    public int x = 10;
}

public class Child extends Parent {
    public int x = 20;
    
    public void print() {
        System.out.println("Child x: " + x);
        System.out.println("Parent x: " + super.x);
    }
}

public static void main(String[] args) {
    Child child = new Child();
    child.print();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，Child 类继承了 Parent 类，并声明了一个同名的 x 变量。通过 super.x 可以访问父类中的 x 值。

访问父类的成员方法

public class Parent {
    public void hello() {
        System.out.println("Hello from parent");
    }
}

public class Child extends Parent {
    public void hello() {
        super.hello();
        System.out.println("Hello from child");
    }
}

public static void main(String[] args) {
    Child child = new Child();
    child.hello();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的代码中，Child 类重写了 Parent 类的 hello() 方法，使用 super.hello() 调用了父类中的方法并在子类中添加了自己的实现。

调用父类的构造方法

public class Parent {
    public Parent(int x) {
        System.out.println("Parent constructor with x = " + x);
    }
}

public class Child extends Parent {
    public Child() {
        super(10);
    }
}

public static void main(String[] args) {
    Child child = new Child();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上面的代码中，Child 类调用了父类中的有参构造函数，使用 super(10) 可以传递参数给父类的构造方法。

需要注意的是，super 关键字必须放在子类构造方法的第一行，而且只能使用一次。同时，如果子类没有显式地调用父类的构造函数，Java 编译器会隐式地插入一个父类默认构造函数的调用语句。

Java中的static关键字

在Java中，static关键字可以用来修饰类的成员变量、方法和代码块。当用Static修饰类的成员时，它代表这个成员属于整个类，而不是某个对象实例。换句话说，无论创建多少个对象，静态成员只会被创建一次并共享。

下面我们来详细介绍Java中static关键字的几种用法：

静态变量

被static修饰的成员变量称为静态变量或者类变量。静态变量存储在静态存储区，不属于任何一个对象，仅在程序执行期间存在一份内存。除非显式地对它赋值，否则它默认被初始化为0或null。

public class Example {
    static int age;
    public static void main(String[] args){
        System.out.println(age);    //输出0
    }
}
1
2
3
4
5
6

静态方法

被static修饰的方法称为静态方法或类方法。它们被设计成仅与类本身有关联。静态方法中不能使用this和super关键字，因为它们都与具体的对象相关。既然静态方法不依赖于对象，所以它可以在没有任何实例的情况下被调用。

public class Example {
    public static void show(){
        System.out.println("This is a static method");
    }
    public static void main(String[] args){
        Example.show(); //无需实例化就可以调用Static方法
    }
}
1
2
3
4
5
6
7
8

静态代码块

静态代码块称为类初始化块，在类被加载时自动执行。它们仅能访问静态成员并支持使用static关键字来声明变量和方法。

public class Example {
    static{
        System.out.println("This is a Static Block");
    }
    public static void main(String[] args){
        System.out.println("Main method Executed..");
    }
}
1
2
3
4
5
6
7
8

上面是Java中对Static关键字的三种常见应用，但是我们在使用的过程中还需要注意以下几点：

静态方法只能访问到类变量和其他静态方法。
非静态方法可以访问到类变量，非静态变量，其他非静态方法和静态变量/方法。
Static方法不能以任何方式引用当前对象的实例。 不能在静态方法内部使用this关键字，或者向它传递任何参数。

Java中的final关键字

在Java中，final关键字可以用来修饰类、方法以及变量。它表示其修饰的内容不可改变，对于类、方法和变量分别有不同的含义：

1.final修饰类
被final修饰的类不能被继承，即该类不允许有子类。通常情况下使用final类是为了防止子类修改父类的行为，从而确保类的安全性和一致性。例如，在Java Collection Framework中的很多类都被声明为final。

final class Example {
    //....
}
1
2
3

2.final修饰方法
被final修饰的方法不能被子类重写，也就是说，该方法已经是最终实现。与final类一样，这种行为也能够有效保护代码的完整性和安全性。但需要注意的是，final方法并不一定要有方法体，因为它们可能只是一些接口规范。

class Example {
    public final void show(){
        System.out.println("This method is final and can't be overriden");
    }
}
1
2
3
4
5

3.final变量
被final修饰的变量称为常量，其赋值后不能再被修改。常量可以在运行时初始化，也可以在编译时通过直接赋值或构造函数进行初始化。Java开发人员通常将常量用于在程序中使用固定的数值或字符串。传统上我们推荐使用大写字母来表示常量。

final int AGE = 20;
final String NAME = "Xiaowei";
1
2

我们需要注意，当final变量引用一个对象时，只是意味着该变量不能在执行期间重新指向另一个对象，而并不阻止对象本身的状态被修改。

文章到这里就先结束了，感兴趣的可以订阅专栏哈，后续会继续分享相关的知识点。