当其中一个应该使用最终用的方法的参数和地方变量?

Question

我发现一对夫妇参考(例如)，建议使用 final 尽可能多的我想知道如何重要。这主要是在上下文的方法的参数和地方的变量，不是最终的方法或类。用常数，它使得显而易见的意义。

在一方面，编译器可以使一些优化，它使程序的目的更加清晰。另一方面，它增加了详细和优化可以是微不足道的。

是什么事情我应该做出努力，记得吗？

Answer 1

迷恋:

• 最后领域的标领域作为最后迫使他们要设施工结束，使得这一领域的参考不可改变的。这可以让安全出版物的领域和可以避免需要同步时以后阅读。(注意，对于一个目的参考，只有领域的参考是不可改变的事物的参考指的是仍然可以改变和影响的不变性。)
• 最终的静态领域的-尽管我使用枚举，现在多数情况下，在那里我用来使用的是静态的最终领域。

考虑，但明智地使用:

• 最终的课程-框架/API设计是唯一的情况下，我认为它。
• 最后方法--基本上相同的作为最后的课程。如果你使用模板方法的模式喜欢疯狂和标记的东西最终，你可能依赖过多的遗产并没有足够的代表团。

忽视，除非感觉肛门:

• 方法的参数和地方变量-我很少这样做主要是因为我懒而且我发现它会扰乱代码。我会完全承认，标志着参数和地方变量那我不打算修改是"正确了".我希望它是默认。但它是不是和我找到代码更加难以理解与总决赛。如果我在其他人的代码，我不会去拉他们出来但如果我在写新的码我不会放他们。是一个例外的情况，你要记的东西最终的，所以你可以访问的内部匿名内部流的。

Answer 2

  

我应该努力记住这件事吗？

不，如果您使用的是Eclipse，因为您可以将Save Action配置为自动为您添加这些 final 修饰符。然后，您可以轻松获得收益。

Answer 3

“最终”的开发时间优势。至少与运行时间的好处一样重要。它告诉未来的编辑代码有关你的意图。

标记一个类“最终”表示您在设计或实现类时没有努力优雅地处理扩展。如果读者可以对课程进行更改，并希望删除“最终”的修饰符，他们可以自担风险。他们应该确保班级能够很好地处理扩展。

标记变量“final” （并在构造函数中指定它）对依赖项注入很有用。它表示“协作者”。变量的性质。

标记方法“最终”在抽象类中很有用。它清楚地描绘了扩展点的位置。

Answer 4

我发现标记方法参数和局部作为 final 可用作重构辅助工具，因为所讨论的方法是几页长的难以理解的混乱。自由地撒上 final ，看看“无法分配给最终变量”编译器（或您的IDE）抛出的错误，您可能会发现为什么变量称为“数据”？即使有几条（过时的）评论发誓不会发生这种情况，也会失效。

然后，您可以通过将重用的变量替换为更接近使用点的新变量来修复一些错误。然后你会发现你可以将方法的整个部分包装在作用域括号中，然后你突然想到一个远离“Extract Method”的IDE键盘。而你的怪物更容易理解。

如果你的方法不已经是一个难以维护的残骸，我想最终可能会有一些东西可以阻止人们把它变成残骸;但如果它是一个简短的方法（参见：不是不可维护的），那么你冒着增加大量冗长的风险。特别是，Java函数签名非常难以适应80个字符，而不是每个参数增加6个字符！

Answer 5

我一直使用 final 来使Java更基于表达式。请参阅Java的条件（ if，else，switch ）不是基于表达式的，我一直很讨厌，特别是如果您习惯于函数式编程（即ML，Scala或Lisp）。

因此，您应该尝试在使用条件时始终（IMHO）使用最终变量。

让我举个例子：

    final String name;
    switch(pluginType) {
        case CANDIDATE_EXPORT:
            name = "Candidate Stuff";
            break;
        case JOB_POSTING_IMPORT:
            name = "Blah";
            break;
        default:
            throw new IllegalStateException();
    }

现在如果添加另一个 case 语句而不设置 name ，编译器将失败。如果你不打破每个案例（你设置变量），编译器也会失败。这使得Java可以使Java与Lisp的 let 表达式非常相似，并且使得代码不会大量缩进（因为词法作用域变量）。

正如@Recurse所指出的那样（但显然是-1我）你可以完成前面的操作而无需编写 String name final 来获取编译器错误（我从未说过）你不能）但你可以很容易地使编译器错误消失在switch语句之后设置名称，这会抛弃表达式语义或者更糟糕的是忘记 break 你不能导致错误（尽管是@Recurse说）不使用 final ：

    String name;
    switch(pluginType) {
        case CANDIDATE_EXPORT:
            name = "Candidate Stuff";
            //break; whoops forgot break.. 
            //this will cause a compile error for final ;P @Recurse
        case JOB_POSTING_IMPORT:
            name = "Blah";
            break;
    }
    // code, code, code
    // Below is not possible with final
    name = "Whoops bug";

