Question

我遇到了我的同事在eventListner中使用的代码，该代码是：

private void someActionPerformed(java.awt.event.ActionEvent evt) {                                         
    new className().methodName(); //public class and public void methodName()
}

我很确定：

private void someActionPerformed(java.awt.event.ActionEvent evt) {                                         
    className ref = new className(); //public class and public void 
    ref.methodName();
}

是比他更好的选择，因为前一个方法每次调用时都会实例化class。
我错了吗？任何建议表示赞赏，如果我错了，请纠正我

Answer 1

两者都做同样的事情，但是其中一个（第一个）缩短了1行。

当您需要浏览超过2-3个对象时，通常建议使用您的方法，因此通常不建议使用new Foo().getBar1().getBar2().doStuff()，因为它会降低为意大利面条代码并妨碍代码的可理解性。

Answer 2

第一个代码示例实例化Type className.methodName 的新 Object 。为此， methodName 必须是Type className 的静态嵌套类。
注意：这也可能是一个错字。你的意思是 new className（）。methodName（）？

第二个示例创建 className 的新实例，并调用其方法 methodName 。

一些示例代码：

public class Test {

    public static void main(String[] args) {
        new Test.test(); // instantiates the inner class

        Test t = new Test(); // instantiates Test
        t.test(); // calls method #test of Test-instance
    }

    public String test() {
        return "Test";
    }

    public static class test {

    }

}

为了判断什么是最佳解决方案，您的示例不会提供信息。该方法是某些静态实用程序代码还是 className 的实例有用？这取决于......

Answer 3

每当对象被实例化但没有赋予引用变量时，它就被称为匿名对象实例化。

使用匿名对象，您也可以调用它的实例方法：

new className().methodName();

在你的情况下，这是一个没有引用变量的匿名对象。

在声明中：

className ref = new className();
ref.methodName();

ref是保存className对象的引用变量，因此您可以在ref变量上调用className的实例方法。

使用匿名表示法的好处是，如果你只想做有限的（可能是调用单一方法等等）对底层对象的操作，这是一个很好的方法。但是，如果您需要对底层对象执行更多操作，则需要将该对象保留在引用变量中，以便您可以使用该引用对该对象执行多个操作。

关于性能，两者在方法范围内没有太大区别，只要方法完成，两个对象都是垃圾收集的有效候选者。

Answer 4

这两个方法都在代码中实例化一个类。如果要在每次调用方法时重用类对象，可以将其声明为方法所在的类的成员。例如：

class AnotherClass{
    private ClassName ref;

    AnotherClass(){
          ref = new ClassName()
    }

    private void someActionPerformed(java.awt.event.ActionEvent evt) {
        ref.methodName();
    }
}

这样，每次在someActionPerformed的对象上调用方法AnotherClass时，它都会重用ref对象，而不是每次都实例化它。

关于编辑，

public class ClassName {
    static class InnerClass{
        // A static inner class
    }
    public void methodName() {
        // A method
    }
}

class AnotherClass{
    private void someActionPerformed(java.awt.event.ActionEvent evt){
        // This creates an instance of the inner class `InnerClass`
        new ClassName.InnerClass(); 
        // However I believe, you wanted to do:
        new ClassName().methodName();
    }    
}

Answer 5

new className.methodName（）; - ＆GT;如果您在代码中使用此约定，则调用另一个方法名称将导致不同对象的方法名称，并且您将丢失您的值。

className ref = new className（）; ref.methodName（）; - ＆GT;在这里，您正在创建一个引用并为新创建的对象进行分配，并且您正在调用该方法。假设你想在同一个对象上调用另一个方法，它会有所帮助。

他们将主要用于监听的第一种方法是匿名课程。

Answer 6

每个选项在每次调用时都会创建一个新类。第二个选项优于第一个选项的优点是，如果您希望稍后在方法中重用该类。

Answer 7

恕我直言，这是DaniEll提供的answer更易理解的代码

public class Test {
    public static void main(String[] args) {
        new Test.test(); // instantiates the inner class
        Test t = new Test(); // instantiates Test
        t.test(); // calls method #test of Test-instance
    }

    public void test() {
        System.out.println("Outer class");
    }

    public static class test {
        public test() {
            System.out.println("Inner class");
        }
    }
}

new className（）。methodName（）; VS className ref = new className（）;

7 个答案: