标签: anonymous-class

ArrayList.remove(int index)正在使用ActionListener类的匿名实例: -

DeleteModule.java: -

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextField;



class MyFrame extends JFrame{

    private ArrayList<String> list = new ArrayList<String>() ; 
    private JButton btn = new JButton("Enter index to delete : ") ;
    private JTextField fld = new JTextField() ;

    MyFrame(){
        populateList() ;

        setLayout(new GridLayout(1, 2)) ;
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE) ;
        setSize(400, 60) ;

        btn.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                list.remove( Integer.parseInt( fld.getText() ) ) ;
                JOptionPane.showConfirmDialog(null, list, …

在Java中,我得到了这个例外:

Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Unknown Source)
    at Threads4.go(Threads4.java:14)
    at Threads4.main(Threads4.java:4)

这是代码:

public class Threads4 {
    public static void main(String[] args){
        new Threads4().go();
    }
    void go(){
        Runnable r = new Runnable(){
            public void run(){
                System.out.println("foo");
            }
        };
        Thread t = new Thread(r);
        t.start();
        t.start();

    }
}

这个例外是什么意思？

这是一个脑力激荡者.

我知道这个实际代码在很多层面都很糟糕.我的问题不是如何做到这一点(我知道静态初始化块),但为什么这不起作用,为了我理解Java序列化的好处.

为什么这样做

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

class Main {

    static Comparator<String> COMPARE_STRING_LENGTH;
    static {
        class CompareStringReverse implements Comparator<String>, Serializable {
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };
        COMPARE_STRING_LENGTH = new CompareStringReverse();    
    }

    public static void main(String[] args) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("test.ser"));
        out.writeObject(new TreeSet<String>(COMPARE_STRING_LENGTH));
        out.close();
    }

}

而这个

import java.io.*;
import java.util.*;
import java.util.concurrent.Callable;

class Main {

    static Comparator<String> COMPARE_STRING_LENGTH = new Callable<Comparator<String>>() {
        public …

我有以下代码:

public class Bar {}
public class FooBar {}

public class Foo {

    public void method() {
        new Bar() {

            void otherMethod() { }

            void barMethod() {

                new FooBar() {

                    void fooBarMethod() {
                        Bar.this.otherMethod(); // not compiles
                    }   
                };
            }
        };
    }

}

所以我有一个匿名内部类,其中有另一个匿名内部类.问题:有没有办法Bar从内部内部类访问外部内部类的方法FooBar？

在Java中,可以在初始化时为特定对象修改类结构:

Car ford = new Car(){   
    public float price;  
};

因此,福特对象获得了一个名为price的新属性,而其他车则没有.

有没有一种方法可以在C++中获得类似的功能,而无需创建整个子类？

谢谢!

如何在Java中获得对匿名内部类的类对象的引用？

对于非无限级的类,它完成了ClassName.class.

这个自我回答的问题的灵感来自变量'snackbar'可能尚未初始化.我觉得有更多细节可以更好地与特定问题分开添加.

为什么以下代码不能编译？

public class Example {
  public static void main(String[] args) {
    final Runnable example = new Runnable() {
      @Override
      public void run() {
        System.out.println(example);  // Error on this line
      }
    };
  }
}

编译错误:

error: variable example might not have been initialized

有没有办法声明一个没有实例的匿名类？

我想做这样的事情：

$myclass = (class {
    public $a;
})::class;

$myobject = new $myclass;

这是你可以用命名类做的事情，但上面的代码会抛出一个语法错误。

abstract class Person {  
abstract void eat();  
}  

class TestAnonymousInner {  
  public static void main(String args[]){  
  Person p=new Person() {  
    void eat(){System.out.println("nice fruits");}  
    };  
  p.eat();  
  }  
}

编译器生成的内部类

static class TestAnonymousInner$1 extends Person
{
    TestAnonymousInner$1(){}
    void eat()
    {
        System.out.println("nice fruits");
    }
}

为什么编译器将匿名类创建为静态？如果它是非静态会发生什么？

这是一个例子

JPanel panel = new JPanel(){
    @Override
    protected void paintComponent(Graphics g){
        // do stuff
    }

    @Override
    public Dimension getPreferredSize(){
        // do stuff
    }
};

这只是一个匿名内部类的变体,还是完全不同的东西？