我不久前注册了，尽管自从我开始自学计算机编程以来，我一直在充分利用这个网站，我一直在自学计算机编程，并认为这是我的一个小爱好。

我确实查找过类似的问题，但事实上我找不到我正在寻找的答案。 现在，请注意，在 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 就像他们对其他变量所做的那样，在班级中名列前茅吗？ 为什么不在构造函数中也初始化它们呢？ 为什么每次调用方法时都这样做而不是使用相同的实例变量？

是的，如果你打电话myMethod()10 次它将创建 10 个独特且独立的对象。

The new关键字的作用与它在罐头上所说的完全一样，它创建一个全新的对象，无论该对象是否已经存在。它创建一个新对象，并将对该对象的引用填充到给定的变量中，覆盖该变量保存的任何先前值（对象）。

myObject 变量每次都会重新分配吗？

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

简而言之：只有当我计划只调用该方法一次时，我才应该编写这样的代码吗？

正如我所说，在上面的示例中，每个对象都会在方法执行结束时被销毁（假设您没有将对象引用分配给方法范围之外的变量），因此在您的示例中，您可以愉快地调用该方法您想要多少次都可以，但每次都不会连接到之前的呼叫。

我意识到我的写作方式可能会令人困惑，所以如果你想让我澄清任何事情，尽管问。

更新答案以反映编辑后的问题

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

好的，我假设您了解变量实际上并未被调用FileWriter, FileReader, BufferedReader, and BufferedWriter，而是变量类型。他们的名字是fw, fr, br, and bw。如果你不明白我的意思就问吧。毕竟，从现在开始，我将用您所做的名称来引用变量，以使阅读更容易fw只是代表FileWriter无论如何，所以不应该有太多的混乱。

这个问题的关键隐藏在变量本身的名称中。注意它们是如何结束的Reader or Writer这可以为我们提供有关其用途的微妙线索。清楚地FileWriter and BufferedWriter以某种方式与输出有关。通过查看代码，我们发现我们的怀疑是正确的，并且除了在writeText(JTextArea area)这些变量出现的方法。因此，如果变量没有在代码中的其他任何地方使用，那么在使用它们的方法中定义和初始化它们是合乎逻辑的，这不仅使代码更易于阅读，因为我们然后“知道”这些变量仅与该方法相关，而且还具有在方法执行结束时删除这些变量的好处，从而不会留下仅短暂使用的变量。根据这些规则，我们可以说同样如此FileReader and 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!

因为类型根本不匹配。

合理？