java - 'new'关键字在Java中实际上有什么作用，应该避免创建新对象吗？

Question

我刚才注册了，尽管自从我从事计算机编程以来就一直在充分利用这个站点，我一直在自学并考虑我的一点爱好。

我确实在寻找类似的问题，但实际上我找不到我想要的答案。
现在，您已经意识到，在Java(这是我建议使用的语言)中，在需要时声明和实例化变量被认为是良好的编程习惯，请考虑以下几行:

class MyClass {
    void myMethod() {
        AnotherClass myObject = new AnotherClass();
        myObject.doStuff();
    }
}

现在，假设我在运行程序时调用了myMethod()10次，那该如何工作？每次都会创建一个新对象吗？每次都重新分配myObject变量吗？编译器看到对象已经创建并且变量myObject已经分配给该对象时，是否会跳过代码的喜欢？简而言之:仅当我计划仅调用该方法一次时，我才应该编写这样的代码吗？
我知道...问这个愚蠢的问题让我感到羞耻，但请给我一次机会!
提前致谢!

---------------------------已编辑---------------------- -------

所以现在我应该在得到新答案后编辑这篇文章吗？
顺便说一句，天哪，很快，非常感谢!哇，这让我很困惑，我想那是由于我一直在自学……
无论如何，不​​是每次都为 new AnotherClass变量创建 myObject对象是没有用的吗？我的意思是，如果我想在整个程序中使用myObject变量，是否不应该一劳永逸地声明它？也许以另一种方法，我将只调用一次？因为据我所知，每次我调用 myMethod()时，都会创建一个新对象，从而覆盖myObject自身的属性(也就是变量)，还是我在胡说八道？

---------------------------已编辑---------------------- -------

从一些我现在不记得的网站上读取了这段代码后，我的怀疑就产生了:

    public class DataBase {

    private static String buf, retString = "\n";
    private static File file = new File("test.txt");

    public static void readText(JTextArea area) {   
        try {
            FileReader fr = new FileReader (file);
            BufferedReader br = new BufferedReader(fr);
            while ((buf = br.readLine()) != null) {
                area.append(buf); 
                area.append(retString);
            }
            br.close(); 
            fr.close();
        }
        catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }

    public static void writeText(JTextArea area) {
        try {
            FileWriter fw = new FileWriter (file);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(area.getText());
            bw.close(); 
            fw.close();
        }
        catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }
}

我的意思是，为什么不声明FileWriter，FileReader，BufferedReader和BufferedWriter
像其他变量一样，处于类的顶部？
为什么不在构造函数中初始化它们呢？
为什么每次调用该方法时都这样做而不是使用相同的实例变量？

Answer 1

是的，如果您调用myMethod() 10次，它将创建10个唯一且独立的对象。
new关键字完全按照其在锡 jar 上的说明进行操作，无论是否已经存在，它都会创建一个全新的对象。它将创建一个新对象，并将对该对象的引用填充到已给定的变量中，从而覆盖该变量保存的所有先前值(对象)。

Is the myObject variable reallocated every time?

再次，是的，每次调用该方法时，它将与一个新对象重新分配。有趣的是，在您定义方法主体本身中的变量时，不会“真正”重新分配该变量，因此，每次方法结束时，它将删除在其范围内定义的变量。因此，它的实际作用是创建10个单独的变量并分配10个单独的对象，尽管正如我所说，其他对象应已自动删除，因此不会使用任何额外的内存。

In a nutshell: should I write code like that only if I plan to invoke that method only once?

就像我说的，在上面的示例中，每个对象在方法执行结束时都会被销毁(假设您没有将对象引用分配给方法范围之外的变量)，因此在您的示例中，您可以愉快地调用该方法您可以进行多次，但每次都不会连接到先前的 call 。

我意识到我的写作方式可能会令人困惑，因此，如果您想让我澄清任何事情，请问。

更新了答案以反射(reflect)编辑后的问题

“为什么不像其他变量那样在类的顶部声明FileWriter，FileReader，BufferedReader和BufferedWriter？”

好的，我假设您了解变量实际上不是所谓的 FileWriter， FileReader， BufferedReader和 BufferedWriter，而是变量类型。它们的名称为 fw， fr， br和 bw。如果您不明白我的意思，那就问。从现在开始，我将使用您所做的命名来引用变量，以使阅读更加容易，毕竟 fw始终代表 FileWriter，因此不要有太多混淆。

这个问题的关键隐藏在变量本身的名称中。请注意，它们以 Reader或 Writer结尾的方式可以为我们提供有关其用法的微妙线索。显然 FileWriter和 BufferedWriter与输出有某种关系。通过查看代码，我们发现我们的猜想是正确的，并且除了 writeText(JTextArea area)方法之外，这些变量都没有出现。因此，如果未在代码中的其他任何地方使用该变量，则在使用它们的方法中定义和初始化它们是合乎逻辑的，这不仅使代码更易于阅读，因为我们随后“知道”了这些变量不仅与该方法有关，而且还具有在方法执行结束时删除这些变量的好处，因此不会留下仅短暂使用过的变量。通过这些规则，我们可以说 FileReader和 BufferedReader同样适用。

观察有关可变范围的此示例。 (看一下我添加到代码中的注释)

public class DataBase {

private static String buf, retString = "\n"; // buf & retString - created
private static File file = new File("test.txt"); // file - created

public static void readText(JTextArea area) {   
    try {
        FileReader fr = new FileReader (file); // fr (FileReader) - created
        BufferedReader br = new BufferedReader(fr); // br (BufferedReader) - created
        while ((buf = br.readLine()) != null) {
            area.append(buf); 
            area.append(retString);
        }
        br.close();
        fr.close();
    } // fr (FileReader & br (BufferedReader) - destroyed
    catch (IOException e) {
        System.out.println("Exception: " + e);
    }
}

public static void writeText(JTextArea area) {
    try {
        FileWriter fw = new FileWriter (file); // fw (FileWriter) - created
        BufferedWriter bw = new BufferedWriter(fw); // bw (BufferedWriter) - created
        bw.write(area.getText());
        bw.close(); 
        fw.close();
    } // fw & bw - destroyed
    catch (IOException e) {
        System.out.println("Exception: " + e);
    }
}
} // buf, retString and file - Still exist as long as the object exists

从该示例可以更清楚地了解，为什么在方法中定义变量而不是在构造函数中将其定义为实例变量。它允许更简洁的代码以及更多的可读性。

为什么每次调用该方法时都这样做而不是使用相同的实例变量？

这个问题与变量类型有关。我们不能为所有信息重用单个变量，因为类型必须有所不同。

如果我们从代码中获取所有变量

private static String buf, retString = "\n"; // valid
private static File file = new File("test.txt"); // valid

FileReader fr = new FileReader (file); // valid
BufferedReader br = new BufferedReader(fr); // valid
FileWriter fw = new FileWriter (file); // valid
BufferedWriter bw = new BufferedWriter(fw); // valid

现在我们知道我们不能将与变量类型不同的值放入该变量，因此

FileReader fr = new BufferedReader(fr); // Is not valid!

因为类型根本不匹配。

合理？