Question

首先，做几乎我想做的事情的理想化工作示例：

public final class One {
    private int i;

    public class InOne {
        public int foo() { return i; }
    }
}

public class Two {
    private final One aOne = new One();

    Object getInTwo() {
        return aOne.new InOne() {
            public int someMethod() { return foo() + 100; }
        };
    }
}

很好，我可以通过使用封闭实例限定new来扩展非基类中的非静态类。但是，当然，因为它是没有意义的，因为someMethod在返回的对象中变得不可访问。实际上，getInTwo的返回类型不应该是Object而是SomeInterface，定义如下：

public interface SomeInterface {
    int someMethod();
}

据我所知，没有办法创建一个匿名类，它既扩展了类又实现了一个未由该类实现的接口。所以我必须做一个非匿名的课程，如下所示：

public class Two {
    private final One aOne = new One();

    Object getInTwo() {
        class InTwo extends One.InOne implements SomeInterface {
            public int someMethod() { return foo() + 100; }
        }
        return new InTwo();
    }
}

现在编译器告诉我需要一个包含One.InOne的封闭实例，这是有道理的，但我拥有我希望成为封闭实例的对象，并在匿名类案例我可以通过aOne.new指定。但既然我不能使用匿名类，我就无法指定封闭的实例，或者我可以吗？

显然，通过在类层次结构中移动东西（例如，在InTwo中封装InOne而不是扩展）可以解决这个问题，这在这个理想化的玩具示例中看起来很好，但在上下文中我实际上想要这样做他们变得更加混乱，所以我问的其实就是我想做的事情。据我所知，没有任何结构可以阻止它，它只是一个语法问题。

Answer 1

这应该对你有用

public class Two {
   private final One aOne = new One();

   Object getInTwo() {
      class InTwo extends One.InOne implements SomeInterface {

            public InTwo(){
                aOne.super();
            }
            public int someMethod() { return foo() + 100; }
       }
       return new InTwo();
    }
}

您的问题是One.InOne的内部类只能存在于One的实例的上下文中。因此，在构造函数中，您必须能够提供除扩展One.InOne之外的任何类的封闭实例。

Answer 2

非常漂亮，我根本不会推荐它......无论如何 - 你走了：

public class Two {
    private final One aOne = new One();

    Object getInTwo() {
        class InTwo extends One.InOne implements SomeInterface {
            public InTwo() {
                Two.this.aOne.super();
            }
            public int someMethod() { return foo() + 100; }
        }
        return new InTwo();
    }
}

扩展嵌套在实现接口的非基类中的非静态类

2 个答案: