从内部匿名类访问外部匿名类的方法

methods java anonymous-class java-8 method-reference

2022-09-01 20:37:12

我使用实例化另一个匿名类的方法实例化一个匿名类，并且从这个内部匿名类中，我想调用一个属于外部匿名类的方法。为了说明这一点，假设我有这个接口：

interface ReturnsANumber {
    int getIt();
}

然后，在我的代码的某个地方，我这样做：

    ReturnsANumber v = new ReturnsANumber() {
            int theNumber() {
                return 119;
            }

            public int getIt() {

                // In a modern version of Java, maybe I could do
                //   var a = this;
                // and then call a.theNumber();

                ReturnsANumber w = new ReturnsANumber() {
                        int theNumber() {
                            return 1;
                        }

                        public int getIt() {
                            return this.theNumber();
                        }
                    };

                return w.getIt();
            }
        };
    System.out.println("The number is " + v.getIt());

问题：在最内层的方法中，我想调用属于最外层的匿名类。如何在不使用Java 10 var功能的情况下实现这一点（如代码中所述）。getIttheNumber()

澄清：理想情况下，外部匿名类不需要知道内部类想要调用其方法。这个想法是想出一些代码，让内部类明确地调用外部类上的任何方法。theNumber

换句话说，如何使此代码显示：（而不是显示The number is 119The number is 1)

动机：有人可能会问我为什么要这样做：我正在编写某种代码生成器，并希望确保我正在生成的代码不是模棱两可的。

答案 1

从Java 8开始，解决方案非常简单。只需将方法引用存储在变量中即可。

ReturnsANumber v = new ReturnsANumber() {
        int theNumber() {
            return 119;
        }

        public int getIt() {

            Supplier<Integer> supplier = this::theNumber;

            ReturnsANumber w = new ReturnsANumber() {
                int theNumber() {
                    return 1;
                }

                public int getIt() {
                    return supplier.get();
                }
            };

            return w.getIt();
        }
    };

存储外部对象也可以做到这一点。但仅适用于继承的方法：

interface ReturnsANumber {
    int theNumber();
    int getIt();
}

public int getIt() {
    ReturnsANumber outer = this;

    ReturnsANumber w = new ReturnsANumber() {
        public int theNumber() {
            return 1;
        }

        public int getIt() {
            return  outer.theNumber();
        }
     };

     return w.getIt();
 }

也可以将方法引用或外部对象存储为字段。

更新

@Holger提出了另一种解决方法。您可以将外部对象传递给 lambda：

ReturnsANumber v = new ReturnsANumber() {
    ...
    @Override
    public int getIt() {
        ReturnsANumber w = Optional.of(this).map(outer ->
                new ReturnsANumber() {
                    int theNumber() {
                        return 1;
                    }
                    public int getIt() {
                        return outer.theNumber();
                    }
                }).get();
        return w.getIt();
    }
};

答案 2

没有用于访问封闭匿名类的关键字。

但是一种解决方案可能是在外部匿名类中代理该方法并进行非限定引用：

ReturnsANumber v = new ReturnsANumber() {


    int theNumber() {
        return 119;
    }

    //Just a different name for theNumber()
    int theNumberProxy() {
        return theNumber();
    }

    public int getIt() {

        ReturnsANumber w = new ReturnsANumber() {
                int theNumber() {
                    return 1;
                }

                public int getIt() {
                    return theNumberProxy(); //calls enclosing class's method
                }
            };

        return w.getIt();
    }
};

对这种操作的需求应该足以证明您的类结构并不理想，并且可能是一个维护陷阱。例如，您可以简单地将第一个匿名类替换为嵌套的静态类。