final、static、this、super 关键字总结

最新推荐文章于 2023-07-15 15:45:00 发布

Lao_Wu66

最新推荐文章于 2023-07-15 15:45:00 发布

阅读量382

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/Lao_Wu66/article/details/88868026

版权

java 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

在java中，this关键字有很多种用法。在java中，这是一个引用当前对象的引用变量。

java this关键字的用法如下：

this关键字可用来引用当前类的实例变量。
this关键字可用于调用当前类方法(隐式)。
this()可以用来调用当前类的构造函数。
this关键字可作为调用方法中的参数传递。
this关键字可作为参数在构造函数调用中传递。
this关键字可用于从方法返回当前类的实例。

建议：如果你是java初学者，只学习 this 关键字的前三个用法就可以了。

1. this：引用当前类的实例变量

this关键字可以用来引用当前类的实例变量。如果实例变量和参数之间存在歧义，则 this 关键字可用于明确地指定类变量以解决歧义问题。

了解没有 this 关键字的问题

下面先来理解一个不使用 this 关键字的示例：

class Student {
    int rollno;
    String name;
    float fee;

    Student(int rollno, String name, float fee) {
        rollno = rollno;
        name = name;
        fee = fee;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + fee);
    }
}

class TestThis1 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", 5000f);
        Student s2 = new Student(112, "sumit", 6000f);
        s1.display();
        s2.display();
    }
}

Java

执行上面代码输出结果如下 -

0 null 0.0
0 null 0.0

Java

在上面的例子中，参数(形式参数)和实例变量(rollno和name)是相同的。所以要使用this关键字来区分局部变量和实例变量。

使用 this 关键字解决了上面的问题

class Student {
    int rollno;
    String name;
    float fee;

    Student(int rollno, String name, float fee) {
        this.rollno = rollno;
        this.name = name;
        this.fee = fee;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + fee);
    }
}

class TestThis2 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", 5000f);
        Student s2 = new Student(112, "sumit", 6000f);
        s1.display();
        s2.display();
    }
}

Java

执行上面代码输出结果如下 -

111 ankit 5000
112 sumit 6000

Java

如果局部变量(形式参数)和实例变量不同，则不需要像下面的程序一样使用this关键字：

不需要 this 关键字的程序示例

class Student {
    int rollno;
    String name;
    float fee;

    Student(int r, String n, float f) {
        rollno = r;
        name = n;
        fee = f;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + fee);
    }
}

class TestThis3 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", 5000f);
        Student s2 = new Student(112, "sumit", 6000f);
        s1.display();
        s2.display();
    }
}

Java

执行上面代码输出结果如下 -

111 ankit 5000
112 sumit 6000

Java

对变量使用有意义的名称是一种好的编程习惯。所以使用相同名称的实例变量和参数，并且总是使用this关键字。

2. this：调用当前类方法

可以使用this关键字调用当前类的方法。如果不使用this关键字，编译器会在调用方法时自动添加此 this 关键字。我们来看看这个例子。

执行上面代码输出结果如下 -

hello n
hello m

Java

3. this()：调用当前类的构造函数

this()构造函数调用可以用来调用当前类的构造函数。它用于重用构造函数。换句话说，它用于构造函数链接。

从参数化构造函数调用默认构造函数：

class A {
    A() {
        System.out.println("hello a");
    }

    A(int x) {
        this();
        System.out.println(x);
    }
}

class TestThis5 {
    public static void main(String args[]) {
        A a = new A(10);
    }
}

Java

执行上面代码输出结果如下 -

hello a
10

Java

从默认构造函数调用参数化构造函数：

class A {
    A() {
        this(5);
        System.out.println("hello a");
    }

    A(int x) {
        System.out.println(x);
    }
}

class TestThis6 {
    public static void main(String args[]) {
        A a = new A();
    }
}

Java

执行上面代码输出结果如下 -

5
hello a

Java

使用this()构造函数调用

this()构造函数调用用于从构造函数重用构造函数。它维护构造函数之间的链，即它用于构造函数链接。看看下面给出的示例，显示this关键字的实际使用。

class Student {
    int rollno;
    String name, course;
    float fee;

    Student(int rollno, String name, String course) {
        this.rollno = rollno;
        this.name = name;
        this.course = course;
    }

    Student(int rollno, String name, String course, float fee) {
        this(rollno, name, course);// reusing constructor
        this.fee = fee;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + course + " " + fee);
    }
}

class TestThis7 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", "java");
        Student s2 = new Student(112, "sumit", "java", 6000f);
        s1.display();
        s2.display();
    }
}

Java

执行上面代码输出结果如下 -

