我想知道是否可以更改 Android Studio 中的自动格式，将匿名类的大括号放置在同一行，同时仍将常规类、方法和块的大括号放置在新行上。

目前，IntelliJ 给了我这个结果：

class TestClass
{
    public void test()
    {
        FooBar foo = new FooBar(new Runnable() // I want the brace here...
        { // ...not here.
            @Override
            public void run()
            {
                //
            }
        });
    }
}

但是，我希望代码的格式如下：

class TestClass
{
    public void test()
    {
        FooBar foo = new FooBar(new Runnable() { // <- Same Line
            @Override
            public void run()
            {
                //
            }
        });
    }
}

一切都很好，除了一个细节，即我无法像第二个示例中那样格式化大括号。这是不可能的还是我只是忽略了设置？

我最近做了一个编程任务,要求我们在代码中实现一个由UML图指定的程序.有一次,该图指定我必须创建一个显示计数(从1开始)的匿名JButton,并在每次单击时递减.JButton及其ActionListener都必须是匿名的.

我提出了以下解决方案:

public static void main(String[] args) {
  JFrame f = new JFrame("frame");
  f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  f.setSize(400, 400);

  f.getContentPane().add(new JButton() {

    public int counter;

    {
      this.counter = 1;
      this.setBackground(Color.ORANGE);
      this.setText(this.counter + "");

      this.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
          counter --;
          setText(counter + "");
        }
      });

    }
  });

  f.setVisible(true);

}

这会添加一个匿名的JButton,然后添加另一个(内部)匿名ActionListener来处理事件并根据需要更新按钮的文本.有更好的解决方案吗？我很确定我不能宣布匿名JButton implements ActionListener (),但还有另一种更优雅的方法来实现相同的结果吗？

在我的Android项目中，我定义了一些回调来对按钮单击，连接事件或UI事件（例如Dilaog.onShow（））进行操作。出于演示目的，我选择了必须从一些Activity代码启动的Runnable接口。使用Java，我有不同的表达方式。

一种模式是使用匿名类

runOnUiThread(new Runnable() { 
    public void run() { 
        doSomething(); 
    }
});

private void doSomething() {
}

另一个-定义内部私有类，即

private DoSomething implements Runnable {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(new DoSomething());

还有一个-使用私有成员，例如：

private final Runnable doSomething = new Runnable() {
    public void run() { 
        // do something; 
    }
}
...
runOnUiThread(doSomething);

这是我最喜欢的另一个，因为一方面，除非有人真正使用它，否则它实际上不会构造对象；因为它避免了多余的类，因为它可以在需要时使用参数。

private Runnable doSomething() { 
    return new Runnable() {
        public void run() { 
            // do something; 
        }
    }
}
...
runOnUiThread(doSomething());

我不是在寻找关于品味或宗教信仰的争论，而是在寻找代码的可维护性和性能。我想收到一些提示和建议，这些建议可以帮助我发展自己的偏爱，可能-根据给定的情况选择不同的偏爱。

扰流板：

Java的进步使这个问题过时了，​​请参见已接受的答案。

我有班级方法:

public object MyMethod(object obj)
{
   // I want to add some new properties example "AddedProperty = true"
   // What must be here?
   // ...

   return extendedObject;
}

和:

var extendedObject = this.MyMethod( new {
   FirstProperty = "abcd",
   SecondProperty = 100 
});

现在,extendedObject具有新属性.请帮忙.

我最近开始使用C＃，并且我想找到与此等效的方法。我不知道这叫什么，所以我将简单地通过代码向您展示。

使用Java，我能够创建如下接口：

public interface Event {
    public void execute();
}

并在方法的参数中传递此接口，如下所示：

public class TestEvent {
    ArrayList<Event> eventList = new ArrayList<Event>();

    public void addEvent(Event event){
        eventList.add(event);
    }

    public void simulateEvent(){
        addEvent(new Event() {
            public void execute(){
                //functionality
            }
        } );
    }

    public void processEvents(){
        for(Event event : eventList)
            eventList.execute();
    }
}

编辑：我的问题是关于类中的simulatEvent方法的TestEvent，如果使用C＃可以进行这样的操作。

我想知道是否有一种方法可以使用C＃执行类似的操作（实例化simulateEvent方法中的接口），以及这实际上是什么。谢谢！

这是来自oracle关于我正在阅读的匿名类的文章:

如果必须实现包含两个或更多方法的接口,则匿名类是理想的

我认为如果你必须实现少于两个方法,这是理想的,因为你不需要创建更具体的命名类,但如果你必须实现两个以上将更难以理解.

我的问题是:为什么要用2种或更多方法实现匿名类是理想的？

我正在尝试自学Java并且有一个我到目前为止无法回答的问题.在我的一些在线阅读中,我发现了两种使用动作监听器的方法,它们似乎做同样的事情.但我试图找出一个优于另一个的优势/劣势.

使用这样的匿名类是否更好:

public MyClass() {
...
    myButton.addActionListener(new ActionListener(){
        public void actionPerformed(ActionEvent e) {
            //doSomething
        }
    });
...
}

或者最好是在类的开头实现,如下所示:

public MyClass() implements ActionListener {
...
    myButton.addActionListener(this);

    public void actionPerformed(ActionEvent e) {
        //doSomething
    }
...
}

在Java 1.8上,您不必定义一个字段,因为final它可以从匿名类中获取.

例如,在旧版本上:

public void foo(final int bar) {
  new Runnable() {
    public void run() {
      System.out.println(bar);
    }
  };
}

但是,现在,在Java 1.8上,bar不需要是最终的:

public void foo(int bar) {
  new Runnable() {
    public void run() {
      System.out.println(bar);
    }
  };
}

所以,如果我编译我的项目,并且我正在使用的Java 1.8上实现的唯一资源就是这个(我没有使用任何lambdas,新类等),我的代码是否可以在具有较旧Java版本的计算机上执行？如果没有,为什么？

我最近碰到了这样的事情......

public final class Foo<T>
implements Iterable<T> {

    //...

    public void remove(T t) { /* banana banana banana */ }

    //...

    public Iterator<T> Iterator {
        return new Iterator<T>() {

            //...

            @Override
            public void remove(T t) {
                // here, 'this' references our anonymous class...
                // 'remove' references this method...
                // so how can we access Foo's remove method?           
            }

            //...

        };
    }
}

有什么方法可以做我正在尝试的同时保持这个匿名课程？或者我们必须使用内部类或其他东西？

我正在尝试在Android中使用SurfaceView来保存相机预览.文档告诉我,我需要在表面持有者的surfaceCreated回调中调用startPreview.我正试图像这样设置回调

this.surface!!.holder!!.addCallback(SurfaceHolder.Callback() {
    fun surfaceChanged(holder: SurfaceHolder, format: Int, 
                       width: Int, height: Int) {

    }

    fun surfaceCreated(holder: SurfaceHolder) {

    }

    fun surfaceDestroyed(holder: SurfaceHolder) {

    }
})

但是,我收到错误:

SurfaceHolder.Callback没有构造函数.

我很困惑为什么当这样的事情发生时这不起作用:

Thread(Runnable() {
    fun run() {
        ...        
    }
})