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

    2018-10-13 21:21:59
    finaldata 数据恢复软件,比较好用的分享给大家,请大家使用。不用客气
  • FinalData已破解企业版含注册码
  • final

    千次阅读 多人点赞 2019-06-19 11:51:16
    ** 类修饰符 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变量就是常量,而且通常常量名要大写。
     

    展开全文
  • hibernate-tools-4.3.1.Final

    2015-10-19 15:26:02
    hibernate-tools-4.3.1.Final.jar 可以逆向生成数据库的注释,替换Eclipse目录下相应版本的包,在Eclipse mar先安装Jboss Tools插件,再替换Eclipse下相应的jar文件(在目录下搜索hibernate-tools-4),重启Eclipse...
  • 有小伙伴很认真地参考着学习了一下,并且在学习的过程中提出了新的问题:“老哥,当我在使用 Lambda 表达式中使用变量的时候,编译器提醒我‘Local variable limit defined in an enclosing scope must be final or ...

    之前写了一篇 Lambda 的入门文章,有小伙伴很认真地参考着学习了一下,并且在学习的过程中提出了新的问题:“老哥,当我在使用 Lambda 表达式中使用变量的时候,编译器提醒我‘Local variable limit defined in an enclosing scope must be final or effectively final’,意思就是‘从 Lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量’,这其中的 final 和 effectively final 到底有什么区别呢?”

    看到这个问题,我忍不住调皮了,不假思索地回答说:“当然是 effectively 啦!”

    那老弟竟然没被我气晕过去,紧接着说:“老哥,我知道你幽默,你风趣,这节骨眼你能不能细致给我说说这两者之间的区别啊?在线等。”

    然后我细细致致地又给他聊了半个多小时,总算是解释清楚了。临了,他还特意叮嘱我说:“老哥,别忘了写篇文章啊!让更多的小伙伴知道这个区别。”

    现在的年轻人啊,真特么有心,未来是你的!我承认我是个负责任的男人,既然如此,下面我就来详细地谈一谈 final 和 effectively final 之间的区别。

    先来看看官方(Java 8 的规格说明书)是怎么说的,如下:

    a final variable can be defined as An entity once that cannot be changed nor derived from later and an effectively final defined as variable or parameter whose value is never changed after it is initialized is effectively final.

    就像你看到的,上面这段解释并没有针对关键词“effectively”进行详细的说明——看得云里雾里的,等于没看。

    来看下面这段代码:

    int limit = 10;
    Runnable r = () -> {
        limit = 5;
        for (int i = 0; i < limit; i++) {
            System.out.println(i);
        }
    };
    new Thread(r).start();
    

    编译器会提醒我们“Lambda 表达式中的变量必须是 final 或者 effectively final”,按照编译器的提示,我们把 limit 变量修饰为 final,但这时候,编译器提示了新的错误。

    这次的错误就很明确了,final 变量是不能被重新赋值的——众所周知,这正是 final 关键字的作用——于是我们把 limit = 5 这行代码去掉。

    final int limit = 10;
    Runnable r = () -> {
        for (int i = 0; i < limit; i++) {
            System.out.println(i);
        }
    };
    new Thread(r).start();
    

    考虑到 limit 在接下来的代码中并未被重新赋值,我们可以将 final 关键字去掉。

    int limit = 10;
    Runnable r = () -> {
        for (int i = 0; i < limit; i++) {
            System.out.println(i);
        }
    };
    new Thread(r).start();
    

    代码仍然可以正常编译,正常运行,那么此时的 limit 变量就是“effectively final”的。由于 limit 在接下来的代码中没有被重新赋值,编译器就被欺骗了,想当然地认为 limit 就是一个 final 变量(实际上的最终变量)。

    假如 limit 在声明为普通的变量(没有 final 修饰)后又被重新赋值了,那也就不可能成为“effectively final”了。

    因此得出的结论是,“effectively final”是一个行为类似于“final”的变量,但没有将其声明为“final”变量,关键就在于编译器是怎么看待的。

    好了,我亲爱的读者朋友,以上就是本文的全部内容了。喜欢的话,就点个赞👍。

    展开全文
  • final关键字用法总结

    千次阅读 2019-01-23 22:08:51
    一、final关键字的基本用法 在java中,final关键字可以用来修饰类、方法、变量(包括成员变量和局部变量)。下面我们从这三个方面了解一下final的用法。 1、修饰类 final修饰一个类时,表示该类不能继承。final类中...

    欢迎大家关注我的公众号【老周聊架构】,Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

    一、final关键字的基本用法

    在java中,final关键字可以用来修饰类、方法、变量(包括成员变量和局部变量)。下面我们从这三个方面了解一下final的用法。

    1、修饰类

    final修饰一个类时,表示该类不能继承。final类中的成员变量可以根据需要设为final,但是final类中的所有成员方法都会被隐式地指定为final方法。 **注意**:在使用final修饰类的时候,一定要谨慎选择,除非这个类以后不会用来继承或者出于安全考虑,尽量不要将类设计为final类。

    在这里插入图片描述

    2、修饰方法

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

    因此,如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。即父类的final方法是不能被子类所覆盖的,也就是说子类是不能够存在和父类一模一样的方法的。

    final修饰的方法表示此方法已经是“最后的、最终的”含义,亦即此方法不能被重写(可以重载多个final修饰的方法)。此处需要注意的一点是:因为重写的前提是子类可以从父类中继承此方法,如果父类中final修饰的方法同时访问控制权限为private,将会导致子类中不能直接继承到此方法,因此,此时可以在子类中定义相同的方法名和参数,此时不再产生重写与final的矛盾,而是在子类中重新定义了新的方法。(注:类的private方法会隐式地被指定为final方法)

    class Animal{
        /**
         * 因为private修饰,子类中不能继承到此方法,因此,子类中的getName方法是重新定义的.
         * 属于子类本身的方法,编译正常.
         */
        private final void getName() {}
    
        /**
         *  因为pblic修饰,子类可以继承到此方法,导致重写了父类的final方法,编译出错.
         */
    //  public final void getName() {}
    }
    
    class Cat extends Animal {
        public static void main(String[] args) {
    
        }
    
        public void getName() {}
    }
    

    3、修饰变量

    修饰变量是final用得最多的地方,也是本文接下来要重点阐述的内容。

    final成员变量表示常量,只能被赋值一次,赋值后值不再改变。

    当final修饰一个基本数据类型时,表示该基本数据类型的值一旦在初始化后便不能发生变化;如果final修饰一个引用类型时,则在对其初始化之后便不能再让其指向其他对象了,但该引用所指向的对象的内容是可以发生变化的。本质上是一回事,因为引用的值是一个地址,final要求值,即地址的值不发生变化。

    final修饰一个成员变量(属性),必须要显示初始化。这里有两种初始化方式,一种是在变量声明的时候初始化;第二种方法是在声明变量的时候不赋初值,但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

    class Animal {
        private final int count = 0;
        public Animal() {
            count = 1; //报错
            final Object object = new Object();
            object = new Object(); //报错
        }
    }
    

    二、深入理解final关键字

    在了解了final关键字的基本用法之后,这一节我们来看一下final关键字容易混淆的地方。

    1、类的final变量和普通变量有什么区别?

    当用final作用于类的成员变量时,成员变量(注意是类的成员变量,局部变量只需要保证在使用之前被初始化赋值即可)必须在定义时或者构造器中进行初始化赋值,而且final变量一旦被初始化赋值之后,就不能再被赋值了。
    那么final变量和普通变量到底有何区别呢?下面请看一个例子:

    public class Test {
        public static void main(String[] args) {
            String a = "helloworld";
            final String b = "hello";
            String c = "hello";
            String x = b + "world";
            String y = c + "world";
            System.out.println(a == x);
            System.out.println(a == y);
        }
    }
    

    输出结果:true ; false

    大家可以先想一下这道题的输出结果。为什么第一个比较结果为true,而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了,当final变量是基本数据类型以及String类型时,如果在编译期间能知道它的确切值,则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方,相当于直接访问的这个常量,不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中,由于变量b被final修饰,因此会被当做编译器常量,所以在使用到b的地方会直接将变量b 替换为它的值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了,不过要注意,只有在编译期间能确切知道final变量值的情况下,编译器才会进行这样的优化,比如下面的这段代码就不会进行优化:

    public class Test {
        public static void main(String[] args) {
            String a = "helloworld";
            final String b = getHello();
            String x = b + "world";
            System.out.println(a == x);
        }
        public static String getHello() {
            return "hello";
        }
    }
    

    这段代码的输出结果为false。这里要注意一点就是:不要以为某些数据是final就可以在编译期知道其值,通过变量b我们就知道了,在这里是使用getHello()方法对其进行初始化,他要在运行期才能知道其值。

    2、被final修饰的引用变量指向的对象内容可变吗?

    在上面提到被final修饰的引用变量一旦初始化赋值之后就不能再指向其他的对象,那么该引用变量指向的对象的内容可变吗?看下面这个例子:

    public class Test {
        public static void main(String[] args) {
           final Object object = new Object();
            System.out.println(++object.i);
        }
    }
    class Object {
        public int i = 0;
    }
    

    输出结果: 1

    这段代码可以顺利编译通过并且有输出结果,输出结果为1。这说明引用变量被final修饰之后,虽然不能再指向其他对象,但是它指向的对象的内容是可变的。

    3、final参数的问题

    在实际应用中,我们除了可以用final修饰成员变量、成员方法、类,还可以修饰参数、若某个参数被final修饰了,则代表了该参数是不可改变的。如果在方法中我们修改了该参数,则编译器会提示你:The final local variable i cannot be assigned. It must be blank and not using a compound assignment。看下面的例子:

    public class TestFinal {
        public static void main(String[] args) {
            TestFinal testFinal = new TestFinal();
            int i = 0;
            testFinal.changeValue(i);
            System.out.println(i);
        }
    
        public void changeValue(final int i) {
            //final参数不可改变
            i++; //报错,因为参数i已经被final修饰了
            System.out.println(i);
        }
    }
    

    上面这段代码changeValue方法中的参数i用final修饰之后,就不能在方法中更改变量i的值了。值得注意的一点,方法changeValue和main方法中的变量i根本就不是一个变量,因为java参数传递采用的是值传递,对于基本类型的变量,相当于直接将变量进行了拷贝。所以即使没有final修饰的情况下,在方法内部改变了变量i的值也不会影响方法外的i。

    再看下面这段代码:

    public class TestFinal {
        public static void main(String[] args) {
            TestFinal testFinal = new TestFinal();
            StringBuffer sb = new StringBuffer("hello");
            testFinal.changeValue(sb);
            System.out.println(sb);
        }
    
        public void changeValue(final StringBuffer sb) {
            //final修饰引用类型的参数,不能再让其指向其他对象,但是对其所指向的内容是可以更改的。
            //buffer = new StringBuffer("hi");
            sb.append("world");
        }
    }
    

    运行结果:helloworld

    运行这段代码就会发现输出结果为 helloworld。很显然,用final进行修饰虽不能再让buffer指向其他对象,但对于buffer指向的对象的内容是可以改变的。现在假设一种情况,如果把final去掉,结果又会怎样?看下面的代码:

    public class TestFinal {
        public static void main(String[] args) {
            TestFinal testFinal = new TestFinal();
            StringBuffer sb = new StringBuffer("hello");
            testFinal.changeValue(sb);
            System.out.println("main方法里的 :" + sb);
        }
    
        public void changeValue(StringBuffer sb) {
            //sb重新指向另一个对象
            sb = new StringBuffer("say");
            sb.append("world");
            System.out.println("changeValue方法里的 :" + sb);
        }
    }
    

    输出结果:
    changeValue方法里的 :sayworld
    main方法里的 :hello

    从运行结果可以看出,将final去掉后,同时在changeValue中让buffer指向了其他对象,并不会影响到main方法中的buffer,原因在于java采用的是值传递,对于引用变量,传递的是引用的值,也就是说让实参和形参同时指向了同一个对象,因此让形参重新指向另一个对象对实参并没有任何影响。


    关于 final 的两个重排序规则了监考下面的博文:final的两个重排序规则

    展开全文
  • 程序员你真的理解final关键字吗?

    千次阅读 多人点赞 2019-10-24 11:45:33
    一提到final博主就不认同网上流传的这句话:”方法中不需要改变作为参数的对象变量时,明确使用final进行声明,会防止你无意的修改而影响到调用方法外的变量
  • hibernate-release-5.0.2.Final API.chm

    热门讨论 2015-10-29 16:13:54
    hibernate-release-5.0.2.Final API.chm 参考文档,有了这个,就不用联网查看API参考文档了
  • hibernate-release-4.3.5.Final.zip

    热门讨论 2014-05-27 18:10:42
    hibernate-release-4.3.5.Final.zip 最新 稳定 最终版
  • 怎样修改Java中的final字段? 先说答案:通过反射是可以修改final字段的! ps:但是修改后的数据能不能生效(正确访问到修改后的数据)就得看情况了,不同的数据类型、不同的数据初始化方式、不同的访问方式都可能导致...
  • final finally finalize()区别

    万次阅读 2019-04-10 11:18:00
    final finally finalize()区别 final 表示最终的、不可改变的。用于修饰类、方法和变量。 finally 异常处理的一部分,它只能用在try/catch语句中,表示希望finally语句块中的代码最后一定被执行(但是不一定会被...
  • hibernate-3.6.10.Final.rar

    热门讨论 2014-04-07 12:40:30
    hibernate-3.6.10.Final.rar,用于Java开发中的Hibernate技术
  • Eclipse中Hibernate插件。
  • hibernate-release-4.2.21.Final官方原版

    热门讨论 2015-11-19 09:19:52
    hibernate-release-4.2.21.Final官方原版
  • 浅谈java中的final用法

    千次阅读 2019-04-10 09:43:57
    谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。 一、final关键字的基本用法 在...
  • final关键字作用详解

    千次阅读 2018-05-19 15:51:30
    final关键字作用详解目录1 final关键字常用应用场景 1.1 单例模式 1.2 静态配置文件解析后的初始化2 final关键字初始化3 在构造函数中参数用final关键字修饰的作用4 final在集合中的应用 4.1 将集合类对象定义为...
  • final 和effectively final区别

    千次阅读 2019-01-03 10:02:01
    针对于jdk1.8,对于一个变量,如果没有给它加final修饰,而且没有对它的二次赋值,那么这个变量就是effectively final(有效的不会变的),如果加了final那肯定是不会变了哈。就是这个意思。 在学习局部内部类...
  • java中的Static、final、Static final各种用法

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

    千次阅读 2020-07-22 10:26:52
    final、static和static final用法 1.final关键字 final关键字修饰变量: 1.这个变量必须在构造对象时就能够初始化 2.如果是基本数据类型的变量,那么这个变量一旦初始化就不能更改,相当于一个常量 3.如果是引用数据...
  • final的两个重排序规则

    千次阅读 2019-07-18 00:50:16
    对于final 域,编译器和处理器要遵守两个重排序规则: 1、在构造函数内对一个 final 域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。 2、初次读一个包含 final 域的对象的...
  • 全面理解Java中的final修饰符

    千次阅读 2018-08-01 17:15:30
    final修饰符 final 可用于修饰类、变量和方法,用于表示它修饰的类、方法和变量不可改变。 final修饰的大都应用于基本类型域,或不可变类。 不可变类:如果类中的每个方法都不会改变其对象,这种类是不可变的类。...
  • 我们在使用 Java8 lambda 表达式的时候常常会遇到这样的编译报错 Variable used in lambda expression should be final or effectively final
  • 从字面上来理解这句话,意思是:*lambda表达式中使用的变量应该是final或者有效的final*,也就是说,lambda 表达式只能引用标记了 final 的外层局部变量,这就是说不能在 lambda 内部修改定义在域外的局部变量,否则...
  • final 与 static 的区别

    万次阅读 多人点赞 2019-04-11 10:58:10
    final 与 static 的区别 都可以修饰类、方法、成员变量。 static可以修饰类的代码块,final不可以。 static不可以修饰方法内的局部变量,final可以。 static修饰表示静态或全局,被修饰的属性和方法属于类,...
  • final 关键字表示对象是最终形态的,对象是不可改变的意思。final 应用于类、方法和变量时意义是不同的,但本质是一样的:final 表示不可改变。 final 用在变量的前面表示变量的值不可以改变,此时该变量可以被称为...
  • 偶尔,我们需要在 Lambda 表达式中修改变量的值,但如果直接尝试修改的话,编译器不会视而不见听而不闻,它会警告我们说:“variable used in lambda expression should be final or effectively final”。...
  • 深入理解final关键字(详解)

    万次阅读 多人点赞 2019-02-19 14:33:50
    提及final关键字都会想到一个常见的面试题就是: final、finally、finalize区别 在这里我们来简单回忆一下这三者的区别, final: Final用于修饰类、成员变量和成员方法。final修饰的类,不能被继承(String、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,236,756
精华内容 894,702
关键字:

final