标签: anonymous-class

我正在尝试使用事件调度程序来允许模型在更改时通知已订阅的侦听器.事件调度程序接收在调度期间调用的处理程序类和方法名称.演示者订阅模型更改并提供要在更改时调用的Handler实现.

这是代码(对不起,它有点长).

EventDispacther:

package utils;

public class EventDispatcher<T> {
    List<T> listeners;
    private String methodName;

    public EventDispatcher(String methodName) {
        listeners = new ArrayList<T>();
        this.methodName = methodName;
    }

    public void add(T listener) {
        listeners.add(listener);
    }

    public void dispatch() {
        for (T listener : listeners) {
            try {
                Method method = listener.getClass().getMethod(methodName);
                method.invoke(listener);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

模型:

package model;

public class Model {
    private EventDispatcher<ModelChangedHandler> dispatcher;

    public Model() {
        dispatcher = new EventDispatcher<ModelChangedHandler>("modelChanged");
    }

    public void …

如何从外部类访问我？

  HashSet<Integer> hs=new HashSet<Integer>(){
        int i=30;
    };

我可以这样做

int k=new HashSet<Integer>(){
    int i=30;
}.i;

但是,如果我得到"我",那么我就无法得到hashset的实例.有没有办法获得两者？问题只是出于好奇.它没有太多实际应用.我只是想知道它是否可以完成.

我很好奇,我看到了很多这样的事情:

Arrays.sort(array, new Comparator<Integer>() {
    public int compare(Integer a, Integer b) {
        return Math.abs(a) < Math.abs(b);
    }
});

因为这里创建的匿名类没有实例变量,标准的JDK编译器是否足够聪明,只能实例化一次匿名类并重用它？或者是否建议在静态字段中实例化匿名类并始终传递静态Comparator对象？

更新:当我说"JDK编译器"时,我的意思是JIT部分.以上也只是一个例子.我真的很好奇,作为一种最佳实践,我应该为上面创建静态字段而不是内联匿名类实例化.在某些情况下,性能/资源使用问题可以忽略不计.但其他情况可能不是......

在Java中,我可以说

Thread t = new Thread(){
    public void run(){ // do stuff }
}

(或类似的东西)声明一个内联的匿名类.这对于制作事件处理程序或其他回调类型的东西非常有用,在任何合理的语言中,首先不需要对象拥有它们.

我在Jython中面临同样的问题 - 我想定义一个事件处理程序,但我不想构建一个完整的独立类来执行此操作.

理想情况下,我只能传递一个lambda并完成它,但如果这是可能的,我无法在文档中的任何地方找到它.

在其中一个SO线程中,我曾看到使用未命名的structfor for for for循环中不同类型的多个变量的占位符:

例如:

for(struct {
      int i;
      double d;
      char c;
    } obj = { 1, 2.2, 'c' };
    obj.i < 10;
    ++obj.i)
{
  ...
}

这与g ++ 编译很好.
这是标准的C++ 03语法吗？

简单地说,让我通过一个例子来解释.

<?php
class My extends Thread {
    public function run() {
        /** ... **/
    }
}
$my = new My();
var_dump($my->start());
?>

这是来自PHP手册.

我想知道是否有办法以更像Java的方式做到这一点.例如:

<?php
$my = new Thread(){
        public function run() {
            /** ... **/
        }
      };
var_dump($my->start());
?>

我经常有一些简单的类，我只想要一个实例。作为一个简单的例子：

import datetime
import sys

class PS1(object):
    def __repr__(self):
        now = datetime.datetime.now()
        return str(now.strftime("%H:%M:%S"))

sys.ps1 = PS1()

有没有一种方法可以将定义和实例化为一个步骤，并获得相同的结果？

再举一个例子，就像一个简单易懂的东西一样。

class Example(object):
    def methodOne(self, a, b):
        return a + b

    def methodTwo(self, a, b):
        return a * b

example = Example()

我四处搜寻，却一无所获（很多人乱扔这些单词one-off，anonymous但似乎没人在谈论我是同一件事）。我试过了，但是没有用：

example = class(object):
    def methodOne(self, a, b):
        return a + b

    def methodTwo(self, a, b):
        return a * b

我意识到我没有太多收获，只是我不必输入一行内容，而在我的命名空间中少了几行，所以我知道这是否不存在。

我有抽象类,有两个方法如下:

public abstract class SessionExecutionBody {
   public Object execute() {
     executeWithoutResult();
     return null;
   }

   public void executeWithoutResult() {}
} 

我按如下方式实现了这个类:

final HTTPDestination destination = sessionService.executeInLocalView(new SessionExecutionBody() {
            @Override
            public Object execute() {
                userService.setCurrentUser(userService.getAdminUser());
                final String destinationName = getConfigurationService().getConfiguration().getString(DESTINATION_PROPERTY);
                return getHttpDestinationService().getHTTPDestination(destinationName);

当我运行sonarLint时,它显示的主要问题是将这个匿名类转换为lambda表达式,但是我无法找到相同的方法,我可以将该表达式转换为lambda吗？

考虑以下代码:

interface A {
    default void doA() {
        System.out.println("a");
    } 
}

interface B {
    void doB(); 
}

class Test implements A {

    @Override
    public void doA() {        
        // Works
        B b = () -> A.super.doA();
        b.doB();

        // Does not compile
        /*
        new B() {      
            public void doB() {  
                A.super.doA();
            }       
        }.doB();
        */
    }

    public static void main(String[] args) {
        new Test().doA();
    }

}

这是做作,但基本上Test::doA()试图来包装this的B,并且具有B::doB()调用它的超强功能A.super.doA().

我可以打电话给A.super.doA()一个类型的lambda B就好了.但我无法弄清楚A.super.doA() …

我通过在公共static void main（）方法内实现接口I创建了匿名类。因此，通过Java 8的抽象方法test（），实现是从类C的imple（）方法提供的。

因此，在public static void main（）方法内部，打印_interface.getClass（），我得到了

package_path.Main $ $ Lambda $ 1/310656974这是绝对好的。因为它打印的是匿名类名。

另外，_interface指向堆中的匿名对象，因此我正在做_interface.test（）;。

因此，test（）方法现在具有的第一条语句是打印类名称，

但是最终它显示的是package_path.C（告诉我C是类名）。那怎么可能？不应再次打印package_path.Main $$ Lambda $ 1/310656974吗？因为“这”意味着在测试方法内部是匿名的，对吗？

@java.lang.FunctionalInterface
interface I {
    void test();
}

class C {
    void imple() {
        System.out.println(this.getClass());
        System.out.println("Inside Implementation");
    }
}

class Main {
    public static void main(String[] args) {
        I _interface = new C()::imple;
        System.out.println(_interface.getClass());
        _interface.test();
    }
}