Что на самом деле делает ключевое слово "новое" в Java и следует ли избегать создания новых объектов?

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

    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);
        }
    }
}

Ответ 1 · рейтинг 25 · linuscash

Да, если вы вызвали myMethod() 10 раз, это создаст 10 уникальных и отдельных объектов.

Ключевое слово new делает именно то, что написано на банке, оно создает совершенно новый объект, независимо от того, существует ли он уже. Он создает новый объект и помещает ссылку на этот объект в переданную ему переменную, перезаписывая любое предыдущее значение (объект), хранящееся в переменной.

Каждый раз перераспределяется ли переменная myObject?

Опять же, да, он будет перераспределяться с новым объектом каждый раз, когда вызывается метод. Интересное замечание по этому поводу заключается в том, что переменная не будет "на самом деле" перераспределена, поскольку вы определяете переменную в самом теле метода, поэтому каждый раз, когда метод завершается, он будет удалять переменные, которые были определены в его области видимости. . Так что на самом деле он создает 10 отдельных переменных и назначает 10 отдельных объектов, хотя, как я уже сказал, остальные должны были быть удалены автоматически, чтобы не использовать дополнительную память.

В двух словах: должен ли я писать такой код только в том случае, если я планирую вызывать этот метод только один раз?

Как я уже сказал, в приведенном выше примере каждый объект будет уничтожен в конце выполнения метода (при условии, что вы не присвоили ссылку на объект переменной вне области действия метода), поэтому в вашем примере вы могли бы с радостью вызвать метод сколько угодно раз, но каждый раз никак не будет связан с предыдущими звонками.

Я понимаю, что моя манера письма может сбивать с толку, поэтому, если вы хотите, чтобы я что-то прояснил, просто спросите.

Обновлен ответ, чтобы отразить отредактированный вопрос

'почему бы не объявить 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!

Потому что типы просто не совпадают.

Есть смысл?

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

 Integer five = Integer.valueOf("5");//Will always return the same instance.
 Integer otherFive = Integer.valueOf("5");

 assert(five==otherFive);//true

 Integer five = new Integer("5");//Will create a new object each time.
 Integer otherFive = new Integer("5");

 assert(five==otherFive);//false