标签: final

有人告诉我,我误解了final.的影响.final关键字有什么影响？

以下简要概述了我的想法,我知道:

Java final修饰符(又称聚合关系)

原始变量:只能设置一次.(内存和性能增益)
对象变量:可以修改,最终适用于对象引用.
字段:只能设置一次.
方法:不能被覆盖,隐藏.
课程:不能扩展.
垃圾收集:将强制Java世代垃圾收集标记扫描双扫.

Can's和Cant's

• 可以使克隆失败(这既好又坏)
• 可以使不可变的原语aka const
• 可以使空白不可变 - 在创建时初始化也称为readonly
• 可以使对象浅不可变
• 可以使范围/可见性不可变
• 可以使方法调用开销更小(因为它不需要虚拟表)
• 可以使方法参数用作final(即使你不是)
• 可以使对象线程安全(如果对象被定义为final,它不会使方法参数最终)
• 可以进行模拟测试(不是你可以对它做任何事情 - 你可以说错误是有意的)
• 不能交朋友(与其他朋友互相变化,休息不变)
• 以后不能将变为不可变的变量(但可以像工厂模式一样修复)
• 无法使数组元素成为不可变的,也是不可变的
• 无法创建对象的新实例(这既好又坏)
• 无法进行序列化工作

没有替代品final,但有包装+私人和枚举.

维基百科在C++ 11 final修饰符上有以下示例:

struct Base2 {
    virtual void f() final;
};

struct Derived2 : Base2 {
    void f(); // ill-formed because the virtual function Base2::f has been marked final
};

我不明白引入虚拟功能并立即将其标记为最终功能.这只是一个不好的例子,还是有更多的东西？

我找不到finalPython中相当于Java的文档,有这样的东西吗？

我正在创建一个对象的快照(如果有任何失败则用于恢复); 一旦分配了这个备份变量,它就不应该被修改 - Python中的类似最终功能对此非常有用.

让我们从一个简单的测试用例开始:

import java.lang.reflect.Field;

public class Test {
  private final int primitiveInt = 42;
  private final Integer wrappedInt = 42;
  private final String stringValue = "42";

  public int getPrimitiveInt()   { return this.primitiveInt; }
  public int getWrappedInt()     { return this.wrappedInt; }
  public String getStringValue() { return this.stringValue; }

  public void changeField(String name, Object value) throws IllegalAccessException, NoSuchFieldException {
    Field field = Test.class.getDeclaredField(name);
    field.setAccessible(true);
    field.set(this, value);
    System.out.println("reflection: " + name + " = " + field.get(this));
  }

  public static void main(String[] args) throws …

情况1

class Program {
    static final int var;

    static {
        Program.var = 8;  // Compilation error
    }

    public static void main(String[] args) {
        int i;
        i = Program.var;
        System.out.println(Program.var);
    }
}

案例2

class Program {
    static final int var;

    static {
        var = 8;  //OK
    }

    public static void main(String[] args) {
        System.out.println(Program.var);
    }
}

为什么案例1会导致编译错误？

我知道Final类的定义是什么,但我想知道如何以及何时真正需要final.

<?php
final class Foo extends Bar
{
   public function()
   {
     echo 'John Doe';
   }
}

如果我理解正确,'final'使它能够扩展'Foo'.

任何人都可以解释何时以及为什么应该使用'final'？换句话说,有没有理由不扩展课程？

例如,如果类'Bar'和类'Foo'缺少某些功能,那么创建一个扩展'Bar'的类会很好.

class WithPrivateFinalField {
    private final String s = "I’m totally safe";
    public String toString() {
        return "s = " + s;
    }
}
WithPrivateFinalField pf = new WithPrivateFinalField();
System.out.println(pf);
Field f = pf.getClass().getDeclaredField("s");
f.setAccessible(true);
System.out.println("f.get(pf): " + f.get(pf));
f.set(pf, "No, you’re not!");
System.out.println(pf);
System.out.println(f.get(pf));

输出:

s = I’m totally safe
f.get(pf): I’m totally safe
s = I’m totally safe
No, you’re not!

为什么它以这种方式工作,你能解释一下吗？第一个印刷品告诉我们私人"s"字段没有像我期望的那样被改变.但是如果我们通过反射获得该字段,则第二个打印显示,它会更新.

我有一个定义不可变值类型的类,我现在需要序列化.不变性来自构造函数中设置的最终字段.我已经尝试过序列化,它的确有效(令人惊讶的是？) - 但我不知道如何.

这是该课程的一个例子

public class MyValueType implements Serializable
{
    private final int value;

    private transient int derivedValue;

    public MyValueType(int value)
    {
        this.value = value;
        this.derivedValue = derivedValue(value);
    }

    // getters etc...
}

鉴于该类没有没有arg构造函数,它如何实例化并设置最终字段？

(旁边 - 我注意到这个类特别是因为IDEA没有为这个类生成"no serialVersionUID"检查警告,但是成功地为我刚刚可序列化的其他类生成了警告.)

必须是不可变对象的所有属性都是final？

据我说不.但我不知道,我是否正确.

据我所知,override关键字声明给定的声明实现了一个基本virtual方法,如果找不到匹配的基本方法,编译应该失败.

我对该final关键字的理解是它告诉编译器没有类会覆盖这个virtual函数.

那是override final多余的吗？好像编译好了.哪些信息override final传达的final不是？这种组合的用例是什么？