Question

我进入了另一个关于Java的“哲学”问题。这是关于以下情况：

你有一个T类，它定义了一个用作监听器的接口L，一个用于第二个类的通知器。

现在你有了第二个类（在下面的代码中，它们是A和B类。该类将创建一个类T的新对象，并使用L，后者将使用T与第一个进行通信。

所以我提出了4个不同版本的监听器对象如何传递给A：

类L定义LL的实现，即类T，并使用它的新对象创建A1类。
1. A2预先分配对象
2. B当场创建一个新对象
类L使用内联方式通过使用B1的匿名类创建对象（感谢Tim Bender进行更正）
1. B2预先分配对象
2. class T extends TT{ public interface L{ public void do(int i); } private L Lo; T(L i){ Lo = i; } public void start(){ // do stuff L.do(0); } }当场创建一个新对象

我的问题是，这些版本中的任何一个版本在某种程度上都更有效吗？出于某种原因，它们中的任何一个都不安全吗请讨论，建议其他版本并解释！

T类

class A1{
    private class LL implements L{
        @Override
        public void do(int i){
            // do stuff
        }
    }

    private LL l = new LL();

    public void function(){
        T t = new T(l)
    }
}

A类

class A2{
    private class LL implements L{
        @Override
        public void do(int i){
            // do stuff
        }
    }

    public void function(){
        T t = new T(new LL())
    }
}

class B1{
    private L l = new L(){
        @Override
        public void do(int i){
            // do stuff
        }
      };

    public void function(){
        T t = new T(l);
    }   
}

B类

class B2{
    public void function(){
        T t = new T(new L(){
            @Override
            public void do(int i){
                // do stuff
            }
        });
    }   
}

{{1}}

Answer 1

A和B之间的区别（使用匿名类）不是运行时差异。编译此代码时，您应该发现使用B1 $ 1之类的标识符创建匿名类。您甚至可以在编译到的bin目录中检查该类文件。

1和2之间的唯一区别是，通过创建成员变量，您实现了实例化包含类的实例所需的大小。如果需要，您应该只创建成员变量（用于重复使用）。

最重要的是，开发过程中的主要问题应该始终是清晰度和正确性。如果稍后出现性能问题，使用可识别问题区域的分析工具来处理正常运行的应用程序要好得多。或者，可能使用静态分析工具来识别小而容易的收益（低挂果）。

Answer 2

软件效率确实没有显着差异。它实际上归结为程序员的效率和更大的背景。如果您确定它只会被使用一次，那么B2通常是首选方法，因为它更简洁。 A1更冗长，但也更可重复使用。此外，通过选择好的变量名称，如果完全复杂的话，详细程度往往更适合自我记录的代码。

我的个人倾向是第三种选择，其中外部类实现接口，this传递给构造函数。

“Listener”类实现有什么区别？

2 个答案: