在Java中匿名类有什么用?我们可以说使用匿名类是Java的优点之一吗?


当前回答

匿名内部类用于以下场景:

1)。对于重写(子类化),当类定义除当前情况外不可用时:

class A{
    public void methodA() {
        System.out.println("methodA");
    }
}

class B{
    A a = new A() {
        public void methodA() {
            System.out.println("anonymous methodA");
        }
    };
}

2)。为了实现一个接口,当接口的实现仅在当前情况下是必需的:

interface InterfaceA{
    public void methodA();
}

class B{
    InterfaceA a = new InterfaceA() {
        public void methodA() {
            System.out.println("anonymous methodA implementer");
        }
    };
}

3.) 参数定义匿名内部类:

interface Foo {
    void methodFoo();
}

class B{
    void do(Foo f) { }
}

class A{
    void methodA() {
        B b = new B();
        b.do(new Foo() {
            public void methodFoo() {
                System.out.println("methodFoo");
            } 
        });
    } 
} 

其他回答

所谓的“匿名类”,我想你是指匿名的内部类。

匿名内部类在创建具有某些“额外”(如重写方法)的对象实例时非常有用,而不必实际继承一个类。

我倾向于使用它作为附加事件监听器的快捷方式:

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // do something
    }
});

使用这个方法可以使编码更快一点,因为我不需要创建一个额外的实现ActionListener的类——我可以实例化一个匿名的内部类,而不需要实际创建一个单独的类。

我只在“快速而肮脏”的任务中使用这种技巧,让整个类感觉没有必要。拥有多个做完全相同事情的匿名内部类应该被重构为一个实际的类,无论是内部类还是单独的类。

匿名类指南。

匿名类同时声明和初始化。 匿名类必须扩展或实现到一个且仅一个类或接口响应。 由于匿名类没有名称,所以只能使用一次。

例如:

button.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent arg0) {
        // TODO Auto-generated method stub

    }
});

优化代码的最佳方法。也可以用于类或接口的重写方法。

import java.util.Scanner;
abstract class AnonymousInner {
    abstract void sum();
}

class AnonymousInnerMain {
    public static void main(String []k){
        Scanner sn = new Scanner(System.in);
        System.out.println("Enter two vlaues");
            int a= Integer.parseInt(sn.nextLine());
            int b= Integer.parseInt(sn.nextLine()); 
        AnonymousInner ac = new AnonymousInner(){
            void sum(){
                int c= a+b;
                System.out.println("Sum of two number is: "+c);
            }
        };
        ac.sum();
    }

}

是的,匿名内部类绝对是Java的优势之一。

使用匿名内部类,您可以访问周围类的final变量和成员变量,这在侦听器等方面很方便。

但是一个主要的优点是,内部类代码(至少应该)与周围的类/方法/块紧密耦合,具有特定的上下文(周围的类、方法和块)。

匿名内部类用于以下场景:

1)。对于重写(子类化),当类定义除当前情况外不可用时:

class A{
    public void methodA() {
        System.out.println("methodA");
    }
}

class B{
    A a = new A() {
        public void methodA() {
            System.out.println("anonymous methodA");
        }
    };
}

2)。为了实现一个接口,当接口的实现仅在当前情况下是必需的:

interface InterfaceA{
    public void methodA();
}

class B{
    InterfaceA a = new InterfaceA() {
        public void methodA() {
            System.out.println("anonymous methodA implementer");
        }
    };
}

3.) 参数定义匿名内部类:

interface Foo {
    void methodFoo();
}

class B{
    void do(Foo f) { }
}

class A{
    void methodA() {
        B b = new B();
        b.do(new Foo() {
            public void methodFoo() {
                System.out.println("methodFoo");
            } 
        });
    } 
}