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

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

int myVariable = 1;

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

侦听器有什么方法可以访问myVariable或被传递myVariable而不将侦听器创建为实际的命名类？

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

但是，类可以引用包含范围的变量。对于匿名类，这些可以是包含类的实例变量，也可以是标记为final的局部变量。

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

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

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)  );

无需“最终”声明。

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

像这样：

final int myVariable = 1;

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

这会神奇

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));

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

似乎在“ 为什么要使用Java实例初始化程序”中也进行了讨论。而如何初始化从构造不同的实例？讨论与构造函数的区别。

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

例如：（从一些GWT代码处理文本框更改）：

/* 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)
        }
     };
}

对于此示例，新的匿名类方法将被引用为：

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

或，根据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);

其他人已经回答说匿名类只能访问最终变量。但是他们悬而未决的问题是如何保持原始变量为非最终变量。亚当·姆洛津斯基（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）的答案没有做任何其他事情，但是代码更多。

您可以使用普通的lambda（“ 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) );

使用功能是重构装饰器和适配器的好方法，请参见此处

我刚刚开始学习lambda，因此，如果您发现错误，请随时发表评论。

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

同样，如果要获取外部变量的值，则可以创建一个返回所需内容的方法！

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

    });

 }

我以为匿名类基本上像lambdas一样，但是语法更差……事实证明这是事实，但是语法更糟，并且会导致（应该是）局部变量渗出到包含类中。

通过将最终变量置于父类的字段中，可以访问任何最终变量。

例如

接口：

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中添加代码以重复使用某些东西所带来的代码量和复杂性要比仅仅复制和粘贴很多时间更糟糕。