Java中匿名类的用途是什么？我们可以说匿名类的使用是Java的优势之一吗？
在以下代码段中:
public class a {
public void otherMethod(){}
public void doStuff(String str, InnerClass b){}
public void method(a){
doStuff("asd",
new InnerClass(){
public void innerMethod(){
otherMethod();
}
}
);
}
}
是否有一个关键字来引用内部类的外部类？基本上我想要做的是outer.otherMethod(),或类似的东西,但似乎找不到任何东西.
我是Java的新手,我正在使用新的API.我遇到了这个方法覆盖,我不确定这是什么叫:
public void exampleMethod() {
Button loginButton = new Button("login"){
public void onSubmit(){
//submit code here
}
};
}
据我所知,这将覆盖Button类的onSubmit方法.我以前从未遇到过这种压倒一切.它有特定的名称吗？我想了解更多关于它但我找不到它.到目前为止,我所有的搜索结果都是通过创建一个新类来定期重写,这是我已经熟悉的.
如果有人能指出我正确的方向,我会很感激.
谢谢.
这两种实例化类的新对象的方法有什么区别,如下所示:
Test t1=new Test();
Test t2=new Test(){ };
当我尝试下面的代码时,我可以看到两个对象都可以访问该方法foo(),但是t2无法访问variable x(variable x无法解析):
public class Test
{
int x=0;
public void foo(){ }
public static void main (String args[])
{
Test t1=new Test();
Test t2=new Test(){ };
t1.x=10;
t2.x=20;
t1.foo();
t2.foo();
System.out.println(t1.x+" "t2.x);
}
}
我有一个枚举类型:
public enum Operation {
PLUS() {
@Override
double apply(double x, double y) {
// ERROR: Cannot make a static reference
// to the non-static method printMe()...
printMe(x);
return x + y;
}
};
private void printMe(double val) {
System.out.println("val = " + val);
}
abstract double apply(double x, double y);
}
如上所述,我定义了一种enum有价值的类型PLUS.它包含一个不变的特定体.在它的正文中,我试着打电话 printMe(val);,但我得到了编译错误:
无法对非静态方法printMe()进行静态引用.
为什么我会收到此错误？我的意思是我在PLUS体内覆盖了抽象方法.为什么它在static范围内？如何摆脱它？
我知道添加一个static关键字来printMe(){...}解决问题,但我有兴趣知道如果我想保持printMe()非静态是否还有其他方法？
另一个问题,与上面的问题非常类似,但这次错误消息反过来说,即PLUS(){...}具有非静态上下文:
public enum Operation {
PLUS() …为什么第一种方式是正确的,但第二种方式不是？
第一种方式:
new Object() {
public void a() {
/*code*/
}
}.a();
第二种方式:
Object object = new Object() {
public void a() {
/*code*/
}
};
object.a();
我在哪里可以找到更多相关信息？
在做一些基本的lambda练习时,一个看似相同的匿名内部类的输出给了我一个不同于lambda的输出.
interface Supplier<T> {
T get(T t);
}
场景#1
Supplier<Integer> s1 = new Supplier<Integer>() {
@Override
public Integer get(Integer t) {
return t;
}
};
Supplier<Integer> s2 = t -> t;
System.out.println(s1.get(2));
System.out.println(s2.get(2));
输出2和2.这里没什么新鲜的.
但是当我这样做时:
场景#2
Supplier<Integer> s1 = new Supplier<Integer>() {
@Override
public Integer get(Integer t) {
return t++;
}
};
Supplier<Integer> s2 = t -> t++;
System.out.println(s1.get(2));
System.out.println(s2.get(2));
输出2和3
问题:两个输出不应该相同吗？我错过了什么吗？
为了完整起见: 场景#3
Supplier<Integer> s1 = new Supplier<Integer>() {
@Override
public Integer …我有以下代码片段:
public class Example {
private Integer threshold;
private Map<String, Progress> history;
protected void activate(ComponentContext ctx) {
this.history = Collections.synchronizedMap(new LinkedHashMap<String, Progress>() {
@Override
protected boolean removeEldestEntry(Map.Entry<String, Progress> entry) {
return size() > threshold;
}
});
}
}
Theres是匿名LinkedHashMap类和Example类之间的循环依赖.这样可以吗？为什么不？它会被垃圾收集器很好地收回吗？
我正在编写C#Wicket实现,以加深我对C#和Wicket的理解.我们遇到的一个问题是Wicket大量使用匿名内部类,而C#没有匿名内部类.
因此,例如,在Wicket中,您可以像这样定义一个链接:
Link link = new Link("id") {
@Override
void onClick() {
setResponsePage(...);
}
};
由于Link是一个抽象类,它强制实现者实现onClick方法.
但是,在C#中,由于没有匿名内部类,因此无法执行此操作.作为替代方案,您可以使用以下事件:
var link = new Link("id");
link.Click += (sender, eventArgs) => setResponsePage(...);
当然,这有一些缺点.首先,可以有多个Click处理程序,这可能不太酷.它也不会强制实现者添加Click处理程序.
另一个选择可能是只有一个这样的闭包属性:
var link = new Link("id");
link.Click = () => setResponsePage(...);
这解决了具有许多处理程序的问题,但仍然没有强制实现者添加处理程序.
所以,我的问题是,你如何在惯用的C#中模仿这样的东西？
我将如何为实现接口的内部类编写构造函数？我知道我可以创建一个全新的课程,但我认为必须有一种方法可以做到这一点:
JButton b = new JButton(new AbstractAction() {
public AbstractAction() {
super("This is a button");
}
public void actionPerformed(ActionEvent e) {
System.out.println("button clicked");
}
});
当我输入它时,它不会将AbstractAction方法识别为构造函数(编译器要求返回类型).有没有人有想法？