Java多重继承重复变量声明？

Question

我正在测试 Java 中 default 关键字的功能和滥用情况。我决定测试多重继承，看看如果我在一个接口(interface)和实现该接口(interface)的类中声明两个具有相同名称和签名的变量会发生什么。

代码: http://ideone.com/mKJjst

import java.util.*;
import java.lang.*;
import java.io.*;

interface Foo {
    default void Meh() {
        System.out.println("Foo.Meh");
    }
}

interface Bar {
    String test="t";

    default String getTest(){
        return test;
    }

    default void doTest(){
        System.out.println("Bar.doTest: -- getTest" + getTest());
    }

    default void Bar() {
        System.out.println("Bar.Bar()");
        String blahh=test;

    }
    static void Sup(){
        System.out.println("Bar.Sup -- Test: "+test);
    }
    default void Meh() {
        System.out.println("Bar.Meh -- Test: "+test);
    }

    default void mega() {
        Meh();
    }
}

abstract class Test {
    public void Meh() {
        System.out.println("Test.Meh");
    }
}

class Ideone extends Test implements Foo, Bar {
    public static void main (String[] args) throws java.lang.Exception
    {
        new Ideone().Meh();
        blah();
    }

    public void Meh() {
        Bar.super.Bar();
        Bar.super.Meh();
        System.out.println("Ideone.Meh -- Test: "+test);

        Foo.super.Meh();
        super.Meh();


        Bar hack = new Bar(){

             public static final String test="over";

             public String getTest(){
                System.out.println("Ideone.Meh.hack.super.test: " + Bar.super.getTest());
                return test;
             }

             public void Meh(){
                System.out.println("Ideone.Meh.hack.Meh()");

                func();
                Bar.Sup();
                Bar.super.Meh();
             }

             public void func(){
                System.out.println("Ideone.Meh.hack.func -- Test: "+test);
             }
        };

        hack.Meh();
        System.out.println("Ideone.Meh.hack.test: " + hack.test);
        hack.mega();
        hack.doTest();
    }

    public static void blah() {

    }
}

结果:

Bar.Bar()
Bar.Meh -- Test: t
Ideone.Meh -- Test: t
Foo.Meh
Test.Meh
Ideone.Meh.hack.Meh()
Ideone.Meh.hack.func -- Test: over
Bar.Sup -- Test: t
Bar.Meh -- Test: t
Ideone.Meh.hack.test: t
Ideone.Meh.hack.Meh()
Ideone.Meh.hack.func -- Test: over
Bar.Sup -- Test: t
Bar.Meh -- Test: t
Ideone.Meh.hack.super.test: t
Bar.doTest: -- getTestover

Bar hack怎么可能可以有一个名为 test 的变量值为 over同时有一个名为 test 的变量值为 t ？

此外，是 Bar hack = new Bar();继承自己？如果 hack 是 Bar 的一个实例, 它怎么会有 super那是类型 Bar并包含不同的 test ？

这里到底发生了什么？

Answer 1

How is it possible that Bar hack can have a variable called test with a value of over and at the same time have a variable called test with a value of t?

接口(interface)只能声明常量(static final 是隐式的)。因此对象 Bar hack 没有任何 [instance] 变量，它只有范围访问两个 static final 变量，这两个变量恰好具有相同的名称，分别由接口(interface)和类声明。

Also, is Bar hack = new Bar(); inheriting from itself? If hack is an instance of Bar, how can it have a super that is of type Bar and contains a different test?

实际上，Bar hack = new Bar() { ... };。所以 hack 是 Bar 的匿名内部子类的实例。是的，这个一次性子类确实继承自 Bar 类。

What's actually going on here?

你正在学习 Java :)