匿名类的多重继承

Question

匿名类如何实现两个（或更多）接口？或者，它如何既扩展一个类并实现一个接口？ 例如，我想创建一个扩展两个接口的匿名类对象：

    // Java 10 "var" is used since I don't know how to specify its type
    var lazilyInitializedFileNameSupplier = (new Supplier<String> implements AutoCloseable)() {
        private String generatedFileName;
        @Override
        public String get() { // Generate file only once
            if (generatedFileName == null) {
              generatedFileName = generateFile();
            }
            return generatedFileName;
        }
        @Override
        public void close() throws Exception { // Clean up
            if (generatedFileName != null) {
              // Delete the file if it was generated
              generatedFileName = null;
            }
        }
    };

然后我可以在 try-with-resources 块中将它用作 AutoCloseable 作为延迟初始化的实用程序类：

        try (lazilyInitializedFileNameSupplier) {
            // Some complex logic that might or might not 
            // invoke the code that creates the file
            if (checkIfNeedToProcessFile()) {
                doSomething(lazilyInitializedFileNameSupplier.get());
            }
            if (checkIfStillNeedFile()) {
                doSomethingElse(lazilyInitializedFileNameSupplier.get());
            }
        } 
        // By now we are sure that even if the file was generated, it doesn't exist anymore

我不想创建一个内部类，因为我绝对确定这个类不会在任何地方使用，除了我需要在其中使用它的方法（我也可能想要使用在该方法中声明的可能属于 var 类型的局部变量。

Answer 1

我想没有人理解这个问题。我猜这家伙想要的是这样的：

return new (class implements MyInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }
});

因为这将允许诸如多个接口实现之类的事情：

return new (class implements MyInterface, AnotherInterface {
    @Override
    public void myInterfaceMethod() { /*do something*/ }

    @Override
    public void anotherInterfaceMethod() { /*do something*/ }
});

这确实很好；但这在 Java 中是不允许的。

你可以做的是在方法块中使用local classes：

public AnotherInterface createAnotherInterface() {
    class LocalClass implements MyInterface, AnotherInterface {
        @Override
        public void myInterfaceMethod() { /*do something*/ }

        @Override
        public void anotherInterfaceMethod() { /*do something*/ }
    }
    return new LocalClass();
}

Answer 2

匿名类在创建其对象时正在扩展或实现 例如：

Interface in = new InterFace()
{

..............

}

这里匿名类正在实现接口。

Class cl = new Class(){

.................

}

这里的匿名类是在扩展一个抽象类。

Answer 3

匿名类必须扩展或实现某些东西，就像任何其他 Java 类一样，即使它只是 java.lang.Object。

例如：

Runnable r = new Runnable() {
   public void run() { ... }
};

这里，r 是实现Runnable 的匿名类的对象。

匿名类可以使用相同的语法扩展另一个类：

SomeClass x = new SomeClass() {
   ...
};

你不能做的是实现多个接口。你需要一个命名类来做到这一点。然而，匿名内部类和命名类都不能扩展多个类。

Answer 4

// The interface
interface Blah {
    void something();
}

...

// Something that expects an object implementing that interface
void chewOnIt(Blah b) {
    b.something();
}

...

// Let's provide an object of an anonymous class
chewOnIt(
    new Blah() {
        @Override
        void something() { System.out.println("Anonymous something!"); }
    }
);

Answer 5

匿名类总是扩展超类或实现接口。例如：

button.addActionListener(new ActionListener(){ // ActionListener is an interface
    public void actionPerformed(ActionEvent e){
    }
});

另外，虽然匿名类不能实现多个接口，但是你可以创建一个接口扩展其他接口，让你的匿名类来实现。

Answer 6

匿名类通常实现一个接口：

new Runnable() { // implements Runnable!
   public void run() {}
}

JFrame.addWindowListener( new WindowAdapter() { // extends  class
} );

如果您的意思是您是否可以实现 2 或更多接口，我认为这是不可能的。然后，您可以创建一个将两者结合起来的私有接口。虽然我无法轻易想象为什么你会希望匿名类拥有它：

 public class MyClass {
   private interface MyInterface extends Runnable, WindowListener { 
   }

   Runnable r = new MyInterface() {
    // your anonymous class which implements 2 interaces
   }

 }