标签: anonymous-inner-class

在onDestroy中

locationManager.removeUpdates(locationListener);
locationListener = null;

匿名实现

locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
        if (locationManager != null) {
            locationListener = new LocationListener() {
                @Override
                public void onLocationChanged(Location location) {
                    if (chatId != null) {
                        double radius = 6378.137;
                        double oldLat = mLastLocation.getLatitude();
                        double oldLng = mLastLocation.getLongitude();
                        double newLat = location.getLatitude();
                        double newLng = location.getLongitude();
                        double dLat = Math.toRadians(newLat - oldLat);
                        double dLng = Math.toRadians(newLng - oldLng);
                        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
                                + Math.cos(Math.toRadians(oldLat))
                                * Math.cos(Math.toRadians(newLat)) * Math.sin(dLng / …

在" OCP学习指南 "一书中,有一个关于可以用两种方式初始化的比较器的示例.第一个是通过这样的匿名类:

Comparator<Duck> byWeight = new Comparator<Duck>(){
    public int compare(Duck d1, Duck d2){
        return d1.getWeight() - d2.getWeight();
    }
};

这个我能理解.根据这本书,这可以用这样的lambda表达式替换:

Comparator<Duck> byWeight = (d1,d2) -> d1.getWeight() - d2.getWeight();

现在这个我不明白.lambda表达式不返回Comparator对象,由于Comparator是一个接口,因此我现在无法想到它.

那么new第一个例子中的运算符是否引用了正在创建的匿名类,它被称为Comparator,因为匿名类实现了Comparator接口？

那么在例2中到底发生了什么？是否以lambda表达式创建了某个对象？在这个例子中,你byWeight用作参考变量吧？

我真的不明白这一点,有人可以解释一下吗？谢谢.

如果我有

[编辑:添加"内部"的类型定义]

interface Inner{
    public void execute();
}

class Outer{
    int outerInt;
    public void hello(){
        Inner inner = new Inner(){
            public void execute(){
                outerInt=5;
            }
        }

        //later
        inner.execute();
    }
}

调用将该特定对象inner.execute()的outerInt变量设置为,无论它在何处被调用,并且只要该对象存在？或者它只是更改变量的副本而不影响原始对象？ Outer5InnerouterIntOuter

请看下面的代码:

import java.util.ArrayList;
import java.util.List;

class Main{
     public static <T> List<T> modifiedList(final List<T> list){
         return new ArrayList<T>(){
            @Override
             public boolean add(T element){
                 super.add(element);
                 return list.add(element);
             }
         };
    }

     public static void main(String[] args) {
         List<String> originalList=new ArrayList<String>();
         List<String> duplicateList=modifiedList(originalList);
         originalList.add("1");
         originalList.add("2");
         originalList.add("3");
         System.out.println(originalList+" "+duplicateList);
         duplicateList.add("4");
         duplicateList.add("5");
         duplicateList.add("6");
         System.out.println(originalList+" "+duplicateList);
     }

在上面的代码中,在modifyList()方法中声明的匿名内部类的实例能够访问传递给该方法的参数.AFAIK Java为内部类创建单独的字节码文件.

任何人都可以解释Java在字节码级别如何处理这些局部变量绑定？我的意思是,Java如何跟踪作为参数传递给该方法的对象的引用？

任何帮助将不胜感激!

[抱歉我的英语不好!如果您理解我的问题,请编辑此帖并删除语法错误.谢谢!]

所以我刚刚在网上找到了这个代码示例,我再次讨论它但很困惑.

通过查看它,我收集的内容(可能是错误的)是它将NumberPrinter类中的print方法传递给Printer对象.但是,该接口也称为Printer,因此我们不是要实例化Printer接口的匿名类,定义方法然后传递它吗？

我的基本问题是,我最初的假设是否正确？如果是这样我认为你无法实例化一个界面？

public class NumberPrinter {

    public interface Printer {
        public void print (int idx);
    }

    public static void print (Printer p) {
        for (int i = 0; i < 4; i++) {
            p.print(i);
        }
    }

    public static void main(String[] args) {
        print(new Printer() {

            @Override
            public void print(int idx) {
                System.out.println(idx);
            }

        });
    }

}

为什么会有人使用inner class？使用local class或可以实现相同的功能subclass.

一个例子也将被赞赏.

我最近遇到了EclipseCon 2014 的演示文稿,在第5页上他们说"Lambda表达式允许您将代码视为数据".

我也遇到了这个示例代码

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent event) {
        System.out.println("button clicked");
    }
});

来自Richard Warburton的"Java 8 Lambdas:实用功能编程",他说

"这实际上是使用代码作为数据的一个例子 - 我们为按钮提供了一个表示动作的对象."

代码作为数据对于Lambda表达式和/或匿名内部类意味着什么？

我一直在考虑课程,特别是关于匿名内部课程.这让我想知道匿名内部类的访问类型是什么？

我意识到在大多数情况下,这不会改变任何东西,但它可能会对反射产生影响.我已经看到几个问题,询问使用反射访问匿名内部类的内容时遇到问题.

我确实找到了这个问题(这个问题的一个例子): 使用java反射调用匿名类的方法时访问异常

这个答案表明它是私人的,但作者无法确认:https: //stackoverflow.com/a/2659647/3049628

当转换通过像DependencyFinder和java-callgraph这样的库生成的java调用图时,我发现java编译器为匿名函数,内部类等生成名称.

我已经找到了其中几个的含义(如果我错了,请纠正):

• org.example.Bar$Foo指的是Foo,这是一个内在的类org.example.Bar.
• org.example.Bar$1指的是在其中一个方法中声明的匿名类org.example.Bar.
• org.example.Bar.lambda$spam$1()指的是在org.example.Bar.spam()方法内声明的lambda .

但是,我也发现:

1. org.example.Bar$$Lambda$2.args$1
2. org.example.Bar$$Lambda$2.call()
3. org.example.Bar$$Lambda$7.lambdaFactory$()
4. org.example.Bar$$Lambda$7.get$Lambda()

上面的四个名字是指什么？double dollar($$)是什么意思？

在Java中,我有以下代码

List<Integer> myList = new ArrayList<>();
for (int i=0;i<9;i++) {
    myList.add(i);
}

Integer sum = 0;

myList.forEach(i -> {
    sum = sum + i; // does not compile, sum needs to be final or effectively final
});   

for(int i : myList) {
    sum = sum + i; //runs without problems
} 

我的问题是,为什么我不能在lambda中改变sum的值？它与下面的for循环完全相同,或者我错了？有趣的是,如果我将main方法之外的整数和声明为静态,它也可以.谁能解释我为什么？

编辑:在另一个类似的问题Java 8支持闭包,答案似乎是:

它是向后兼容性和项目资源约束的组合.

但是,我仍然无法理解为什么它可以工作,如果我将数组和数组或我在main之外声明它.我还想了解下面的myList.forEach和for循环之间有什么区别,为什么一个有效,另一个没有.