标签: final

我在带有构造函数的 Java 类中定义了几个最终属性，该类具有初始化属性的所有信息。

public final class A {
   private final Object prop1;
   private final Object prop2;

   public A(Object someObj, String prop1Str, String prop2Str) {
       //initialize prop1 and prop2 based on information provided from someObj, prop1Str and prop2Str parameter (1)
   }
}

我想在 A 类中引入一个具有以下签名和语义的新构造函数

   public A(Object obj1, Object obj2, String prop1Str, String prop2Str) {
       //use obj1 and obj2 to initialize the someObj
       //initialize prop1 and prop2 based on information provided from someObj, prop1Str and prop2Str parameter (1)
   }

如何重用 (1) …

struct B { 
  virtual void foo ()
  { cout << "B::foo()\n"; }
};

struct D : B { 
  void foo () //final
  { cout << "D::foo()\n"; }
};

int main ()
{
  B *pB = new B;
  D *pD = static_cast<D*>(pB);
  pB->foo();
  pD->foo();
}

输出预期行为:

B::foo()
B::foo()

如果我们做出D::foo()决赛,那么输出就会大不相同:

B::foo()
D::foo()

这意味着virtual当使用声明该方法的类的指针/引用调用方法时,不会启用该功能final.
这也意味着,它final不仅仅是一个编译时检查,而且还有助于运行时行为.

它是所有编译器的标准行为.我用g ++ 4.7测试过.

编辑:
产生了一个澄清的新问题.结束这个问题.

class hello {
    public static void main(String arg[]){

    int[] c = { 2 };
    final int[] d = { 3 };

    }

static void useArgs(final int a, int b, final int[] c, int[] d) {

    c[0]=d[0]; // no error 
    c = d; //error 
    }
 }

伙计们可以解释一下这种行为吗？

Effective Java中的第15项规定,建议使用私有final字段作为不可变对象中的公共final字段,因为它可能会阻止更改后续版本中的内部表示.

我无法理解突出显示的部分 - 我无法看到更改访问说明符可能导致问题的情况.有人可以为此提供一个例子吗？

练习一些代码示例,我发现了这个:我已经在类级别声明了最终变量并尝试从方法中分配值,导致编译时错误(代码-2).但是从构造函数中它确实被赋值(代码-1).

代码-1:

class Immutable {

    private final int age;
    private final String name;

    private Immutable(int age, String name) {
        this.age = age;
        this.name = name;
    }

代码-2:

class Immutable {

    private final int age;
    private final String name;

    private void me() {
        this.age = 19;
        this.name = "name";
    }

当然,它们也可以在类级别分配,但不允许再次在构造函数中执行,因为它们只允许声明一次.但是,为什么最终变量在构造函数中分配而不是从方法中分配？

我知道在java中传递对象时,对象的引用作为值传递.因此,您对该对象所做的更改也会反映在原始对象中.为避免这种情况,我们在java中使用immutability属性.

所以我的问题是,我创建了一个不可变类Employee,当我将这个Employee类的对象传递给其他类中的某个方法时,我不希望该方法对该对象进行任何更改.即使它确实如此,我也不希望更改受到调用类中创建的原始对象的影响.

这是我的示例代码.

public final class Employee {
    int employeeId;

    public int getId() {
        return employeeId;
    }

    public void setId(int id) {
        this.employeeId = id;
    }

}

public class Worker {
    public static void process(Employee f, Employee g){
        int c = f.getId();
        f.setId(g.getId());
        g.setId(c);
    }
}

public class ImmutabilityTest{

    public static void main(String[] args) {
        Employee teamMember = new Employee();
        Employee teamLead = new Employee();
        teamMember.setId(5);
        teamLead.setId(10);
        System.out.println("Before process "+teamMember.getId() + " " + …

public class Test1 {
    static final int i;
    static{
        if(3<2){
        i = 0;
        }
    }   
}

public class Test2 {
    static final int i;
    static{
        if(3>2){
        i = 0;
        }
    }   
}

类Test1编译失败,Class Test2编译成功.

任何人都可以告诉我编译器如何能够在if条件下评估表达式吗？

程序代码:

public class A{
   public static final String l;

   public void method(String strTestData){
     l = strTestData;
   }
}

strTestData将包含"public static final java.lang.String DELETE"之类的数据.可能吗？

我已经阅读并且一直被告知不可变类必须是最终的.但我想知道是否有可能将非最终类对象作为不可变对象.在这个链接中(为什么在Java中声明一个不可变的类final？)如果不可变类方法是最终的并且不能被覆盖,该怎么办？如果该类的所有成员都是final,那么该类的对象也可以是不可变的(除非它们引用了一个可变对象).如果我错了请告诉我,并勾选:)

我刚看到这个问题,显然很明显Java应该拒绝访问lambda表达式体内的非final变量.为什么？

编辑:例如,我不明白为什么以下代码有害:

String[] numbers = new String[10]; // put some numerical strings in
BigInteger sum = new BigInteger("0");
numbers.forEach(n -> sum = sum.add(new BigInteger(n)));