Java教程

JAVA-final关键字

本文主要是介绍JAVA-final关键字,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

final 中文意思:最后的,最终的.

final关键字可用于修饰类,方法,变量(成员变量,局部变量,静态变量),被final修饰的类是一个最终类,不可以被继承。被final修饰的方法是一个最终方法,不可以被覆盖,但是可以被继承。被final修饰的变量只能是一个常量,只能赋值一次。内部类被定义在类中的局部位置上时,只能访问局部被final修饰的局部变量。


使用到final的情况:
1)当不希望类被继承时,可以用final修饰.【 final class A】
2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。【访问修饰符 final 返回类型 方法名】
3)当不希望类的的某个属性的值被修改,可以用final修饰.【final double TAX RATE=0.08】
4)当不希望某个局部变量被修改,可以使用final修饰

final使用的注意事项:
1)final修饰的属性又叫常量一般用 XX_XX_XX来命名
2)final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一【选择一个位置赋初值即可】:
①定义时:如 public final double TAX RATE=0.08
②在构造器中
③在代码块中
3)如果final修饰的属性是静态的,则初始化的位置只能是:
①定义时
②在静态代码块 不能在构造器中赋值
4)final类不能继承,但是可以实例化对象。
5)如果类不是final类,但是含有final方法,则该方法虽然不能重写, 但是可以被继承
6)一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法
7)final不能修饰构造方法(即构造器)
8)final 和 static 往往搭配使用,效率更高,底层编译器做了优化处理
class Demo{
       public static final int i=16;
       static{
             System.out.printIn(“仪宝加油~"):
       }
}
8)包装类(Integer,Double,Float,Boolean等都是final,String也是final类

//final修饰的属性初始化
class A{
    //一、在定义时
    public final double TAX_RATE1 = 0.08;
    public final double TAX_RATE2;
    public final double TAX_RATE3;
    //二、在构造器中
    public A(){
        TAX_RATE2=1.1;
    }
    //三、在代码块
    {
        TAX_RATE3 = 1.8;
    }
}

//若final修饰的属性是静态的,则初始化
class B{
    //一、在定义时
    public static final double TAX_RATE1=99.9;
    public static final double TAX_RATE2;
    //二、在静态代码块
    static{
        TAX_RATE2=3.3;
    }
}

//final类不能继承,但是可以实例化对象
final class C{ }

public class en {
    public static void main(String[] args){
        C c = new C();
        new E().cal();
    }
}

//如果该类不是final类,但含有final方法,则该方法虽然不能重写,但是可以被继承
//即,仍然遵守继承的机制
class D{
    public final void cal(){
        System.out.println("cal()方法");
    }
}
class E extends D { }

思考:

Q:为什么当final修饰的属性为静态时,不可在构造器中初始化?

A:构造器在创建对象的时候才会被调用,而静态变量的初始化在类加载时就要给值。

User u = new User();
u.Login("a");
和new User().Login("a"); 是一样的.
只不过后者没有把User实例的引用付给一个实例而已.

User.Login("a");这是调用静态方法.静态方法不依赖于类实例,即静态方法不需要有对象,可以使用类名调用。但是在静态方法里不能操作类成员变量.

Q:为什么在静态方法里不能操作类成员变量?

A:因为要想访问成员变量你必须有个“已经实例化好的对象”,除非你在静态方法里创建一个当前类的实例对象,否则你是无法直接调用成员变量的,因为它不知道这个成员变量属于哪个实例对象的。而在成员方法里,所有属于成员的变量、方法已经可以确定是同一个对象的,并且可以用this表示当前对象。

static与final的区别:
static和final的意义是不同的,static修饰的时候代表对象是静态的,而final修饰的时候代表对象只能赋值一次,他们连用是因为定义的那个对象既要它是静态的,也要求它的值不能再被修改。
举例说明:
static int a=1;            static final b=1;
这里a和b的区别在于,a在程序里可以被重新赋值为2或3或等等的整数,而b在程序里不能被重新赋值,b永远都为1,也就是说b是一个常量。

final int c=1;              static final b=1;
这里c和b的区别在于,b存放在静态空间,不会在程序运行时被释放,它永远占着内存直到程序终止,而c在程序用完它而不会再用到它的时候就会被自动释放,不再占用内存。

当一个常数或字符串需要在程序里反复反复使用的时候,我们就可以把它定义为static final,这样内存就不用重复的申请和释放空间。

Q:一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法,为什么?

A:因为该类为final类,不能被继承,就不存在子类重写方法了,画蛇添足了属于是。因此也说,final类中的方法也都是final的。

Q:final为什么不能修饰构造方法(即构造器)?

A:java构造函数不能被final修饰
java中,构造函数是不能被继承的,也不能被重写。final修饰函数的主要目的是避免函数被重写。构造函数内在地具有不能被重写的特性,所以没必要用final修饰。
如果用fianl修饰构造函数,编译器会报modifier final not allowed的错误。

扩展+1:构造函数不能用abstract, static, final修饰

java构造函数不能被static修饰
static修饰函数时,可以说函数是属于类而不是属于一个具体的对象。而每个对象被创建时构造函数都会被调用,所以一个static的构造函数是没有用的。
如果用static修饰构造函数,编译器会报modifier static not allowed的错误。

java构造函数不能被abstract修饰
abstract修饰函数时,这个函数应当在子类中被实现。然而,在new被使用时,构造函数会被自动调用,因此必须要有一个函数体(而abstract函数没有函数体)。此外,构造函数不能被重写,因此也不可能在子类中被实现。
如果用abstract修饰构造函数,编译器会报modifier abstract not allowed的错误

public class en {
    public static void main(String[] args){
        System.out.println(F.num);
    }
}

//final 和 static 往往搭配使用,效率更高,不会导致类加载,底层编译器做了优化处理
final class F{
    public final static int num=10000;
    static{
        System.out.println("F 静态代码块被执行");
    }
}

代码运行结果为:  

public class en {
    public static void main(String[] args){
        System.out.println(F.num);
    }
}

final class F{
    public static int num=10000;
    static{
        System.out.println("F 静态代码块被执行");
    }
}

 代码运行结果为:  

可以看到,第一个代码块与第二个代码块的区别在于final static 与 static

前者可以在常量时不会导致类的加载,称为编译期常量。

这篇关于JAVA-final关键字的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!