如何将参数传递给匿名类？

Question

是否可以传递参数或访问外部参数到匿名类？例如：

int myVariable = 1; 

myButton.addActionListener(new ActionListener() { 
    public void actionPerformed(ActionEvent e) { 
     // How would one access myVariable here? 
    } 
}); 

有什么办法使听者无需创建听者作为实际命名的类访问MYVARIABLE或传递MYVARIABLE？

Answer 1

从技术上讲，没有，因为匿名类不能有构造函数。

但是，类可以引用来自包含范围的变量。对于匿名类，这些可以是来自包含类（es）的实例变量或标记为最终的局部变量。

编辑：正如Peter指出的那样，您还可以将参数传递给匿名类的超类的构造函数。

Answer 2

是的。你可以捕捉内部类可见的变量。唯一的限制是，它必须是最终

Answer 3

像这样：

final int myVariable = 1; 

myButton.addActionListener(new ActionListener() { 
    public void actionPerformed(ActionEvent e) { 
     // Now you can access it alright. 
    } 
}); 

Answer 4

是的，通过添加一个初始化方法，返回“这个”，并立即调用该方法：

int myVariable = 1; 

myButton.addActionListener(new ActionListener() { 
    private int anonVar; 
    public void actionPerformed(ActionEvent e) { 
     // How would one access myVariable here? 
     // It's now here: 
     System.out.println("Initialized with value: " + anonVar); 
    } 
    private ActionListener init(int var){ 
     anonVar = var; 
     return this; 
    } 
}.init(myVariable) ); 

没有“最终”需要申报。

Answer 5

如http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class所示，您可以添加实例初始值设定项。这是一个没有名字并且先被执行的块（就像构造函数一样）。

看起来他们也在Why java Instance initializers?和How is an instance initializer different from a constructor?讨论与构造函数的差异。

Answer 6

我的解决方案是使用返回实现的匿名类的方法。常规参数可以传递给方法，并且可以在匿名类中使用。

例如：（一些GWT代码来处理一个文本框的变化）：

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger)) 

：

/* Regular method. Returns the required interface/abstract/class 
    Arguments are defined as final */ 
private ChangeHandler newNameChangeHandler(final String axisId, final Logger logger) { 

    // Return a new anonymous class 
    return new ChangeHandler() { 
     public void onChange(ChangeEvent event) { 
      // Access method scope variables   
      logger.fine(axisId) 
     } 
    }; 
} 

在这个例子中，新的匿名类的方法将与参考OR，使用OP的要求：

private ActionListener newActionListener(final int aVariable) { 
    return new ActionListener() { 
     public void actionPerformed(ActionEvent e) { 
      System.out.println("Your variable is: " + aVariable); 
     } 
    }; 
} 
... 
int myVariable = 1; 
newActionListener(myVariable); 

Answer 7

其他人已经回答说，匿名类只能访问最终变量。但他们留下了如何保持原始变量不是最终的问题。 Adam Mlodzinski给出了一个解决方案，但是非常臃肿。这个问题有一个更简单的解决方案：

如果你不想myVariable是最终的，你必须把它包装在一个新的范围内，它是无关紧要的，如果它是最终的。

int myVariable = 1; 

{ 
    final int anonVar = myVariable; 

    myButton.addActionListener(new ActionListener() { 
     public void actionPerformed(ActionEvent e) { 
      // How would one access myVariable here? 
      // Use anonVar instead of myVariable 
     } 
    }); 
} 

Adam Mlodzinski在他的回答中没有做任何其他事情，但代码更多。

Answer 8

将一些值放入外部变量（不属于匿名类） 的一种简单方法是如何从属！

以同样的方式，如果你想得到一个外部变量的值，你可以创建一个方法，返回你想要的！

public class Example{ 

    private TypeParameter parameter; 

    private void setMethod(TypeParameter parameter){ 

     this.parameter = parameter; 

    } 

    //... 
    //into the anonymus class 
    new AnonymusClass(){ 

     final TypeParameter parameterFinal = something; 
     //you can call setMethod(TypeParameter parameter) here and pass the 
     //parameterFinal 
     setMethod(parameterFinal); 

     //now the variable out the class anonymus has the value of 
     //of parameterFinal 

    }); 

} 

Answer 9

我以为匿名类基本上是一样的lambda但语法糟糕的......这原来是真实的，但语法还差和原因（应该是什么）局部变量渗出到包含类。

您可以通过将它们放入父类的字段来访问最终的变量。

如

接口：

public interface TextProcessor 
{ 
    public String Process(String text); 
} 

类：

private String _key; 

public String toJson() 
{ 
    TextProcessor textProcessor = new TextProcessor() { 
     @Override 
     public String Process(String text) 
     { 
      return _key + ":" + text; 
     } 
    }; 

    JSONTypeProcessor typeProcessor = new JSONTypeProcessor(textProcessor); 

    foreach(String key : keys) 
    { 
     _key = key; 

     typeProcessor.doStuffThatUsesLambda(); 
    } 

我不知道他们是否已经在Java 8整理了这一点（我被困在EE世界，而不是得到8）但在C＃它看起来像这样：

public string ToJson() 
    { 
     string key = null; 
     var typeProcessor = new JSONTypeProcessor(text => key + ":" + text); 

     foreach (var theKey in keys) 
     { 
      key = theKey; 

      typeProcessor.doStuffThatUsesLambda(); 
     } 
    } 

你不需要在c＃中的独立接口...我想念它！我发现自己在java中进行更糟糕的设计并重复自己，因为在Java中添加重复使用某些代码+复杂性比复制和粘贴大量时间要糟糕。

Answer 10

这将做魔术

int myVariable = 1; 

myButton.addActionListener(new ActionListener() { 

    int myVariable; 

    public void actionPerformed(ActionEvent e) { 
     // myVariable ... 
    } 

    public ActionListener setParams(int myVariable) { 

     this.myVariable = myVariable; 

     return this; 
    } 
}.setParams(myVariable)); 

Answer 11

可以使用plain lambdas（ “lambda表达式可以捕捉变量”）

int myVariable = 1; 
ActionListener al = ae->System.out.println(myVariable); 
myButton.addActionListener(al); 

甚至功能

Function<Integer,ActionListener> printInt = 
    intvar -> ae -> System.out.println(intvar); 

int myVariable = 1; 
myButton.addActionListener(printInt.apply(myVariable)); 

使用功能是重构装饰器和适配器的好方法，see here

我刚开始学习lambda，所以如果你发现一个错误，随时写评论。