标签: anonymous-class

不幸的是,我没有编写Java大约五年,我完全不记得下面的代码如何或为什么工作.

我偶然发现了一个类似的例子并将其分解为此.重点是注释下面的部分:我没有得到构造函数符号,后面是双括号中的块.不幸的是,我无法在Java文档中找到任何内容或使用Google(我应该使用哪些词？).

package syntaxtest;

public class Main {

    public static void main(String[] args) {

        // What kind of notation is this?
        MyTest tester = new MyTest() {{
            setName("John Johnson");
        }};

        System.out.println(tester.getName());
    }
}


class MyTest {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

所以这是我的问题:

1. 如何调用这种符号/语法？
2. 我在哪里可以阅读一些有关它的文档？

我想/希望如果有人能够为我提供第一个问题的答案,我将能够自己回答第二个问题.

说清楚:我知道输出是John Johnson;)但我不知道它为什么有效.

此代码基本上按降序对数组进行排序:

val arrayList = arrayListOf(1, 5, 2)

Collections.sort(arrayList, object : Comparator<Int> {
   override fun compare(x : Int, y: Int) = y - x
})

世界上如何将比较方法与y - x作品重叠？科特林怎么知道是什么y - x意思把y之前x如果y < x？

我在方法中有以下代码:

 var list = new[]
  {
   new { Name = "Red", IsSelected = true },
   new { Name = "Green", IsSelected = false },
   new { Name = "Blue", IsSelected = false },
  };

我想调用一个函数,它需要一个元素列表,每个元素实现一个接口(ISelectable).我知道如何使用普通类完成此操作,但在这种情况下,我只是尝试填写一些演示数据.

是否可以创建实现接口的匿名类？

像这样:

new { Name = "Red", IsSelected = true } : ISelectable

抱歉有趣的标题.

在此之前的C++ 0x,有限制的使用功能局部结构("本地型")作为模板参数.我的问题基本上是否类似的限制适用于匿名结构.具体来说,在特质类的上下文中:

template <typename T>
struct trait;

template <>
struct trait<int> {
    typedef int type;
};

template <typename T>
struct trait<std::basic_string<T> > {
    typedef struct {
        T value;
    } type;
};

trait<std::string>::type foo; // Is this valid?

template <typename T>
void f() { }

f<trait<std::string>::type> >(); // Is this?

template <typename T>
void g() { f<typename trait<T>::type>(); }

g<std::string>(); // And this?

这有效可靠吗？它汇编了最新版本的GCC和LLVM,但我仍然不安全,这是否严格有效,以及VC++和ICC是否理解它.

在C++中有一个叫做匿名类的功能.它与C中的匿名结构类似.我认为这个功能是由于某些需求而发明的,但我无法弄清楚它是什么.

我可以有一些真正需要匿名课程的例子吗？

当从实例方法返回没有引用其封闭类的匿名类时,它会引用this.为什么？

请考虑以下代码:

package so;

import java.lang.reflect.Field;

public class SOExample {

    private static Object getAnonymousClassFromStaticContext() {
        return new Object() {
        };
    }

    private Object getAnonymousClassFromInstanceContext() {
        return new Object() {
        };
    }

    public static void main(String[] args) throws NoSuchFieldException, SecurityException {

        Object anonymousClassFromStaticContext = getAnonymousClassFromStaticContext();
        Object anonymousClassFromInstanceContext = new SOExample().getAnonymousClassFromInstanceContext();

        Field[] fieldsFromAnonymousClassFromStaticContext = anonymousClassFromStaticContext.getClass().getDeclaredFields();
        Field[] fieldsFromAnonymousClassFromInstanceContext = anonymousClassFromInstanceContext.getClass().getDeclaredFields();

        System.out.println("Number of fields static context: " + fieldsFromAnonymousClassFromStaticContext.length);
        System.out.println("Number of fields instance context: " + fieldsFromAnonymousClassFromInstanceContext.length);
        System.out.println("Field from instance context: " …

我有一个如下定义的示例类:

public class FooBar {

  void method1(Foo foo){ // Should be overwritten
    ...
  }

}

后来,当我尝试这个:

FooBar fooBar = new FooBar(){
  public String name = null;
  @Override
  void method1(Foo foo){
    ...
  }
};

fooBar.name = "Test";

我收到一个错误,说明名称字段不存在.为什么？

我对Java中的匿名类有什么误解.考虑以下简单示例:

public static void main (String[] args) throws java.lang.Exception
{
    B b = new B(){ };
    System.out.println(b.b);
}

interface B{ int b = 1; }

DEMO

为什么代码编译？在JLS,CHAPT 15说:

匿名类始终是内部类(第8.1.3节); 它永远不会是静止的

但JLS,8章

内部类是未显式或隐式声明为静态的嵌套类.

所以匿名类是一个内部类.但我们在静态环境中使用它们.为什么在这里是正确的？

我们知道只能在匿名类中访问最终的局部变量,这里有一个很好的理由:为什么在匿名类中只能访问最终变量？.

但是,我发现如果变量是封闭类的成员字段,匿名类仍然可以访问非final变量:如何从匿名类内部访问封闭的类实例变量？

我很迷惑.我们确保只能在匿名类中访问最终的局部变量,因为我们不希望变量在匿名类和本地函数之间不同步.如果我们尝试访问匿名类中的非最终封闭类成员,则同样的理由应该适用于该情况.

为什么不关注呢？

我有以下静态工厂方法,从int数组创建列表视图:

public static List<Integer> newInstance(final int[] numbers) {
    return new AbstractList<Integer>() {

        @Override
        public Integer get(int index) {
            return numbers[index];
        }

        @Override
        public int size() {
            return numbers.length;
        }
    };
}


public static void main(String[] args) {
    int[] sequence = {10, 20, 30};
    List<Integer> list = ListFactory.newInstance(sequence);
    System.out.println("List is "+list);

}

在"Effective Java"中,Joshua Bloch提到了这一点

作为适配器,允许将int数组视为Integer实例列表.

但是,我记得Adapter使用组合,匿名列表实现的实例应该使用int []作为成员字段.

如果int []输入参数不是匿名列表实现的成员字段,那么它究竟存储在哪里？

如果有人能提供一些见解或一些链接来寻找更多信息,我将不胜感激.