天道酬勤,学无止境

Cannot assign a value to final variable 'name'

Why isn't Java allowing me to initialize final variables indirectly? I don't see why it shouldn't work, I mean the method will always run so what difference does it make if initialized directly or via method?

This code works:

package com.company;

public class Person {

    private final String name;

    public Person() {
        name = "bob";
    }
}

This one doesn't. (even if I get rid of IO code and hardcode the value assigned to name)

package com.company;

import java.util.Scanner;

public class Person {

    private final String name;

    public Person() {
        askName();
    }

    public void askName() {
        Scanner scanner = new Scanner(System.in);
        name = scanner.nextLine();
    }
}

评论

final fields must be set in the constructor. What you can do is the following.

import java.util.Scanner;

public class Person {

    private final String name;

    public Person() {
        name = askName();
    }

    public static String askName() {
        Scanner scanner = new Scanner(System.in);
        return scanner.nextLine();
    }
}

However, a better option is likely to inject the value you need.

import java.util.Scanner;

public class Person {

    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public static Person askName() {
        Scanner scanner = new Scanner(System.in);
        return new Person(scanner.nextLine());
    }
}

This is common sense. You can only initialize a final variable once.

A constructor can only be called once, so, unless the variable is static, it can be initialized here.

But your method can be called unlimited times, which would cause the variable to be re-referenced, which is just what the final keyword is supposed to avoid of happening.

You can assign values to final member variables in 4 places only:

  1. At the point of declaration

  2. In the constructor

  3. In a static initialization block (if the variable is static)

  4. In a initialization block (if the variable is not static)

It is because final variables cannot be initialized in a method. It needs to be initialized in constructor ,while declaring only or in static blocks only.

You can initialize final variable at 4 places.

  • with declaration
  • in constructor (only non-static)
  • in static initializer (for only static)
  • in instance initializer (only non-static)

static final variable

These variables can be initialized in either the declaration or static initializer.

class Program {
    static final int i1 = 10;
    static final int i2;
    static {
        i2 = 10;
    }
}

final variable

final variables can be initialized in the declaration, instance initializer, or constructor:

class Program {
    final int i1 = 10;
    final int i2;
    final int i3;
    {
        i2 = 10;
    }

    Program() {
        i3 = 10;
    }
}

Local final variables

These variables can be initialized in the declaration or any place after its declaration. The local final variables must be initialized before they are used.

