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

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

    **

    类修饰符 final

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

    展开全文
  • final finally finalize()区别

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

    final finally finalize()区别

    • final 表示最终的、不可改变的。用于修饰类、方法和变量。
    • finally 异常处理的一部分,它只能用在try/catch语句中,表示希望finally语句块中的代码最后一定被执行(但是不一定会被执行
    • finalize()是在java.lang.Object里定义的,Object的finalize方法什么都不做,对象被回收时finalized方法会被调用。
          特殊情况下,可重写finalize方法,当对象被回收的时候释放一些资源。但注意,要调用super.finalize()。

    finalize()的调用过程详细

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 写了一个多线程中有关final和static的例子,遇到问题了。 ``` public class MyThread implements Runnable { int i = 0; int a = 20; static int b = 20; static int c = 20; static int d = 20; final int ...
  • Struts中private static final long serialVersionUID的作用

    万次阅读 多人点赞 2016-11-25 22:21:41
    private static final long serialVersionUID = -1672970955045193907L; 这样的一条语句。 中文搜索之后,全部都是 如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错。为了在...

    今天在看项目源码的时候发现struts的action里面有

     

    private static final long serialVersionUID = -1672970955045193907L;

     

     

    这样的一条语句。

     

     

    中文搜索之后,全部都是

    如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错。为了在反序列化时,确保类版本的兼容性,最好在每个要序列化的类中加入private static final long serialVersionUID这个属性,具体数值自己定义。

     

    中文的全部都是抄来抄去的答案。这真是叫人恶心。

     

    有趣的事,在外国网站也出现了这样的状况。原帖:http://www.coderanch.com/t/596397/java/java/private-static-final-long-serialVersionUID

     

    What is private static final long serialVersionUID = 1L; ???
    上面那句话是什么?

     

    Hi Friends,

    Can you please tell me the purpose of this line ???

    朋友们,

    谁能告诉我这段代码的缘由?

     

        
    SerialVersionUID is an ID which is stamped on object when it get serialized usually hashcode of object, you can use tool serialver to see serialVersionUID of a serialized object . SerialVersionUID is used for version control of object. you can specify serialVersionUID in your class file also. Consequence of not specifying serialVersionUID is that when you add or modify any field in class then already serialized class will not be able to recover because serialVersionUID generated for new class and for old serialized object will be different. Java serialization process relies on correct serialVersionUID for recovering state of serialized object and throws java.io.InvalidClassException in case of serialVersionUID mismatch.

     

    SerialVersionUID,后面简称SUID,是当对象序列化的时候对象的一个标识(stamp on 在这里我也不太清楚翻译成什么好),SUID的值常为该对象的hascode。你可以使用工具serialver查看一个序列化对象的SUID。SUID用于控制对象的版本。你也可以在类文件中指定SUID。不指定SUID的结果就是当你添加或者更改类的域并已经序列化类的时候,类是不能再恢复了,因为新的SUID和之前的SUID不同了。Java的序列化过程依赖于正确的SUID来反序列化已经序列化的对象,如果SUID不匹配,那么就会抛 java.io.InvalidClassException 异常了。

     

    Please don’t simply copy and paste from another website; that may be breach of copyright. That quote is confusing at the best.

    An SUID is not a hash of the object, but a hash of its originating class. If the class is updated, for example with different fields, the SUID can change. You have four (at least) possible courses of action:-

    • 1: Leave out the SUID. This tells the runtime that there are no differences between versions of classes when serialising and deserialising.
    • 2: Always write a default SUID, which looks like the heading of this thread. That tells the JVM that all versions with this SUID count as the same version.
    • 3: Copy an SUID from a previous version of the class. That tells the runtime that this version and the version the SUID came from are to be treated as the same version.
    • 4: Use a generated SUID for each version of the class. If the SUID is different in a new version of the class, that tells the runtime that the two versions are different and serialised instances of the old class cannot be deserialised as instances of the new class.

       

      请不用简单地从别的网站复制粘贴(一针见血指出上面回答的缺点);这是对版权的破坏,而且这样的描述最多还是困惑读者。

      SUID不是一个对象的哈希值(翻译错了,公司一个牛逼同事提醒了!),是源类的哈希值。如果类更新,例如域的改变,SUID会变化,这里有4个步骤:

      1.忽略SUID,相当于运行期间类的版本上的序列化和反序列上面没有差异。

      2.写一个默认的SUID,这就好像线程头部。告诉JVM所有版本中有着同样SUID的都是同一个版本。

      3.复制之前版本类的SUID。运行期间这个版本和之前版本是一样的版本。

      4.使用类每个版本生成的SUID。如果SUID与新版本的类不同,那么运行期间两个版本是不同的,并且老版本类序列化后的实例并不可以反序列成新的类的实例。

       

      第四点才是private static final long serialVersionUID的作用的重点所在。

       

      Thanks Campbell, will be careful from now on. 

      后面那个直接抄答案的跟上面那位答者致谢。对方也在后面的回复中也竖起大拇指。

       

      最后总结一下:其实序列化的作用是能转化成Byte流,然后又能反序列化成原始的类。能在网络进行传输,也可以保存在磁盘中,有了SUID之后,那么如果序列化的类已经保存了在本地中,中途你更改了类后,SUID变了,那么反序列化的时候就不会变成原始的类了,还会抛异常,主要就是用于版本控制。

       

      这完完全全是和国内这种复制粘贴漫天飞的问答的不同的格调,这正是技术所需要的一种气氛,一种对更好的答案的追求。

      希望以后国内的技术氛围也能如此!

    展开全文
  • 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类不能被...
  • final关键字

    2017-12-15 18:15:39
    引用类型,变量放的是个地址,所以用final修饰引用类型变量指的是它里面的地址不能变,即它只能指向初始时指向的那个对象,而不关心指向的对象内容的变化 所以修饰的变量必须被初始化 public s...
  • Java中final、finally和finalize的区别

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

    千次阅读 2014-11-07 18:28:16
    所谓空白final就是指不初始化后续再对其进行赋值,但是这个操作zhineng
  • final String ab = "ab"; final String c = "c"; final String abc = "abc"; System.out.println(ab+c==abc);//true } private void demo3() { final String ab ; ab ="ab";//这跟demo2()方法差别...
  • 再说final变量

    万次阅读 热门讨论 2006-12-25 17:41:00
    final变量的定义从它诞生那天起,就没有发生任何变化,也就是这十多年它就一直表示它原来的意思.但遗憾的是,经过十多年仍然有90%的人没有理解它的真实含义,也没有一篇文章,包括我所见到的所有介绍JAVA的书籍(包括TKJ...
  • Caused by: java.lang.VerifyError: Cannot inherit from final class at java.lang.ClassLoader.defineClass1(Native Method) at java.lang.ClassLoader.defineClass(ClassLoader.java:621) at java.security....
  • final方法:表示方法不可被子类重写(覆盖) final变量:初始化一次后值不可变 final类:类不能被继承,内部的方法和变量都变成final类型 final对象:指对象的引用不可变,但是对象的值可变,即指向的是同一个...
  • final int i; final Mydate md; FinalTest(){ i=4; md=new Mydate(); } public static void main(String args[]){ FinalTest ft=new FinalTest(); // ft.md=new Mydate(); --------这里我的...
  • java中的Static、final、Static final各种用法

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

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

    万次阅读 多人点赞 2018-08-07 22:24:12
    final在Java中是一个保留的关键字,可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初始化的话,编译器会报编译错误。 一....
  • private final BigInteger lastNumber; private final BigInteger[] lastFactors; /** * 如果在构造函数中没有使用 Arrays.copyOf()方法,那么域内不可变对象 lastFactors却能被域外代码改变 * 那么 ...
  • 一、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; .....
  • 那么原来子控件的位置不会随着它的item变化,意思就是说,以前viewholder中子控件的位置(position)是5的话,那么就算有1条新数据添加上,它的位置(position)还是5,并不会变成6,我想应该是这个final的原因,导致不会变化,...
  • Java 中的final类与普通类几乎没有区别,只是失去了被继承的权力。 1 什么是final类 API中的某些类,如String,以及Math等,就是final类的典型例子。虽然在Java编程中并不经常使用final类和final方法,但它们有着...
  • 有小伙伴很认真地参考着学习了一下,并且在学习的过程中提出了新的问题:“老哥,当我在使用 Lambda 表达式中使用变量的时候,编译器提醒我‘Local variable limit defined in an enclosing scope must be final or ...
  • final 和effectively final区别

    千次阅读 2019-01-03 10:02:01
    参考: ... 最近在学习多线程的知识,感觉自己超级无知,写了这么久代码,我连匿名内部类都搞不太懂哈哈,但是我愿意学,哪怕从头开始。 首先贴一下我学习的代码 ... import java.util.ArrayList;... ...

空空如也

1 2 3 4 5 ... 20
收藏数 170,353
精华内容 68,141
关键字:

final