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

最新推荐文章于 2023-06-07 17:19:55 发布

小绵羊~~

最新推荐文章于 2023-06-07 17:19:55 发布

阅读量75

点赞数

分类专栏：面试题文章标签： java

本文链接：https://blog.csdn.net/weixin_45769722/article/details/120615398

版权

面试题专栏收录该内容

8 篇文章 1 订阅

订阅专栏

文章目录

final，static，this，super关键字总结
static关键字详解
补充内容
- 静态方法和非静态方法
- static{}静态代码块与{}非静态代码块

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

1.final关键字

final关键字，意思是最终的、不可修改的，最见不得变化，用来修饰类，方法和变量，具有以下特点：

final修饰的类不能被继承，final类中的所有成员方法都会被隐式的指定为final方法
final修饰的方法不能被重写
final修饰的变量是常量，如果是其他数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。

说明：使用final的方法原因有两个：

1.把方法锁定，以防任何继承类修改它的含义

2.效率。在早期的Java实现版本中，会将final方法转为内嵌调用。

但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升

2. static关键字

四种使用场景：

**修饰成员变量和成员方法：**被static修饰的成员属于类，不属于单个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static声明的成员属于静态成员变量，静态变量存放在Java内存区域的方法区。调用格式：类名.静态变量名类名.静态方法名()

静态代码块：静态代码块定义在类中方法外，执行顺序：（静态代码块->非静态代码块->构造方法）。该类不管创建多少对象，静态代码块只执行一次。

静态内部类（static修饰类的话只能修饰内部类）：

静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：

1.它的创建不需要依赖外围类的创建。

2.它不能使用外围类的非static成员变量和方法

静态导包(用来导入类中的静态资源，1.5之后的新特性)：

格式为：import static这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法

3. this关键字

this关键字用于引用类的当前实例。例如：

class Manager {
    Employees[] employees;

    void manageEmployees() {
        int totalEmp = this.employees.length;
        System.out.println("Total employees: " + totalEmp);
        this.report();
    }

    void report() { }
}

在上面的示例中，this关键字用于两个地方：

this.employees.length：访问类Manager的当前实例的变量
this.report():调用Manager的当前实例的方法

此关键字是可选的，这意味着如果上面的示例在不适用此关键字的情况下表现相同。但是，使用关键字可能会使代码更易读或易懂

4. 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是属于对象范畴的东西，而静态方法属于类范畴的东西**

static关键字详解

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

修饰成员变量和成员方法
静态代码块
修饰类(只能修饰内部类)
静态导包(用来导入类中的静态资源，1.5 之后的新特性)

2. 修饰成员变量和成员方法(常用)

被static修饰的成员属于类，不属于单个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static声明的成员属于静态成员变量，静态变量存放在Java内存区域的方法区。

方法区与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap(非堆)，目的应该是与Java堆分开来

HotSpot虚拟机中方法区常被称为“永久代”，本质上两者并不等价。仅仅是因为HotSpot虚拟机设计团队用永久代来实现方法区而已，这样HotSpot虚拟机的垃圾收集器就可以像管理Java堆一样管理这部分内存，但是这样并不是一个好主意，因为这样容易遇到内存溢出问题

调用格式：类名.静态变量名类名.静态方法名()

如果变量或者方法被 private 则代表该属性或者该方法只能在类的内部被访问而不能在类的外部被访问。

测试方法：

public class StaticBean {

    String name;
    //静态变量
    static int age;

    public StaticBean(String name) {
        this.name = name;
    }
    //静态方法
    static void sayHello() {
        System.out.println("Hello i am java");
    }
    @Override
    public String toString() {
        return "StaticBean{"+
                "name=" + name + ",age=" + age +
                "}";
    }
}

public class StaticBean {

    String name;
    //静态变量
    static int age;

    public StaticBean(String name) {
        this.name = name;
    }
    //静态方法
    static void sayHello() {
        System.out.println("Hello i am java");
    }
    @Override
    public String toString() {
        return "StaticBean{"+
                "name=" + name + ",age=" + age +
                "}";
    }
}

3. 静态代码块

