标签: final

添加private和final使用相同的方法是多余的吗？

class SomeClass {

    //--snip--

    private final void doStuff()
    {
        // private work here
    }
}

如果是的话private,任何人都无法覆盖它,对吗？

final如果没有效果,为什么可以添加关键字？(或者我错过了什么？)

我有一个最终的非静态成员:

private final HashMap<String,String> myMap;

我想使用构造函数调用的方法初始化它.由于myMap是final,我的"helper"方法无法直接初始化它.我当然有选择:

我可以直接在构造函数中实现myMap初始化代码.

MyConstructor (String someThingNecessary)
{
    myMap = new HashMap<String,String>();

    myMap.put("blah","blahblah");
    // etc...

    // other initialization stuff unrelated to myMap
}

我可以让我的帮助器方法构建HashMap,将其返回到构造函数,然后让构造函数将对象分配给myMap.

MyConstructor (String someThingNecessary)
{
    myMap = InitializeMyMap(someThingNecessary);

    // other initialization stuff unrelated to myMap
}

private HashMap<String,String> InitializeMyMap(String someThingNecessary)
{
    HashMap<String,String> initializedMap = new HashMap<String,String>();

    initializedMap.put("blah","blahblah");
    // etc...

    return initializedMap;
}

方法#2很好,但是,我想知道是否有某种方法可以让helper方法直接操作myMap.也许一个修饰符指示它只能由构造函数调用？

MyConstructor (String someThingNecessary)
{
    InitializeMyMap(someThingNecessary);

    // other initialization stuff unrelated to myMap
}


// helper doesn't work since it can't modify …

引自http://sites.google.com/site/gson/gson-design-document:

为什么Gson中的大多数课程都被标记为最终？

虽然Gson通过提供可插拔序列化器和反序列化器提供了相当可扩展的架构,但Gson类并未专门设计为可扩展.提供非最终类将允许用户合法地扩展Gson类,然后期望该行为在所有后续修订中工作.我们选择通过将类标记为final来限制这样的用例,并等到出现良好的用例以允许扩展性.标记类final也有一个很小的好处,即为Java编译器和虚拟机提供额外的优化机会.

为什么会这样？[如果我猜测:JVM知道类是最终的,它不维护方法覆盖表？还有其他原因吗？]

性能有什么好处？

这是适用于频率实例化的类(POJO？)还是适用于持有静态方法(实用类)的类？

定义为final的方法在理论上也可以提高性能吗？

有什么影响吗？

谢谢你,马克西姆.

可能重复:
字符串和最终

从http://docs.oracle.com/javase/6/docs/api/java/lang/String.html我可以读到:

Strings are constant; their values cannot be changed after they are created. 

这是否意味着final String在某种意义上该final属性在某种程度上是多余的,在Java中实际上没有意义？

这段代码:

interface Config {
    int MAX_CONN = 20;
}

编译和按我的预期工作.它看起来像是:

interface Config {
    public static final int MAX_CONN = 20;
}

对于Java接口中的常量,"public static final"是多余的吗？这对于Java 1.1,1.2,1.3,1.4,...,1.8是否适用,或者是否在Java版本中进行了更改？

我只是注意到可以final在Scala中声明对象:

final object O

这样做有什么意义？无论如何,无法继承对象:

object A
object B extends A // not found: type A

class A {
public:
    virtual void f() = 0;
};

class B : public A {
public:
    void f() final override { };
};

int main() {
    B* b = new B();
    b->f();
}

在这种情况下,编译器是否仍需要执行v表查找b->f();,或者是否可以B::f()直接调用,因为它已被标记final？

我有一个非常简单的问题:

我想要一个Java类,它提供了一个公共静态方法,它可以做一些事情.这仅用于封装目的(在一个单独的类中包含所有内容)...

这个类既不应该被实例化,也不应该被扩展.这让我写道:

final abstract class MyClass {
   static void myMethod() {
      ...
   }
   ... // More private methods and fields...
}

(虽然我知道,这是禁止的).

我也知道,我可以使这个类完全是final,并覆盖标准构造函数,同时将其设为私有.

但在我看来,这更像是一种"解决方法",并且应该更有可能通过最终的抽象类来完成......

而且我讨厌变通方法.所以只是为了我自己的兴趣:还有另一种更好的方法吗？

考虑：

class UnderstandingConversion {
    public static void main(String[] args) {

        int a=10, b=20;

        byte c = (a>b) ? 40 : 50;

        System.out.println(c);
        // output : lossy conversion error
    }
}

这段代码给出了一个错误“有损转换”，我理解，但如果我final在代码中使用关键字，如下所示，它工作正常。

class UnderstandingConversion {
    public static void main(String[] args) {

        final int a=10, b=20;

        byte c = (a>b)? 40 : 50;

        System.out.println(c);
        // Output: 50

    }
}

这里的工作情况如何final？向下转型是如何发生的？

我正面临一个用例,我想声明一个static final带有初始化语句的字段,该语句被声明为抛出一个已检查的异常.通常,它看起来像这样:

public static final ObjectName OBJECT_NAME = new ObjectName("foo:type=bar");

我在这里遇到的问题是ObjectName构造函数可能会抛出各种已检查的异常,我并不关心这些异常(因为我知道我的名字是有效的,如果它没有崩溃就会崩溃).java编译器不会让我忽略它(因为它是一个经过检查的异常),我宁愿不诉诸:

public static final ObjectName OBJECT_NAME;
static{
    try{
        OBJECT_NAME = new ObjectName("foo:type=bar");
    }catch(final Exception ex){
        throw new RuntimeException("Failed to create ObjectName instance in static block.",ex);
    }  
}

因为静态块确实非常难以阅读.有没有人有一个关于如何以一个漂亮,干净的方式处理这种情况的建议？