final 订阅
Final,英语单词,名词、形容词,作名词时意为“(英、美、巴、印、俄、加、法)怀勒(人名),决赛;期末考试;当日报纸的末版”,作形容词时意为“最终的;决定性的;不可更改的”。 展开全文
Final,英语单词,名词、形容词,作名词时意为“(英、美、巴、印、俄、加、法)怀勒(人名),决赛;期末考试;当日报纸的末版”,作形容词时意为“最终的;决定性的;不可更改的”。
信息
发    音
[ˈfaɪnl]
类    型
英文单词
词    性
名词、形容词
外文名
Final
excel函数公式大全教程简介
收起全文
精华内容
下载资源
问答
  • final

    千次阅读 多人点赞 2019-06-19 11:51:16
    ** 类修饰符 final ** ...只有类和方法可以用final来修饰,成员属性不可以final修饰; 当类被修饰为final时,这个类不能被继承; 当一个方法被修饰为final时,这个方法不可以被重写; ...

    **

    类修饰符 final

    **
    只有类和方法可以用final来修饰,成员属性可以final修饰,但是个人认为没啥意义了;
    当类被修饰为final时,这个类不能被继承;
    在这里插入图片描述
    当一个方法被修饰为final时,这个方法不可以被重写;
    在这里插入图片描述

    展开全文
  • 我们在使用Java8 lambda表达式的时候常常会遇到这样的编译报错 Variable used in lambda expression should be final or effectively final

    我们在使用Java8 lambda表达式的时候时不时会遇到这样的编译报错:
    场景描述
    这句话的意思是,lambda表达式中使用的变量应该是final或者有效的final,为什么会有这种规定?

    其实在 Java 8 之前,匿名类中如果要访问局部变量的话,那个局部变量必须显式的声明为 final,如下代码在 Java 7 中是编译不过的:

        @Test
        public void demo() {
            String version = "1.8";
            foo(new Supplier() {
                @Override
                public String get() {
                    return version; // 编译报错 Variable 'version' is accessed from within inner class, needs to be declared final
                }
            });
        }
        private void foo(Supplier supplier) {
            System.out.println(supplier.get());
        }
    

    Java 7 要求 version 这个局部变量必须是 final 类型的,否则在匿名类中不可引用。

    我们知道,lambda表达式是由匿名内部类演变过来的,它们的作用都是实现接口方法,于是类比匿名内部类,lambda表达式中使用的变量也需要是final类型。也就是说我们一开始图片中,i 这个变量需要声明为final类型,但是又发现个现象,如图:
    现象描述
    i 这个变量赋值给了 finalI 变量,但是finalI并没有声明为final类型,然而代码却能够编译通过,这是因为 Java 8 之后,在匿名类或 Lambda 表达式中访问的局部变量,如果不是 final 类型的话,编译器自动加上 final 修饰符,即Java8新特性:effectively final。


    前面一直说 Lambda 表达式或者匿名内部类不能访问非 final 的局部变量,这是为什么呢?

    • 首先思考外部的局部变量finalI和匿名内部类里面的finalI是否是同一个变量?

    我们知道,每个方法在执行的同时都会创建一个栈帧用于存储局部变量表、操作数栈、动态链接,方法出口等信息,每个方法从调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中入栈到出栈的过程(《深入理解Java虚拟机》第2.2.2节 Java虚拟机栈)。

    就是说在执行方法的时候,局部变量会保存在栈中,方法结束局部变量也会出栈,随后会被垃圾回收掉,而此时,内部类对象可能还存在,如果内部类对象这时直接去访问局部变量的话就会出问题,因为外部局部变量已经被回收了,解决办法就是把匿名内部类要访问的局部变量复制一份作为内部类对象的成员变量,查阅资料或者通过反编译工具对代码进行反编译会发现,底层确实定义了一个新的变量,通过内部类构造函数将外部变量复制给内部类变量。

    • 为何还需要用final修饰?

    其实复制变量的方式会造成一个数据不一致的问题,在执行方法的时候局部变量的值改变了却无法通知匿名内部类的变量,随着程序的运行,就会导致程序运行的结果与预期不同,于是使用final修饰这个变量,使它成为一个常量,这样就保证了数据的一致性。


    了解关于更多Jvm知识,请看 >>> 深入理解Java虚拟机

    展开全文
  • final关键字

    万次阅读 2021-02-01 19:41:46
    final修饰符 final:关键字最终的意思,可以修饰成员变量,成员方法,类 final修饰特点: 修饰方法:表明该方法是最终方法,不能被修改 修饰变量:表明该变量是常量,不能被重新复制 final修饰局部变量: 变量的...

    final修饰符
    final:关键字最终的意思,可以修饰成员变量,成员方法,类
    final修饰特点:

    • 修饰方法:表明该方法是最终方法,不能被修改
    • 修饰变量:表明该变量是常量,不能被重新复制

    final修饰局部变量:

    • 变量的基本类型:final修饰指的是基本类型的数据值不能被发生改变
    • 变量是引用类型:final修饰指的是引用类型的地址不能发生改变, 但是地址里的内容是可以被改变的
    展开全文
  • Java中的final变量、final方法和final

    万次阅读 多人点赞 2018-12-13 17:39:24
    1、final变量 final关键字可用于变量声明,一旦该变量被设定,就不可以再改变该变量的值。通常,由final定义的变量为常量。例如,在类中定义PI值,可以使用如下语句: final double PI=3.14; 在Java中定义全局...

    1、final变量

    final关键字可用于变量声明,一旦该变量被设定,就不可以再改变该变量的值。通常,由final定义的变量为常量。例如,在类中定义PI值,可以使用如下语句:

    final double PI=3.14;

    在Java中定义全局常量,通常使用public static final修饰,这样的常量只能在定义是被赋值。

    public static final double PI_VAULE = 3.14;

    规范:被定义为final的常量定义时需要使用大写字母命名,并且中间使用下划线进行连接。

    常量示例:

    import java.util.Random;
    
    class Test
    {
    	int i = 0;
    }
    
    /**
     * 常量示例
     * 
     * @author pan_junbiao
     *
     */
    public class FinalData
    {
    	static Random rand = new Random();
    	private final int VALUE_1 = 9; // 声明一个final常量
    	private static final int VALUE_2 = 10; // 声明一个final、static常量
    	private final Test test = new Test(); // 声明一个final引用
    	private Test test2 = new Test(); // 声明一个不是final的引用
    	private final int[] a = { 1, 2, 3, 4, 5, 6 }; // 声明一个定义为final的数组
    	private final int i4 = rand.nextInt(20);
    	private static final int i5 = rand.nextInt(20);
    
    	public String toString()
    	{
    		return "i4值:" + i4 + " i5值:" + i5 + " ";
    	}
    
    	public static void main(String[] args)
    	{
    		FinalData data = new FinalData();
    
    		// 报错:不能改变定义为final的常量值
    		// data.VALUE_1 = 8;
    
    		// 报错:不能改变定义为final的常量值
    		// data.VALUE_2 = 9;
    
    		// 报错:不能将定义为final的引用指向其他引用
    		// data.test = new Test();
    
    		// 正确: 可以对指定为final的引用中的成员变量赋值
    		data.test.i = 1;
    
    		// 正确: 可以将没有定义为final的引用指向其他引用
    		data.test2 = new Test();
    
    		// 报错:不能对定义为final的数组赋值
    		// int b[] = { 7, 8, 9 };
    		// data.a = b;
    
    		// 但是final的数组中的每一项内容是可以改变的
    		for (int i = 0; i < data.a.length; i++)
    		{
    			data.a[i] = 9;
    		}
    
    		System.out.println(data);
    		System.out.println("data2");
    		System.out.println(new FinalData());
    	}
    }

    执行结果:

     

    从上述执行结果中可以发现i5的值是相同的。

    全局常量:

    我们知道一个被定义为final的对象引用只能指向唯一一个对象,不可以将它再指向其它对象,但是一个对象的值却是可以改变的,那么为了使一个常量真正做到不可更改,可以将常量声明为static final。

    示例:在项目中创建FinalStaticData类,在该类中创建Random类的对象,在主方法中分别输出类中定义的final变量a1与a2。

    import static java.lang.System.out;
    
    import java.util.Random;
    
    /**
     * FinalStaticData类
     * 
     * @author pan_junbiao
     *
     */
    public class FinalStaticData
    {
    	private static Random rand = new Random(); // 实例化一个Random类对象
    	// 随机产生0~10之间的随机数赋予定义为final的a1
    	private final int a1 = rand.nextInt(10);
    	// 随机产生0~10之间的随机数赋予定义为static final的a2
    	private static final int a2 = rand.nextInt(10);
    
    	public static void main(String[] args)
    	{
    		FinalStaticData fdata = new FinalStaticData(); // 实例化一个对象
    		// 调用定义为final的a1
    		out.println("重新实例化对象调用a1的值:" + fdata.a1);
    		// 调用定义为static final的a2
    		out.println("重新实例化对象调用a2的值:" + fdata.a2);
    		// 实例化另外一个对象
    		FinalStaticData fdata2 = new FinalStaticData();
    		out.println("重新实例化对象调用a1的值:" + fdata2.a1);
    		out.println("重新实例化对象调用a2的值:" + fdata2.a2);
    	}
    }

    运行结果:

     

    从本示例运行结果中可以看出,定义为final的常量不是恒定不变的,将随机数赋予定义为final的常量,可以做到每次运行程序时改变a1的值。但是a2与a1不同,由于它被声明为static final形式,所以在内存中为a2开辟了一个恒定不变的区域,当再次实例化一个FinalStaticData对象时,仍然指向a2这块内存区域,所以a2的值保存不变。a2是在装载时被初始化,而不是每次创建新对象时被初始化;而a1会重新实例化对象时被更改。

    最后总结一下在程序中final数据可以出现的位置,如下程序。

    /**
     * 总结一下在程序中final数据可以出现的位置
     * 
     * @author pan_junbiao
     *
     */
    public class FinalDataTest
    {
    	// final成员变量不可更改
    	final int VALUE_ONE = 6;
    
    	// 在声明final成员变量时没有赋值,称为空白final
    	final int BLANK_FINALVAULE;
    
    	// 在构造方法中为空白final赋值
    	public FinalDataTest()
    	{
    		BLANK_FINALVAULE = 8;
    	}
    
    	// 设置final参数,不可以改变参数x的值
    	int doIt(final int x)
    	{
    		return x + 1;
    	}
    
    	// 局部变量定义为final,不可以改变i的值
    	void doSomething()
    	{
    		final int i = 7;
    	}
    }

     

    2、final方法

    首先,我们应该了解定义为final的方法不能被重写

    将方法定义为final类型可以防止任何子类修改该类的定义与实现方式,同时定义为final的方法执行效率要高于非final方法。在修饰权限中曾经提到过private修饰符,如果一个父类的某个方法被设置为private修饰符,子类将无法访问该方法,自然无法覆盖该方法,所以一个定义为private的方法隐式被指定为final类型,这样无须将一个定义为private的方法再定义为final类型。

    语法:

    private final void test()
    {
    }

     

    3、final类

    定义为final的类不能被继承。

    如果希望一个类不允许任何类继承,并且不允许其他人对这个类有任何改动,可以将这个类设置为final形式。

    final类的语法如下:

    final 类名{}

    如果将某个类设置为final形式,则类中的所有方法都被隐式设置为final形式,但是final类中的成员变量可以被定义为final或非final形式。

    示例:在项目中创建FinalClass类,在类中定义doit()方法和变量a,实现在主方法中操作变量a自增。

    /**
     * 定义final类
     * 
     * @author pan_junbiao
     *
     */
    final class FinalClass
    {
    	int a = 3;
    
    	void doit()
    	{
    	}
    
    	public static void main(String args[])
    	{
    		FinalClass f = new FinalClass();
    		f.a++;
    		System.out.println(f.a); // 结果:4
    	}
    }

     

    4、总结

    下面总结了一些使用final关键字的好处:

    (1)final关键字提高了性能。JVM和Java应用都会缓存final变量。

    (2)final变量可以安全的在多线程环境下进行共享,而不需要额外的同步开销。

    (3)使用final关键字,JVM会对方法、变量及类进行优化。

    不可变类:

    创建不可变类要使用final关键字。不可变类是指它的对象一旦被创建了就不能被更改了。String是不可变类的代表。不可变类有很多好处,譬如它们的对象是只读的,可以在多线程环境下安全的共享,不用额外的同步开销等等。

    关于final的重要知识点:

    (1)final关键字可以用于成员变量、本地变量、方法以及类。

    (2)final成员变量必须在声明的时候初始化或者在构造器中初始化,否则就会报编译错误。

    (3) 你不能够对final变量再次赋值。

    (4)本地变量必须在声明时赋值。

    (5)在匿名类中所有变量都必须是final变量。

    (6)final方法不能被重写。

    (7)final类不能被继承。

    (8)final关键字不同于finally关键字,后者用于异常处理。

    (9)final关键字容易与finalize()方法搞混,后者是在Object类中定义的方法,是在垃圾回收之前被JVM调用的方法。

    (10)接口中声明的所有变量本身是final的。

    (11)final和abstract这两个关键字是反相关的,final类就不可能是abstract的。

    (12)final方法在编译阶段绑定,称为静态绑定(static binding)。

    (13)没有在声明时初始化final变量的称为空白final变量(blank final variable),它们必须在构造器中初始化,或者调用this()初始化。不这么做的话,编译器会报错“final变量(变量名)需要进行初始化”。

    (14)将类、方法、变量声明为final能够提高性能,这样JVM就有机会进行估计,然后优化。

    (15)按照Java代码惯例,final变量就是常量,而且通常常量名要大写。
     

    展开全文
  • java中的static和final

    千次阅读 多人点赞 2014-03-20 00:02:00
    一、final   根据程序上下文环境,Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变:设计或效率。  final类不能被...
  • Java中final、finally和finalize的区别

    万次阅读 多人点赞 2017-03-28 20:00:13
    final、finally、finalize的区别 1、final修饰符(关键字)。被final修饰的类,就意味着不能再派生出新的子类,不能作为父类而被子类继承。因此一个类不能既被abstract声明,又被final声明。将变量或方法声明为...
  • 理解final关键字

    万次阅读 多人点赞 2018-08-07 22:24:12
    final在Java中是一个保留的关键字,可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初始化的话,编译器会报编译错误。 一....
  • 一、final变量 咋们先看个,例子,再来解释为什么会这样! public class Main { public static void main(String[] args) { // write your code her final int a[]=new int[2]; final int b=1; a[0]=1; .....
  • final 关键字表示对象是最终形态的,对象是不可改变的意思。final 应用于类、方法和变量时意义是不同的,但本质是一样的:final 表示不可改变。 final 用在变量的前面表示变量的值不可以改变,此时该变量可以被称为...
  • java中的Static、final、Static final各种用法

    万次阅读 多人点赞 2019-10-22 21:38:13
    对Static、final、Static final这几个关键词熟悉又陌生?想说却又不知怎么准确说出口?好的,本篇博客文章将简短概要出他们之间的各自的使用,希望各位要是被你的面试官问到了,也能从容的回答… static 加载:...
  • Final关键字

    2019-09-28 14:06:50
    final关键字介绍 final修饰类 final修饰方法 final修饰变量 1. final关键字介绍 final关键字的意思: 是不能改变的意思,用来修饰类、方法、变量。 用法: Java提供了Final关键字主要用来修饰一些不可改变的内容...
  • Struts中private static final long serialVersionUID的作用

    万次阅读 多人点赞 2016-11-25 22:21:41
    private static final long serialVersionUID = -1672970955045193907L; 这样的一条语句。 中文搜索之后,全部都是 如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错。为了在...
  • * 1.final修饰变量,变量变成了一个常量,所有字母大写. * 2.方法被final修饰,方法不允许重写. * 3.类被final修饰,类不允许继承,也就不存在方法重写的问题了. * 4.final 和 public都是修饰符,顺序无要求. * 5...
  • final方法:表示方法不可被子类重写(覆盖) final变量:初始化一次后值不可变 final类:类不能被继承,内部的方法和变量都变成final类型 final对象:指对象的引用不可变,但是对象的值可变,即指向的是同一个...
  • private final

    千次阅读 2019-06-30 00:28:09
    private final final 本意是指 无法改变的!不想被改变无非出于两种理由。设计和效率以下针对用到final的三种情况 数据,方法和类 数据 final 修饰基本的数据类型时 必须初始化 否则编译报错。代码 如下  包括...
  • Java final关键字

    千次阅读 2020-03-13 14:16:32
    文章目录一.final类的理解二.final的讲解三.final修饰成员变量和局部变量的详解四. final修饰基本类型变量和引用类型变量详解五.可执行“宏”替换的final变量六.final关键字好处 针对Java语言中的final关键字,想必...
  • 空白final final方法 final与private

    千次阅读 2014-11-07 18:28:16
    所谓空白final就是指不初始化后续再对其进行赋值,但是这个操作zhineng
  • final类与final方法

    千次阅读 2016-03-07 16:31:39
    final---用于类、方法前。  final类---不可被继承。  final方法---不可被覆盖。  final类不能被继承。  如果我们不希望一个类被继承,我们使用final来修饰这个类。这个类将无法被继承。比如我们设定的Math类...
  • 对于基本数据类型,final 会将值变成一个常数;但对于对象句柄,final 会将句柄变成一个常数。进行声明时,必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。不能由于某样东西的属性是...
  • 在Java中这几个关键字常常被混用。 可修饰部分 static:成员变量、方法、代码块(静态代码块)、内部类(静态内部类) final: 类、成员变量、方法、局部变量 ...final具体修饰 ...final 修饰...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,779
精华内容 96,711
热门标签
关键字:

final