标签: final

final关键字如何不使变量成为不可变的？维基百科说它没有.

有人可以澄清下面代码的重要性.

class A
{
    int i = 10;

    public void setI(int b)
    {
        i = b;
    }

    public int getI()
    {
        return i;
    }
}

class Test
{    
    public static void main(String args[]) throws Throwable
    { 
        final A ob = new A();
        ob.setI(10);
        System.out.println(ob.getI());
    }
}

对象A被声明为final,但我可以更改此对象的实例变量的值,并还可以检索更新的值.那么将对象声明为final是什么意义.我知道将原始数据类型声明为final,这使得该变量保持不变.

假设我有一个名为"Base"的类,以及一个名为"Derived"的类,它是Base的子类,并访问受保护的方法和Base的成员.

我现在想要做的就是让它没有其他类可以继承Derived.在Java中,我可以通过声明Derived类"final"来实现这一点.是否有一些C++技巧可以给我同样的效果？

(理想情况下,我希望除了Derived之外没有其他类可以将Base子类化.我不能只将所有代码放入同一个类或使用friend关键字,因为Base和Derived都是模板化的,模板参数比Derived少的基础....)

有没有办法使用JPA映射不可变的Value对象,如电子邮件地址？

@Immutable
@Embeddable
public final class EmailAddress {
    private final String value;

    public EmailAddress(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EmailAddress that = (EmailAddress) o;
        return value.equals(that.value);
    }

    @Override
    public int hashCode() {
        return value.hashCode();
    }
}

现在我在实体保存上得到例外

org.hibernate.InstantiationException: No default constructor for entity: com.domain.EmailAddress
    org.hibernate.tuple.PojoInstantiator.instantiate(PojoInstantiator.java:107)
    org.hibernate.tuple.component.AbstractComponentTuplizer.instantiate(AbstractComponentTuplizer.java:102)
    org.hibernate.type.ComponentType.instantiate(ComponentType.java:515)
    org.hibernate.type.ComponentType.deepCopy(ComponentType.java:434)
    org.hibernate.type.TypeHelper.deepCopy(TypeHelper.java:68)
    org.hibernate.event.def.AbstractSaveEventListener.performSaveOrReplicate(AbstractSaveEventListener.java:302) …

可能重复:
Java静态类初始化

为什么字符串变量在初始化块中更新而不是整数(即使先写入块)

class NewClass
{
    static 
    {
       System.out.println(NewClass.string+" "+NewClass.integer);
    }

    final static String string="static";
    final static Integer integer=1;

    public static void main(String [] args)//throws Exception
    {
    }
}

我的输出是

static null

PS:还注意到只有当我插入final修饰符时,字符串变量初始化才会发生在块之前.为什么会这样？为什么不是整数？我已经将它声明为最终静态

在方法中声明本地内部类时,为什么包含最终的静态字符串或整数是合法的,但包含其他对象却不合法？

例如:

class Outer {
void aMethod() {
    class Inner {
        final static String name = "compiles";
        final static int ctr = 10; // compiles
        final static Integer intThree = Integer.valueOf(3); // does not compile!
        final static obj objConst = new Object(); // does not compile!
    }

    Inner inner = new Inner();
}
}

当我编译它时,我得到以下内容:

InnerExample.java:6: inner classes cannot have static declarations
        final static Integer outer = Integer.valueOf(3);
                             ^
InnerExample.java:7: inner classes cannot have static declarations
        final static Object objConst …

我对这段代码有2个问题

1. 方法1工作正常,方法2没有.这是什么原因？
2. 在方法1中,返回值是字节(8位).但实际上我们返回一个char值(16位).这里到底发生了什么？

//方法1

static byte m1() {
    final char c = 'b'-'a';
    return c; 
}

//方法2

static byte m3(final char c) {
    return c; // 3
}

最终方法不能在子类中重写.但有了Scala的魔力,似乎这是可能的.

请考虑以下示例:

trait Test {
  final def doIt(s: String): String = s
}

object TestObject extends Test {
  def doIt: String => String = s => s.reverse
}

该方法doIt中的对象TestObject具有不相同的签名doIt中的性状Test.因此doIt重载而不是重写.但正常调用doIt始终调用方法TestObject:

val x = TestObject.doIt("Hello")                //> x  : String = olleH

问: 我怎样才能调用原始的方法doIt上TestObject.这是可能的还是这种方法"有点被覆盖"？

ratingS = new JSlider(1, 5, 3); 
ratingS.setMajorTickSpacing(1);
ratingS.setPaintLabels(true);
int vote;

class SliderMoved implements ChangeListener {
    public void stateChanged(ChangeEvent e) {
        vote = ratingS.getValue();
    }
}

ratingS.addChangeListener(new SliderMoved());

如果我写上面的代码Eclipse告诉我这个:

不能在不同方法中定义的内部类中引用非最终变量vote

但如果我在int vote之前添加final,它会给我这个错误:

无法分配最终的局部变量投票,因为它是在封闭类型中定义的

那么,如何解决？

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

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

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

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