Java super、final和static关键字

本文详细介绍了Java中的super关键字,包括它如何在非构造方法中调用父类成员以及在构造函数中的使用。接着讨论了final关键字,它可以修饰类、方法和变量,确保不可继承、不可重写以及不可修改。最后,阐述了static关键字的作用,它修饰的成员属于类,被所有对象共享,并强调了static final修饰的属性的特性:全局唯一且不可更改。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、Super关键字

1、非构造方法中的super关键字访问父类成员(变量和方法)

如果子类方法覆盖父类的方法,在子类中可以通过super关键字调用被重写的方法

class father {
    //私有,子类不可访问
    private String str = "let's play some dota";
    public String str1 = "dota";

    public void play() {
        System.out.println(str);
    }
}

class son extends father {
    //继承father,super访问父类方法
    public void fatherplay() {
        super.play();
    }

    //继承father,super访问父类成员
    private String str2 = super.str1;
    public String str3 = super.str1;
}

public class SuperTest {
    public static void main(String[] args) {
        son o = new son();
        //无法访问私有
//        System.out.println(o.str);
        System.out.println(o.str1);
//        System.out.println(o.str2);
        System.out.println(o.str3);
        o.play();
        o.fatherplay();
    }
}

2、构造函数super关键字调用父类构造函数

通过使用super关键字调用父类的构造方法必须在子类构造方法的第一行。可以是调用无参的super();也可以是调用父类有参数的构造方法super(parameter,list);

class animal{
    //带有参数的构造函数
    animal(String s){
        System.out.println(s);
    }
}
class dog extends animal{
    //如果不显示调用父类构造函数,Java编译器会调用super()
    //如果父类没有无参数构造函数,则编译报错
    dog(String str){
        super(str);
    }
    public void wangwang(){
        System.out.println("wangwang");
    }
}
public class Supertest2 {
    public static void main(String[] args) {
        dog d=new dog("heihei");
        d.wangwang();
    }
}

注意:Java 程序在执行子类的构造方法之前,如果没有用 super() 来调用父类特定的构造方法,则会调用父类中“没有参数的构造方法”。因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法,则编译时将发生错误,因为 Java 程序在父类中找不到没有参数的构造方法可供执行,这个就是在Java中定义一个不做事且没有参数的构造方法的作用

二、final关键字

在Java中,final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。final修饰的属性跟具体对象有关,在运行期初始化final修饰的属性,表示这个属性是常数(创建后不可更改),不同的对象有不同的final属性

1、final修饰类:表示这个类不能被继承,一般工具类会被设置成final的,如JDK中的String类

public final class FinalDemo {
    public FinalDemo(){

    }
    public FinalDemo(int value){
        System.out.println(value);
    }
    class FinalChild extends FinalDemo{

    }
}

 在FinalDemo类中如果没有默认构造函数,会报错(在前面的super关键字使用已经提过);上面的代码最下面的FinalDemo会有红色波浪下划线表示错误:Cannot inherit from final  “ FinalDemo ”

2、final修饰方法:表示这个方法不能被重写

类的private方法会被隐示的指定为final方法;如果父类中有final修饰的方法,子类无法继承重写

public class FinalDemo {
    public FinalDemo(){

    }
    public FinalDemo(int value){
        System.out.println(value);
    }

    public final void func(){
        System.out.println("do sth");
    }
    class FinalChild extends FinalDemo{
        // override 报错
        public void func(){
            System.out.println("do str");
        }
        // overloading 重载可以
        public void func(String str){
            System.out.println(str);
        }
    }
}

上面代码在 func() 报错 “ 'func()' cannot override 'func()' in 'FinalDemo' ; overridden method is final ”。 但是可以被重载

3、final修饰变量:final关键字用的最多的地方,只能赋值一次,赋值后不可更改

fina修饰基本数据类型会将其变成一个常数(创建后不可被修改);

fina修饰引用数据类型会将引用变成一个常数(创建后不可再指向其他对象),但是引用(指向的对象)的内容可以被修改。

fina修饰成员变量,注意必须要显示初始化,一种是直接在声明的时候初始化,一种是在该类的构造函数初始化(所有构造函数都要有final的初始化)

public class FinalDemo {
    private final int value;
    public FinalDemo(){
        this.value=12;
    }
    public FinalDemo(int value){
        this.value=value;
    }
    public static void main(String[] args) {
        FinalDemo test=new FinalDemo();
        System.out.println(test.value);
        FinalDemo testtmp=new FinalDemo(123);
        System.out.println(testtmp.value);
        final int[] arr1={1,2,3};
        int[] arr2={2,43,4};
        // arr1=arr2.clone();,报错 不可更改引用即指向的对象
        arr1[0]=12; // 但是指向的对象的内容可以更改
        System.out.println(arr1[0]);
    }
}

三、static关键字

在Java中,static关键字可以用来修饰属性,方法,代码段,内部类(静态内部类或嵌套内部类),static修饰的属性初始化是在编译器(类加载的时候),初始化后可以被改变,static关键字最重要的作用就是方便在没有对象的情况调用。

  • static修饰的成员变量和方法,属于类,被所有对象共有(理所当然可以被对象访问)
  • 静态方法不可以调用非静态成员
  • 普通的成员变量和方法,属于对象,是对象独有的
  • static代码块:属于类初始化操作,将一些必要的初始化放入static代码块用于提高性能
  • static不可以用于修饰局部变量(对于Java,这是乌龟的屁股——规定)
public class StaticFinal {
    // 被所有对象共有
    private static int res = 0;
    // 被所有对象共有,且唯一不可改变
    private static final int tmp=12;

    public StaticFinal(int value) {
        res += value;
    }

    public static void main(String[] args) {
        StaticFinal test = new StaticFinal(23);
        System.out.println(test.res);
        StaticFinal test2 = new StaticFinal(32);
        System.out.println(test2.res);
    }
}

前面介绍final关键字的时候,修饰成员变量可以声明后在所有构造函数中赋初值,这里如果用 static final 来修饰的话,必须在声明的时候赋初值,因为此时的成员变量是所有对象共有,且只能初始化一次的。

注:static修饰的属性重点在于它们只有一个,被所有对象共享,属于类的;final修饰的属性重点在于它们是个常数,不可被修改,static final修饰的属性重点在于它们被所有对象共享,属于类的,且不可更改,可以通过类名直接访问。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值