静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块 —> 非静态代码块 —> 构造方法)。该类不管创建多少对象，静态代码块只执行一次.

静态代码块的格式是

static {
语句体;
}

一个类中的静态代码块可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态代码块，如果静态代码块有多个，JVM会按照它们在类中出现的先后顺序依次执行它们，每个代码只会被执行一次。

静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问.

4. 静态内部类

它的创建是不需要依赖外围类的创建。
它不能使用任何外围类的非 static 成员变量和方法。

Example（静态内部类实现单例模式）

public calss Singleton{
    private Singleton(){
    }
    
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getUniqueInstance(){
        return SingletonHolder.INSTANCE;
    }
}

当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance()方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

5. 静态导包

格式为：import static

这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用静态成员，可以使用类中的静态成员变量和成员方法


 //将Math中的所有静态资源导入，这时候可以直接使用里面的静态方法，而不用通过类名进行调用
 //如果只想导入单一某个静态方法，只需要将*换成对应的方法名即可

import static java.lang.Math.*;//换成import static java.lang.Math.max;具有一样的效果

public class Demo {
  public static void main(String[] args) {

    int max = max(1,2);
    System.out.println(max);
  }
}

补充内容

静态方法和非静态方法

静态方法属于类本身，非静态方法属于从该类生成的每个对象。如果您的方法执行的操作不依赖于各个变量和方法，情将其设置为静态(这将使程序的占用空间更小)。否则，它应该是非静态的

Example

class Foo {
    int i;
    public Foo(int i) {
       this.i = i;
    }

    public static String method1() {
       return "An example string that doesn't depend on i (an instance variable)";

    }

    public int method2() {
       return this.i + 1;  //Depends on i
    }

}

你可以像这样调用静态方法：Foo.method1()。如果您尝试使用这种方法调用 method2 将失败。但这样可行

Foo bar = new Foo(1);
bar.method2();

总结：

在外部调用静态方法时，可以使用“类名.方法名”的方式，也可以使用“对象.方法名“的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象

静态方法在访问本类的成员时，值运行访问静态成员（即静态成员变量和静态方法），而不允许访问实例方法和变量；实例方法无此限制

static{}静态代码块与{}非静态代码块

相同点：都是在JVM加载类时且构造方法执行之前执行，在类中可以定义多个，定义多个按定义的顺序执行，一般在代码中对一些static变量进行赋值

不同点：静态代码在非静态代码之前执行(静态代码块->非静态代码块->构造方法)。静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。

一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法，例如：Arrays 类，Character 类，String 类等，就需要使用静态方法, 两者的区别是静态代码块是自动执行的而静态方法是被调用的时候才执行的.

Example：

public class Test {
    public Test() {
        System.out.print("默认构造方法！--");
    }

    //非静态代码块
    {
        System.out.print("非静态代码块！--");
    }

    //静态代码块
    static {
        System.out.print("静态代码块！--");
    }

    private static void test() {
        System.out.print("静态方法中的内容! --");
        {
            System.out.print("静态方法中的代码块！--");
        }

    }

    public static void main(String[] args) {
        Test test = new Test();
        Test.test();//静态代码块！--静态方法中的内容! --静态方法中的代码块！--
    }
}

上述代码输出：

静态代码块！--非静态代码块！--默认构造方法！--静态方法中的内容! --静态方法中的代码块！

当只执行 Test.test(); 时输出：

静态代码块！--静态方法中的内容! --静态方法中的代码块！

当只执行 Test test = new Test(); 时输出：

静态代码块！--非静态代码块！--默认构造方法！

非静态代码块与构造函数的区别是：非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容

小绵羊~~

关注

0
点赞
踩
1

收藏

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

文章目录final，static，this，super关键字总结**1.final关键字**2. static关键字3. this关键字4. super关键字static关键字详解1. static 关键字主要有以下四种使用场景2. 修饰成员变量和成员方法(常用)3. 静态代码块4. 静态内部类5. 静态导包补充内容静态方法和非静态方法static{}静态代码块与{}非静态代码块final，static，this，super关键字总结1.final关键字final关键字，意思是最终的、不可修改的，最见
复制链接

扫一扫