111 ankit java null
112 sumit java 6000

Java

注意：调用this()必须是构造函数中的第一个语句。

下面示例为不把 this() 语句放在第一行，因此编译不通过。

class Student {
    int rollno;
    String name, course;
    float fee;

    Student(int rollno, String name, String course) {
        this.rollno = rollno;
        this.name = name;
        this.course = course;
    }

    Student(int rollno, String name, String course, float fee) {
        this.fee = fee;
        this(rollno, name, course);// C.T.Error
    }

    void display() {
        System.out.println(rollno + " " + name + " " + course + " " + fee);
    }
}

class TestThis8 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", "java");
        Student s2 = new Student(112, "sumit", "java", 6000f);
        s1.display();
        s2.display();
    }
}

Java

执行上面代码输出结果如下 -

Compile Time Error: Call to this must be first statement in constructor

Java

4. this：作为参数传递给方法

this关键字也可以作为方法中的参数传递。它主要用于事件处理。看看下面的一个例子：

class S2 {
    void m(S2 obj) {
        System.out.println("method is invoked");
    }

    void p() {
        m(this);
    }

    public static void main(String args[]) {
        S2 s1 = new S2();
        s1.p();
    }
}

Java

执行上面代码输出结果如下 -

method is invoked

Java

这个应用程序可以作为参数传递：

在事件处理(或)的情况下，必须提供一个类的引用到另一个。它用于在多个方法中重用一个对象。

this：在构造函数调用中作为参数传递

也可以在构造函数中传递this关键字。如果必须在多个类中使用一个对象，可以使用这种方式。看看下面的一个例子：

class B {
    A4 obj;

    B(A4 obj) {
        this.obj = obj;
    }

    void display() {
        System.out.println(obj.data);// using data member of A4 class
    }
}

class A4 {
    int data = 10;

    A4() {
        B b = new B(this);
        b.display();
    }

    public static void main(String args[]) {
        A4 a = new A4();
    }
}

Java

执行上面代码输出结果如下 -

Java

6. this关键字用来返回当前类的实例

可以从方法中 this 关键字作为语句返回。在这种情况下，方法的返回类型必须是类类型(非原始)。看看下面的一个例子：

作为语句返回的语法

return_type method_name(){  
    return this;  
}

Java

从方法中返回为语句的 this 关键字的示例

class A {
    A getA() {
        return this;
    }

    void msg() {
        System.out.println("Hello java");
    }
}

class Test1 {
    public static void main(String args[]) {
        new A().getA().msg();
    }
}

Java

执行上面代码输出结果如下 -

Hello java

Java

验证 this 关键字

现在来验证 this 关键字引用当前类的实例变量。在这个程序中将打印参考变量，这两个变量的输出是相同的。

class A5 {
    void m() {
        System.out.println(this);// prints same reference ID
    }

    public static void main(String args[]) {
        A5 obj = new A5();
        System.out.println(obj);// prints the reference ID
        obj.m();
    }
}

Java

执行上面代码输出结果如下 -

A5@22b3ea59
A5@22b3ea59

final 关键字
final关键字主要用在三个地方：变量、方法、类。

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

static 关键字
static 关键字主要有以下四种使用场景：

修饰成员变量和成员方法: 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量存放在 Java 内存区域的方法区。调用格式：类名.静态变量名类名.静态方法名()
静态代码块: 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。该类不管创建多少对象，静态代码块只执行一次.
静态内部类（static修饰类的话只能修饰内部类）：静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
静态导包(用来导入类中的静态资源，1.5之后的新特性): 格式为：import static 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。

super 关键字
super关键字用于从子类访问父类的变量和方法。例如：

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();
}
}

在上面的例子中，Sub 类访问父类成员变量 number 并调用其其父类 Super 的 showNumber（）方法。

使用 this 和 super 要注意的问题：

super 调用父类中的其他构造方法时，调用时要放在构造方法的首行！this 调用本类中的其他构造方法时，也要放在首行。
this、super不能用在static方法中。
简单解释一下：

被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而 this 代表对本类对象的引用，指向本类对象；而 super 代表对父类对象的引用，指向父类对象；所以， this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西。

Lao_Wu66

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
final、static、this、super 关键字总结

在java中，this关键字有很多种用法。在java中，这是一个引用当前对象的引用变量。java this关键字的用法如下：this关键字可用来引用当前类的实例变量。 this关键字可用于调用当前类方法(隐式)。 this()可以用来调用当前类的构造函数。 this关键字可作为调用方法中的参数传递。 this关键字可作为参数在构造函数调用中传递。 this关键字可用于从方法返回...
复制链接

扫一扫

专栏目录