标签: final

在C++标准中,闭包类型定义如下:

[expr.prim.lambda.closure] lambda表达式的类型(也是闭包对象的类型)是一个唯一的,未命名的非联合类类型,称为闭包类型,其属性如下所述.[...]

该标准似乎并未定义未命名的非联合类类型是否为final.将lambdas实现为最终类的编译器是否符合标准,或者我们是否可以保证可以从lambdas继承？

问题不在于从lambdas继承是否有用:它是有用的.问题是标准是否提供此保证.

在类中声明final变量(常量)时,例如:

private static final int MyVar = 255;

如果我有100,000个声明这个类的实例,那么这需要多少内存？

它会将变量链接到类,因此具有1*MyVar内存使用(忽略内部指针),还是会链接到此变量的实例并创建此变量的100,000*MyVar副本？

令人难以置信的快速反应!共识似乎是,如果变量既是静态的又是最终的,那么它将需要1*MyVar.谢谢大家!

这样做的原因是:

public void processSomething(final String hello, final String two, final Car car){}

而不是:

public void processSomething(String hello, String two, Car car){}

我的问题主要是关于表现.编译器更清楚地知道,例如,在对象实例化之后,某些变量未被修改.那么,为什么要打扰决赛呢？

我认为可能会有许多结构/逻辑原因,但从性能的角度来看呢？有关系吗？

谢谢,

我想知道标记为final的变量是如何被Groovy解释的(在1.8.0,1.8.1中).我知道它在Java中是有意义的,它可以提高性能 - 当然 - 有助于避免愚蠢的错误.我想学习final是否可以帮助java编译器优化用Groovy编写的程序.我想知道Groovy变换器是否保留变量的最终标记.

拿这两个Java类:

class User {
   final Inventory inventory;
   User (Inventory inv) {
       inventory = inv;
   }
}

class Inventory {
   final User owner;
   Inventory (User own) {
       owner = own;
   }
}

有没有办法没有使用反射*来解决这个问题？我实际上并不指望它是,但它可以不会受到质疑.

更新:因为在字节码构造中有两个步骤(1.分配对象,2.调用构造函数**)这可能是(ab)用来做手写字节码或自定义编译器吗？我正在谈论首先对两个对象执行步骤1,然后使用步骤1中的参考执行步骤2.当然,类似的东西会相当麻烦,这部分问题是学术性的.

(*因为反射可能会给安全管理员带来麻烦)

(**说我的知识有限)

我有一个变量,它不应该在初始化后改变它的值,所以我想把它定义为最终变量.

问题是变量必须在try块内初始化,所以我遇到以下麻烦:

我有以下代码:

Connection conn = null;
try {
    conn = getConn(prefix);
    [...do some stuff with conn...]
} catch (Exception e) {
    throw new DbHelperException("error opening connection", e);
} finally {
    closeConnection(conn);
}

如果我将变量声明为final,而不将其初始化为null,则会在finally块上得到"局部变量conn可能尚未初始化".另一方面,如果我将其声明为final并将其初始化为null,则会在try块中收到错误"无法分配最终局部变量conn".

编辑:在lxx回答后,我来到这个版本

try {
    final Connection conn = conn = getConn(prefix);
    try {
        return selectAll(conn, sql, params);
    } catch (Exception e) {
        throw new DbHelperException("error executing query", e);
    } finally {
        closeConnection(conn);  
    }
} catch (Exception e) {
    throw new DbHelperException("error opening connection", e);
}

那应该是这样做的方法吗？

- …

如果我在Synapse一个抽象类型的类中有以下语句:

private final List<Synapse> synapses;

是否final允许我仍然能够更改Synapse对象的状态List,但是阻止我将新Synapse对象添加到列表中？如果我错了,你能否解释一下我final在做什么以及什么时候应该使用关键字final.

我正在尝试在超类中实现一个方法,该方法应该可以在子类中使用,但不能更改.考虑一下:

export abstract class BaseClass {
    universalBehavior(): void {
        doStuff(); // Do some universal stuff the same way in all sub classes
        specializedBehavior(); // Delegate specialized stuff to sub classes
    }

    protected abstract specializedBehavior(): void;
}

我的意图是BaseClass的任何子类不仅可以省略实现universalBehavior(),甚至不允许提供实现.这在TypeScript中是不是可能？当我省略子类中的实现时,Intellisense会抱怨.我能做的最好的就是:

export class SubClass extends BaseClass {
    universalBehavior(): void {
        super.universalBehavior();
    }

    specializedBehavior(): void {
        // sub class' implementation
    }
}

显然这是有问题的,因为我必须确保没有子类实现universalBehavior()除了调用之外的任何东西super.universalBehavior().

我目前正在尝试了解有关最终字段的 JLS 部分。

为了更好地理解 JLS 中的文本，我还在阅读Jeremy Manson（JMM 的创建者之一）撰写的The Java Memory Model。

该论文包含让我感兴趣的示例：如果o具有 final 字段的对象对另一个线程可见t两次：

• 在o的构造函数完成之前首先“不正确地”
• o的构造函数完成后的下一个“正确”

然后即使仅通过“正确”发布的路径访问它，也t可以看到半构造的o。

这是论文中的部分：

图 7.3：简单最终语义示例

f1 是最后一个字段；它的默认值为 0

主题 1	主题 2	主题 3
o.f1 = 42; p = o; freeze o.f1; q = o; Run Code Online (Sandbox Code Playgroud)	r1 = p; i = r1.f1; r2 = q; if (r2 == r1) k = r2.f1; Run Code Online (Sandbox Code Playgroud)	r3 = q; j = r3.f1; Run Code Online (Sandbox Code Playgroud)

我们假设 r1、r2 和 …