class Program {
    void method() {
         final int i1 = 10;
         final int i2;
         System.out.println(i1);
         i2 = 10;
         System.out.println(i2);
         return ;
    }
}

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Java学习笔记一面向对象final修饰符
    final修饰符 final关键字可用于修饰类、变量和方法,用于表示它修饰的类、方法和变量不可改变。 final修饰变量时,表示该变量一旦获得初始值就不可改变。final既可以修饰成员变量(包括类变量和实例变量),也可以修饰局部变量、形参。 final修饰变量 final成员变量 Java语法规定:final修饰的成员变量必须由程序员显示指定初始值。 成员变量是随类初始化或对象初始化而初始化的。当类初始化时,系统会为该类的类变量分配内存,并分配默认值;当创建对象时,系统会为该对象的实例变量分配内存,并分配默认值。也就是说,当执行静态初始化块时可以对类变量赋初始值;当执行普通初始化块、构造器时可对实例变量赋初始值。因此,成员变量的初始值可以在定义该变量时指定默认值,也可以在初始化块、构造器中指定初始值。 对于final修饰的成员变量而言,一旦有了初始值,就不能被重新赋值,如果既没有在定义成员变量时指定初始值,也没有在初始化块、构造器中为成员变量指定初始值,那么这些成员变量的值将一直是系统默认分配的0、’\u0000’、false或null,这些成员变量也就失去存在的意义。 归纳: 类变量:必须在静态初始化块中指定初始值或声明该类变量时指定初始值,而且只能在两个地方的其中之一指定。实例变量:必须在非静态初始化块、声明该实例变量或构造器中指定初始值,而且只能在三个地方的其中之一指定。
  • TensorFlow supervisor prevents variable assignment: Graph is finalized and cannot be modified
    This code works fine: import tensorflow as tf x = tf.Variable(initial_value=0) with tf.Session() as session: print session.run(x.assign(1)) But this code fails: import tensorflow as tf x = tf.Variable(initial_value=0) supervisor = tf.train.Supervisor(logdir="/tmp") with tf.Session() as session: print session.run(x.assign(1)) The only difference is the instantiation of a tf.train.Supervisor. Note that we don't even use the supervisor to create a managed session. The error is: python tf_supervisor_freeze.py Traceback (most recent call last): File "tf_supervisor_freeze.py", line 6, in <module>
  • 如果将“final”放在变量之前,它会做什么?(What does “final” do if you place it before a variable?)
    问题 非常基本的问题,但是,如果将“final”放在如下变量之前,它会做什么... final EditText myTextField = (EditText) findViewById(R.id.myTextField); final什么作用? 回答1 简答 停止将“myTextField”变量分配给其他内容。 长答案 不会阻止“myTextField”变量发生变异,例如将其字段设置为新值。 使代码更具可读性(恕我直言),因为读者永远不必怀疑“myTextField”变量是否会在代码中重新分配。 防止意外重新分配变量的错误类别(使实例不可变背后的原因相同,只是规模较小)。 由于上述原因,我总是尽可能将“final”修饰符应用于静态字段、实例字段、局部变量和方法参数。 它确实使代码膨胀了一点,但对我来说,额外的可读性和健壮性是值得的。 回答2 在此上下文中,关键字final意味着您无法更新隐式指针myTextField以指向不同的对象(尽管您可以修改myTextField指向的对象)。 该关键字还可用于防止覆盖(当应用于类或方法时)。 您可能会看到这种情况的一个原因是,引用局部变量的匿名类只能引用标记为final变量。 这样匿名类只需要存储一个重复的引用,而不需要维护对本地函数堆栈的完整访问。 例如: Runnable r = new Runnable() { public
  • 基础第一阶段day11——final、匿名内部类习题
    第一题 判断下面代码的输出结果 public class Animal { public final int a=10; public Animal() { a=20; } public Animal(int a) { this.a=a; } } public class Test { public static void main(String[] args) { Animal animal=new Animal(3); System.out.println(animal.a); } } A:10 B:20 C:编译出错 D:运行出错 解析: 答案是 C 编译出错,因为final成员变量只能赋值一次 类里面的final成员变量a已经赋值过了,构造方法里面就不能再赋值 因此直接编译报错 ============================================================================ 第二题 判断下列语句是否正确 A:一个匿名内部类,只会创建一个对象 B:匿名内部类只能在方法内部定义 C:匿名内部类对象的方法只能调用一次 解析 A:正确,匿名内部类是实现类没有名字,每次创建匿名内部类,都是一个新的没有名字的实现类,因此每个匿名内部类只能创建一次对象。 B:错误,匿名内部类还可以在方法参数上面定义 C:匿名内部类创建之后
  • 无法分配最终的局部变量(The final local variable cannot be assigned)
    问题 我有一个座位数组,该数组有两个字符串(已选择和为空)。 单击鼠标后,我想遍历数组并找到选定的座位。 当我按下按钮时,它说: 由于最终的局部变量seatno是在封闭类型中定义的,因此无法分配它。 JButton btnContinue = new JButton("Next"); btnContinue.addMouseListener(new MouseAdapter() { public void mouseClicked(MouseEvent arg0) { for(int x=0;x<17;x++){ if(anArray[x]=="selected"){ seatno = anArray[x]; } } data page=new data(newfrom,newto,newtime,date2,seatno); page.setVisible(true); setVisible(false); } }); btnContinue.setBounds(358, 227, 62, 23); contentPane.add(btnContinue); 回答1 关键是封闭类型中的方法局部变量实际上已复制到匿名类的实例中(这是由于激活框架的问题,但我将不做进一步的详细介绍,因为这与问题无关)。这就是为什么它们需要是final的原因,因为嵌套类型实例中的变量不再相同。 因此
  • 无法将值分配给java中的“最终”变量(cannot assign value to “final” variable in java)
    问题 private void pushButtonActionPerformed(java.awt.event.ActionEvent evt) { final int c=0; final JDialog d=new JDialog(); JLabel l=new JLabel("Enter the Element :"); JButton but1=new JButton("OK"); JButton but2=new JButton("Cancel"); final JTextField f=new JTextField(10); JPanel panel = new JPanel(); but1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { c=Integer.parseInt(f.getText()); d.setVisible(false); d.dispose( ); } }); but2.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ d.setVisible(false); d.dispose( ); } }); }
  • 错误:无法为最终变量赋值(error: cannot assign a value to final variable)
    问题 我正在处理一项任务,但遇到了这个错误:无法为最终变量计数赋值 到目前为止,这是我的代码... public class List { private final int Max = 25; private final int count; private Person list[]; public List() { count = 0; list = new Person[Max]; } public void addSomeone(Person p) { if (count < Max){ count++; // THIS IS WHERE THE ERROR OCCURS list[count-1] = p; } } public String toString() { String report = ""; for (int x=0; x < count; x++) report += list[x].toString() + "\n"; return report; } } 我对 Java 很陌生,显然不是计算机高手,所以请尽可能用最简单的术语解释问题/解决方案。 非常感谢。 回答1 count++; 会抛出错误。 根据甲骨文, 一个 final 变量只能赋值一次。 声明一个变量 final 可以作为有用的文档,它的值不会改变,并且可以帮助避免编程错误。
  • 对于Java接口中的常量,“ public static final”是否多余?(Is “public static final” redundant for a constant in a Java interface?)
    问题 这段代码: interface Config { int MAX_CONN = 20; } 编译并按预期工作。 看起来这与以下内容相同: interface Config { public static final int MAX_CONN = 20; } 对于Java接口中的常量,“公共静态最终”是否多余? 这对于Java 1.1、1.2、1.3、1.4,...,1.8是正确的,还是在Java版本中发生了变化? 回答1 在Interface中声明的变量是隐式的public static final 。 这就是JLS 9.3所说的: 接口主体中的每个字段声明都是隐式的public,static和final 。 可以为此类字段多余地指定任何或所有这些修饰符。 通读JLS以了解执行此操作的原因。 看这个SO答案: 接口变量是静态的,因为不能单独实例化Java接口。 必须在不存在任何实例的静态上下文中分配变量的值。 final修饰符确保分配给接口变量的值是一个真正的常量,不能由程序代码重新分配。 回答2 接口:系统需求服务。 在界面中,默认情况下,变量是由public,static,final访问修饰符分配的。 因为 : public:有时候接口可能会放在其他包中。 因此,它需要从项目中的任何位置访问变量。 static:这样的不完整类无法创建对象。 因此,在项目中
  • Java学习【阶段一[04]】继承与多态(08final关键字)
    一、final关键字的概述 final关键字代表最终的不可改变的 常用四种方法: 1、可以用来修饰一个类 2、可以用来修饰一个方法 3、还可以用来修饰一个局部变量 4、还可以用来修饰一个成员变量 二、final关键字用来修饰一个类 当final关键字用来修饰一个类的时候,格式: public final class 类名称{ //..... } 含义:当前这个类不能有任何的子类。(太监类) 【注意】:一个类如果是final的,那么所有的成员方法都无法进行覆盖重写(因为没儿子) final父类 package Day11_Demo01; /* 当final关键字用来修饰一个类的时候,格式: public final class 类名称{ //..... } 含义:当前这个类不能有任何的子类。(太监类) 【注意】:一个类如果是final的,那么所有的成员方法都无法进行覆盖重写(因为没儿子) */ public final class Myclass /*extends Object*/{ public void method() { System.out.println("方法执行"); } } 没有子类 package Day11_Demo01; //不能使用final类作为父类 public class MysubClass /*extends Myclass*/{ //报错 }
  • JAVA 关键字
    abstract 1.abstract 是关键字,他说明他可以用来修饰类型和方法,他指这个类型或者方法是抽象的,是不知道里面如何实现的,也不用知道是如何实现的。 2.抽象类被abstract 修饰的类型,是具有承载抽象方法能力的类型。 3.抽象方法:只知道方法的特征(方法名,返回值类型,参数列表),但不知道方法具体应该怎么实现的方法,叫做抽象方法,应该使用abstract修饰。 4.抽象方法必须在抽象类中,但抽象类中不一定有抽象方法; 5.抽象方法不能有方法体,就是不能有{}。 6.抽象类存在的意义就是为了让别人继承,抽象方法的存在就是为了让别人重写。 7.抽象类不能创建对象,就算抽象类中没有抽象方法,也不能创建对象,但可以有构造方法。 final (不能改值,类不能继承,不能重写) 1.final可以修饰属性 ,方法和类 2.final 修饰属性,该属性不能被修改(重新指定内存位置),必须直接赋值或者用构造方法直接赋值,而且不能用 = ,++,-- 号重新赋值改变了;被final修饰的属性叫常量。(public final int a =4;),final 修饰属性,如果用构造参数赋值,必须每次都赋值。 3.final 修饰的方法不能被重写,但可以继承,可以重载。 4.final 修饰的类不能被继承。 举例: final修饰容器,容器不能再修改,但容器中的内容可以更改;
  • 【Java基础】一文全面了解Java关键字
    大家好,我是程序员青戈,一个被Bug耽误了才艺的程序员👦专注于Java领域的知识分享和技术交流,每天会给大家带来Java学习的干货教程📚 微信搜索公众号 Java学习指南,回复 面试 领取一线大厂面试题一套😋加号主微信 xia_qing2012,可以进技术交流学习群一起共同进步哦😊 文章目录 Java关键字汇总final 关键字final 修饰类final 修饰方法final 修饰变量 static 关键字static 变量static 代码块 this 关键字引用成员变量调用类的构造器方法返回对象的引用 关于作者 Java 有一系列的关键字,在代码中各自有自己的重要用途与意义,今天就带着大家一起来了解一下 Java 的关键字! Java 的关键字特别多,本文先主要介绍一下各个关键字的用途,然后重点介绍一下 final、static 和 this 这三个常用的关键字,其他的关键字大家用到的时候可以去网上查一下。 Java关键字汇总 数据类型含义abstract表明类或者成员方法具有抽象属性assert断言,用来进行程序调试boolean基本数据类型之一,布尔类型break提前跳出一个块byte基本数据类型之一,字节类型case用在switch语句之中,表示其中的一个分支catch用在异常处理中,用来捕捉异常char基本数据类型之一,字符类型class声明一个类const保留关键字
  • final和引用类型
    一、final关键字 作用:可以用于修饰类、方法和变量。 规则: 类:被修饰的类,不能被继承。方法:被修饰的方法,不能被重写。变量:被修饰的变量,不能被重新赋值 具体: 1、final修饰局部变量——基本类型 基本类型的局部变量,被final修饰后,只能赋值一次,不能再更改 2、final修饰局部变量——引用类型 引用类型的局部变量,被final修饰后,只能指向一个对象,地址不能再更改。但是不影响对象内部的成员变量值的 修改 被final修饰的常量名称,一般都有书写规范,所有字母都大写 二、引用类型用法总结 引用类型可以作为成员变量、作为方法的参数、作为方法的返回值 1、使用一个接口,作为成员变量,可以随时更换功能,这样的设计更为灵活,增强了程序的扩展性。 接口作为成员变量时,对它进行赋值的操作,实际上,是赋给它该接口的一个子类对象。 2、接口作为参数时,传递它的子类对象。 接口作为返回值类型时,返回它的子类对象。 来源:https://blog.csdn.net/iamyzy00/article/details/106820716
  • 有一个实例变量作为最终的点?(point of having an instance variable as final?)
    问题 将实例变量作为最终变量有什么意义? 那么将该变量设置为静态最终变量不是更好吗? 因为如果它不能被任何对象更改,那么它与类(静态)变量相同,对吗? 回答1 不。 static意味着它在类的所有实例中都是相同的。 final意味着它在初始分配后不可分配。 因此,对于非静态最终变量,两个实例可能具有不同的值。 您可能希望将变量设为 final 的原因有很多; 最好的之一是清晰度。 如果我阅读了一个方法并注意到 foo 是最终的,我不必担心它在下面的位置发生变化 - 因为它不是; 它不能。 我可以对带有最终变量的代码进行更多更改,而不必担心(“我在 bar 之前还是之后更改了 foo 的值,这有关系吗?”),因为我知道某些变量不会更改。 它还侧重于那些可能发生变化的变量我的注意-他们是值得更多的关注的人。 回答2 两个原因: 1) 从类设计的角度来看,它允许程序员依赖这样一个事实,即字段自实例化后不会改变——所谓的“不可变对象”(应用于类成员,而不是对象的引用)。 Java教程说: 不可变对象在并发应用程序中特别有用。 因为它们不能改变状态,所以它们不会被线程干扰破坏或在不一致的状态下被观察到。 不可变对象是各种编程风格的基石,例如纯函数式编程。 2)第二个原因是JVM优化。 如果所有字段都是最终的,那么 JVM 知道对象的状态不能改变,因此它可以进行许多优化,例如省略线程安全检查等
  • JAVA学习笔记_入门基础
    文章目录 JAVA学习笔记_入门基础1. 符号及类型1.1 添加注释comment1.2 关键字keywords1.3 标识符1.4 常量1.5 变量和数据类型1.6 数据类型的转换1.7 ASCII编码表 在这里插入图片描述 2. 运算符2.1 算数运算符2.2 赋值运算符2.3 比较运算符2.4 逻辑运算符2.5 三元运算符2.6 常量和变量的运算 3. 方法的入门学习3.1 方法的定义3.2 方法的调用3.3 注意事项 4. java中的流程控制语句4.1 顺序结构4.2 判断语句4.3 判断语句 `switch`4.4 循环语句4.4.1 `for` 循环4.4.2 `while`循环:4.4.3 `do - while`循环:4.4.4 几种循环语句的区别: 5. Java 中的四种权限修饰符6. 关键字final6.1 final 修饰类6.2 final 修饰方法6.3 final 修饰局部变量6.4 final 修饰成员变量 JAVA学习笔记_入门基础 1. 符号及类型 1.1 添加注释comment 注释:就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释,是十分必须要的,它不影响程序的编译和运行。Java中有单行注释和多行注释 单行注释以 //开头 换行结束多行注释以 /*开头 以*/结束 1.2 关键字keywords 关键字
  • 静态和最终之间的区别?(Difference between Static and final?)
    问题 我总是在java的static和final关键字之间感到困惑。 它们有何不同? 回答1 static关键字可以在4种情况下使用 静态变量静态方法静态代码块静态嵌套类 首先让我们看一下静态变量和静态方法。 静态变量 它是一个属于类而不属于对象(实例)的变量。 静态变量在执行开始时仅初始化一次。 在初始化任何实例变量之前,将首先初始化这些变量。 该类的所有实例共享的单个副本。 静态变量可以通过类名直接访问,不需要任何对象。 语法: Class.variable 静态方法 它是属于类而不属于对象(实例)的方法。 静态方法只能访问静态数据。 除非具有/创建该类的实例,否则它无法访问非静态数据(实例变量)。 静态方法只能调用其他静态方法,而不能从其调用非静态方法,除非它具有/创建了该类的实例。 静态方法可以通过类名直接访问,并且不需要任何对象。 语法: Class.methodName() 静态方法无论如何都不能引用this关键字或super关键字。 静态类 Java还具有“静态嵌套类”。 静态嵌套类只是一个没有隐式引用外部类实例的类。 静态嵌套类可以具有实例方法和静态方法。 Java中没有顶级静态类。 边注: main方法是static因为在进行任何实例化之前,应用程序必须可以访问该方法才能运行。 在几个不同的上下文中使用final关键字定义一个实体,以后不能更改它。
  • Dart入门宝典第三章——面向对象编程之类的介绍
    类与对象 使用关键字class声明一个类 class Person{ } 使用关键字new创建一个对象,new可省略 void main() { var p1 = new Person(); var p2 = Person(); } 所有对象都继承于Object类 属性与方法 属性默认会生成getter和setter方法 void main() { var p = new Person(); p.name = "黄家驹"; p.age = 31; print("name = ${p.name}, age = ${p.age}"); } class Person{ String name; int age; } 打印结果: name = 黄家驹, age = 31 可以看到属性name和age可以被重新赋值,且可以被获取,即默认生成了setter和getter方法 使用final声明的属性只有getter方法 void main() { var p = new Person(); // p.gender = "Female"; 报错提示:'gender' can't be used as a setter because it's final print("gender = ${p.gender}"); } class Person{ String name; int age
  • Java基础|1-06-final_权限_内部类 @面向对象篇
    写在前面: 此系列文是笔者在学习黑马的Java系列课程的过程中,参考相关课件、视频讲解、课程代码,并结合一些文档、思维导图及个人理解,对所学内容做的阶段性梳理与总结。 写于:2021年1月30日 ~ 31日内容:Java后端系列笔记006(Java基础-final_权限_内部类)全文:5665字 文章目录 一、final关键字1. 1 概述1. 2 使用方式 二、权限修饰符2. 1 访问能力2. 2 使用建议 三、内部类3. 1 概述3. 2 成员内部类3. 3 局部内部类3. 4 匿名内部类 ★ 一、final关键字 1. 1 概述 概念 final是Java提供的一个关键字,代表最终、不可改变的 用法 final可修饰说明类被final修饰的类,不能有任何的子类。即:不能被继承方法被final修饰的方法就是最终方法,不能被覆盖重写变量(局部变量/成员变量)若使用final修饰,则该变量是不可变的。即:不能被重新赋值 1. 2 使用方式 修饰类 格式: final class 类名称 { // ... } 注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没儿子)代码演示:(被final修饰的类,不能有任何的子类) // 当前类 (默认继承Object类) public final class MyClass /*extends Object*/ {
  • 2021-04-11
    第九节 三个修饰符 abstract(抽象类、抽象方法) 1、生活中的抽象:搜索动物,全是动物的子类对象,却没有动物的具体对象, 2、不被创建的对象:程序是模拟现实世界,解决现实问题的,现实中存在的都是动物的子类对象,并无动物对象。所以Animal不该被独立创建成对象。 3、抽象类:被abstract修饰的类,称为抽象类,抽象类意为不够完整的类,不够具体的类,抽象类对象无法独立存在,即不能new对象。 4、抽象类的作用: 4.1、可被子类继承,为子类提供共性的属性和方法 4.2、可声明为引用,更自然的使用多态,如Animal a=new sheep(),Animal a 声明为引用了,父类引用直线指向子类对象。 4.3、经验:抽象父类,可作为子类的组成部分,依附于子类对象存在,由父类共性+子类独有,组成了完整的子类对象。 5、不该被实现的方法 5.1、Dog中的eat()应输出为“狗在吃骨头”Cat中的eat()应输出为“猫在吃鱼” 5.2、父类提供的方法无法满足子类不同需求,如不定义,则表示所有动物都不会吃、睡。如定义,略显多余,多数会被子类所覆盖。 5.3、方法声明必要,方法实现多余 6、抽象方法:被abstract修饰的方法,称为抽象方法,只有方法声明,没有方法实现({}里的部分),意为不完整的方法,必须包含在抽象类里面。 7、产生继承关系之后
  • Delphi 编译错误信息表
    Delphi 编译错误信息表 ; not allowed before ELSE ElSE前不允许有“;” <clause> clause not allowed in OLE automation section 在OLE自动区段不允许“<clause>”子句 <name> is not a type identifier <name>不是类型标识符 <name> not previously declared as a PROPERTY <name>前面没有说明PROPERTY GOTO <label> leads into or out of TRY statement GOTO <label>进入或超出TRY语句的范围 <clause1> clause expected, but <clause2> found 要求子句<clause1>,但出现<clause2> 16-Bit fixup encountered in object file <text> 在对象文件<text>遇到16位修复 486/487 instructions not enabled 不能用486/487指令 Abstract methods must be virtual or dynamic 抽象方法必须为虚拟的或动态的 Array type required 需要数组类型 Assignment
  • 详解Java中final关键字
    final关键字: 使用final来修饰的类叫作final类。final类通常功能是完整的,它们不能被继承。Java中有许多类是final的,譬如String, Interger以及其他包装类。 final在Java中是一个保留的关键字,可以声明成员变量、方法、类以及局部变量。一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初始化的话,编译器会报编译错误。 (一)final修饰类 1.final修饰一个类的时候,表明该类不可再被继承; 特点: (1)在被final修饰的类中,该类的成员变量可根据自己定义是否用final修饰; (2)该类的成员方法隐式被final修饰; (二)final修饰成员变量 1.final修饰的成员变量有两种赋值方法: (1)定义时候初始化直接赋值; (2)通过本类中的构造方法赋值; 2。被final修饰的成员变量赋值以后不可再被更改; (三)final修饰成员方法 1.final修饰的成员方法不能被重写; 特点: (1)如果你认为一个方法的功能已经足够完整了,子类中不需要改变的话,你可以声明此方法为final。final方法比非final方法要快,因为在编译的时候已经静态绑定了,不需要在运行时再动态绑定。 (四)final关键字的好处 (1)final关键字提高了性能。JVM和Java应用都会缓存final变量。