标签: final

是否可以让给定的子类在其超类中初始化静态最终字段？基本上我希望子类配置所需的类范围变量.不幸的是,abstract关键字并不完全适用于字段..

我知道这不起作用,但它只是一个例子,所以我可以理解为什么它不起作用.

public class MyClass {

    final static JButton b;

 public void myMethod() {
   b = new JButton("Hello!");
 }
 }

1)为什么final static JButton b;线路出错？当我删除static关键字时,为什么这个错误会消失？

2)有或没有static关键字,行有一个错误b = new JButton("Hello!"); 我想知道为什么这是？我认为在方法中实例化最终变量是可以的.

在下面的代码中,第一个if语句抱怨current_guy不能是a,final但第二个if语句抱怨current_guy不是最终的.我没有想法.

final int current_guy=0;

if (a.equals("bf")){
   current_guy=1;
}

guy1.setOnClickListener(new OnClickListener() {    
   public void onClick(View v) {

   if (current_guy==1) {
      // TODO Auto-generated method stub
   }
}

我想使用java.util.Set(和其他集合),但有一个扭曲:我想contains(),add()等等,总是调用对象equals()(这是基于身份而不是更平等的操作).我想我有办法,但它有很大的缺点.有没有正确的方法来做到这一点？对不起,如果我错过了一些明显的东西.

这就是我所做的:

public class OnlySelfEqual {
    public final boolean equals(Object o){
        return super.equals(o);
    }
}

public class Example{
    private Set<T extends OnlySelfEqual> set;
    //etc
}

我看到的主要问题(可能还有很多其他问题)是所有Ts必须从类扩展而不是实现接口,这是非常严格的.我想我想要的就像一个'反向'接口,它列出了子类型无法实现的方法(覆盖).我很确定不存在.有什么建议？

如果在类中声明了最终变量,并且创建了类的多个实例,那么最终变量将在哪里分配内存？是否会出现在所有情况下,还是会独立分配？

我之前问过这个问题,但我得不到合适的答案.

如果非最终字段的值可以更改,那么如何在匿名类类中使用它们？

class Foo{
    private int i;
    void bar(){
        i = 10
        Runnable runnable = new Runnable (){
            public void run (){
                System.out.println(i); //works fine
            }//end method run
        }//end Runnable
    }//end method bar
}//end class Foo 

如果在匿名类中使用的局部变量必须final使编译器能够在匿名类代码中内联它们的值,如下所示:

之前:

public class Access1 {
  public void f() {
    final int i = 3;
    Runnable runnable = new Runnable() {
        public void run() {
            System.out.println(i);
        }//end method run
    };//end anonymous class
  }//end method f
}//end class Access1

后:

public class Access1 …

class a
{
    static final  int a =5;
    static {
        System.out.println("hi");

    }
}
class b
{
    public static void main(String[] args) {
        System.out.println(a.a);
    }   

}

为什么静态块不运行,输出只是

五

而如果我从类变量中删除final关键字,则执行静态块并输出

hi 
5

可能重复:

该线程不询问如何扩展final类.它问 为什么声明的类final可能会扩展另一个类.

从这个线程:

一final类是仅仅是一个类不能扩展.

但是,我有一个我声明的辅助类final和extends另一个类:

public final class PDFGenerator extends PdfPageEventHelper {
    private static Font font;

    private PDFGenerator() {
        // prevent instantiation
    }

    static {
        try {
            BaseFont baseFont = BaseFont.createFont(
                "/Trebuchet MS.ttf",
                BaseFont.WINANSI,
                BaseFont.EMBEDDED
            );

            font = new Font(baseFont, 9);

        } catch(DocumentException de) { 
            de.printStackTrace();

        } catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }

    public static ByteArrayOutputStream generatePDF() throws DocumentException {            
        Document doc …

finalScala构造函数参数意味着什么？我有这个例子:

class IntFinalTest(
    val intVal: Int,
    final val finalIntVal: Int,
    var intVar: Int,
    final var finalIntVar: Int) {
  //  intVal = 3 // error: reassignment to val
  //  finalIntVal = 3 // error: reassignment to val
  intVar = 3
  finalIntVar = 3
}

class ArrayFinalTest(
    val arrayVal: Array[Int],
    final val finalArrayVal: Array[Int],
    var arrayVar: Array[Int],
    final var finalArrayVar: Array[Int]) {
  arrayVal(0) = 3
  finalArrayVal(0) = 3
  arrayVar(0) = 3
  finalArrayVar(0) = 3
}

根据编译器输出判断(只有两条标记的行导致错误),final非final vals和 …

我有这样的代码:

public class App {
    private final String some;
    public App(){
        some = "old";
    }
    public static void main(String... args) throws NoSuchFieldException, IllegalAccessException {
        App a = new App();
        a.magic();
        System.out.println(a.some);

    }
    private void magic() throws NoSuchFieldException, IllegalAccessException {
        Field field = this.getClass().getDeclaredField("some");
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        field.set(this, "new");
        String someDuplicate = (String) field.get(this);
        System.out.println(someDuplicate);
    }
}

这个输出将是

new 
new

但如果我将变量初始化更改为:

private final String some = "old";

输出将是

new
old

看起来像内联初始化会导致最终非静态字段的静态行为

我找不到这种行为的任何码头参考,可能有一些合理的解释.

顺便说一句,init方式的这种方式会导致类似于构造函数初始化的行为:

{ …