由于bug设置名称（除了忘记 break 还有另一个bug），我现在可能会意外地执行此操作：

    String name;
    switch(pluginType) {
        case CANDIDATE_EXPORT:
            name = "Candidate Stuff";
            break;
        //should have handled all the cases for pluginType
    }
    // code, code, code
    // Below is not possible with final
    name = "Whoops bug";

最终变量强制单一评估应该是什么名称。类似于具有返回值的函数必须始终返回一个值（忽略异常），名称切换块必须解析名称，从而绑定到该开关块，这使得重构代码块变得更容易（即Eclipe重构：提取方法）

上面的OCaml：

type plugin = CandidateExport | JobPostingImport

let p = CandidateExport

let name = match p with
    | CandidateExport -> "Candidate Stuff"
    | JobPostingImport -> "Blah" ;;

match ... with ... 的评估类似于函数，即表达式。注意它看起来像我们的switch语句。

这是Scheme（球拍或鸡肉）中的一个例子：

(define name 
    (match b
      ['CandidateExport "Candidate Stuff"]
      ['JobPostingImport "Blah"]))

Answer 6

嗯，这一切都取决于你的风格......如果你想看到最终你不会修改变量，那就用它吧。如果你不喜欢看到它......那就把它留下吧。

我个人喜欢尽可能少的冗长，所以我倾向于避免使用非必要的额外关键字。

我更喜欢动态语言，所以我喜欢避免冗长并不奇怪。

所以，我会说只是选择你倾向的方向，然后选择它（无论如何，尽量保持一致）。

---

作为旁注，我参与了使用和不使用这种模式的项目，我发现错误或错误的数量没有差别...我不认为这是一种模式这将极大地改善你的错误数量或任何东西，但它又是风格，如果你想表达你不会修改它的意图，那么继续使用它。

Answer 7

在参数中有用的是避免意外更改参数值并引入一个微妙的错误。我用了忽略这个建议，但花了4个小时后。在一个可怕的方法（有数百行代码和多个fors，嵌套ifs和各种不良做法）我建议你这样做。

 public int processSomethingCritical( final int x, final int y ){
 // hundreds of lines here 
     // for loop here...
         int x2 = 0;
        x++; // bug aarrgg...
 // hundreds of lines there
 // if( x == 0 ) { ...

 }

当然，在一个完美的世界中，这不会发生，但是......好吧..有时你必须支持其他代码。 :(

Answer 8

如果你正在编写一个应用程序，有人必须在1年之后阅读代码，那么是的，使用final不应该一直修改的变量。通过这样做，您的代码将更加“自我记录”。而且你也减少了其他开发人员做傻事的机会，比如使用局部常量作为本地临时变量。

如果你正在写一些一次性代码，那么，不，不要费心去识别所有的常数并让它们成为最终的。

Answer 9

我会尽可能多地使用final。如果您无意中更改了字段，则会执行此操作。我还将Method参数设置为final。这样做我已经从代码中找到了一些错误，当我们尝试“设置”一个忘记Java传递值的参数时，我接管了这些错误。

Answer 10

从问题中不清楚这是否显而易见，但制作方法参数final只影响方法的主体。它 NOT 向调用者传达有关方法意图的任何有趣信息。传入的对象仍然可以在方法中变异（决赛不是consts），变量的范围在方法中。

要回答你的确切问题，除非代码需要它（例如，变量是从内部类引用），或者澄清一些非常复杂的逻辑，否则我不会费心去做一个实例或局部变量（包括方法参数）final。

对于实例变量，如果它们是逻辑常数，我会将它们作为最终变量。

Answer 11

变量 final 有很多用途。这里只是几个

最终常数

 public static class CircleToolsBetter {
     public final static double PI = 3.141;
        public double getCircleArea(final double radius) {
          return (Math.pow(radius, 2) * PI);
        }
    }

这可以用于代码的其他部分，或者由其他类访问，如果您想要更改值，则不必逐个更改它们。

最终变量

public static String someMethod(final String environmentKey) {
    final String key = "env." + environmentKey;
    System.out.println("Key is: " + key);
    return (System.getProperty(key));

  }

}

在此类中，您将构建一个作用域的final变量，该变量为参数environmentKey添加前缀。在这种情况下，最终变量仅在执行范围内是最终的，在每次执行该方法时都是不同的。每次输入方法时，都会重建最终结果。一旦构造，就不能在方法执行的范围内更改它。这允许您在方法的持续时间内修改方法中的变量。见下文：

public class FinalVariables {


  public final static void main(final String[] args) {
    System.out.println("Note how the key variable is changed.");
    someMethod("JAVA_HOME");
    someMethod("ANT_HOME");
  }
}

最终常数

public double equation2Better(final double inputValue) {
    final double K = 1.414;
    final double X = 45.0;

double result = (((Math.pow(inputValue, 3.0d) * K) + X) * M);
double powInputValue = 0;         
if (result > 360) {
  powInputValue = X * Math.sin(result); 
} else {
  inputValue = K * Math.sin(result);   // <= Compiler error   
}

当你有很长的代码行时，它们会特别有用，并且会产生编译器错误，因此当有人意外更改了不应更改的变量时，你不会遇到逻辑/业务错误。

最终收藏

当我们谈论集合时，您需要将它们设置为不可修改的。

 public final static Set VALID_COLORS; 
    static {
      Set temp = new HashSet( );
      temp.add(Color.red);
      temp.add(Color.orange);
      temp.add(Color.yellow);
      temp.add(Color.green);
      temp.add(Color.blue);
      temp.add(Color.decode("#4B0082")); // indigo
      temp.add(Color.decode("#8A2BE2")); // violet
      VALID_COLORS = Collections.unmodifiableSet(temp);
    }

否则，如果您不将其设置为不可修改：

Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler

无法分别扩展或覆盖

最终课程和最终方法。

编辑：解决关于封装的最终类别问题：

有两种方法可以让课程最终成功。第一种是在类声明中使用关键字final：

public final class SomeClass {
  //  . . . Class contents
}

使类最终成功的第二种方法是将其所有构造函数声明为private：

public class SomeClass {
  public final static SOME_INSTANCE = new SomeClass(5);
  private SomeClass(final int value) {
  }

如果发现它确实是最终版本，那么将它标记为最终可以省去麻烦，以展示这个Test类。乍一看看起来很公开。

public class Test{
  private Test(Class beanClass, Class stopClass, int flags)
    throws Exception{
    //  . . . snip . . . 
  }
}

不幸的是，由于该类的唯一构造函数是私有的，因此无法扩展此类。对于Test类，没有理由认为该类应该是final。 Test类是隐式final类如何导致问题的一个很好的例子。

因此，当您通过使其构造函数为私有来隐式地使类成为最终时，您应该将其标记为最终。

Answer 12

如你所说，有些权衡取舍，但我更喜欢明确使用某些内容而不是隐式使用。这将有助于消除未来代码维护者的一些歧义 - 即使只是你。

Answer 13

如果你有内部（匿名）类，并且该方法需要访问包含方法的变量，则需要将该变量作为final。

除此之外，你所说的是对的。

Answer 14

如果要将变量设为 immutable

，请将 final 关键字用于变量

通过将变量声明为final，它可以帮助开发人员排除高度多线程环境中变量的可能修改问题。

在Java 8发布版中，我们还有一个名为“ 有效最终变量 ”的概念。 非最终变量可以作为最终变量。

从lambda表达式引用的局部变量必须是最终的或有效的最终

  

如果在本地块中初始化后未修改变量，则将变量视为 有效最终 。这意味着你现在可以在匿名类或lambda表达式中使用没有final关键字的局部变量，前提是它们必须是有效的最终版本。

直到Java 7，您不能在匿名类中使用非最终局部变量，但是从Java 8中可以

看看这个文章

Answer 15

一个非常简单的答案我们有3个案例的最终变量，最终的方法＆amp;＆amp;最后的课程..

1.Final with variable：你不能多次分配这个变量..

2.Final with methods：你不能覆盖这个方法..

3.Final with classes：你不能扩展任何最终类

Answer 16

首先，final关键字用于使变量保持不变。常数意味着它不会改变。例如：

final int CM_PER_INCH = 2.54;

你会声明变量final，因为每英寸厘米不会改变。

如果您尝试覆盖最终值，则该变量首先被声明。例如：

final String helloworld = "Hello World";
helloworld = "A String"; //helloworld still equals "Hello World"

编译错误类似于：

local variable is accessed from inner class, must be declared final

如果您的变量不能被声明为final或者您不想将其声明为final，请尝试：

final String[] helloworld = new String[1];
helloworld[0] = "Hello World!";
System.out.println(helloworld[0]);
helloworld[0] = "A String";
System.out.println(helloworld[0]);

这将打印：

Hello World!
A String