What does the 'new' keyword actually do in Java, and should I avoid creating new objects?
I signed up a few moments ago, though I've been making great use of this site since I took up computer programming, which I've been teaching myself and consider a little hobby of mine.
I did look up for similar questions, but in fact I couldn't find the answer I was seeking for. Now, being aware that, in Java (that's the language I was suggested to start off with), it is considered good programming practise to declare and instantiate variables as you need them, please consider the following lines:
class MyClass {
void myMethod() {
AnotherClass myObject = new AnotherClass();
myObject.doStuff();
}
}
Now, suppose I invoke myMethod(), say, 10 times while running my program, how does that work? Is a new object create every time? Is the myObject variable reallocated every time? Does the complier skip that like of code as it sees that the object has already been created and the variable myObject already been assigned to such object? In a nutshell: should I write code like that only if I plan to invoke that method only once? I know... shame on me for asking such a stupid question, but please give me a chance! Thanks in advance!
--------------------------- edited -----------------------------
So now am I supposed to edit this post after I get new answers?
btw... gosh that was quick, thanks a lot! And wow that confused me, a lot, I guess that's due to the fact that I've been teaching myself so...
Anyways, isn't it useless to create a new AnotherClass Object for the myObject variable every time? I mean, if i want to use the myObject variable throughout my program, shouldn't I declare it Once And For All? maybe in another method, that I'm going to invoke only once? Because as far as I understand, every time i invoke myMethod() a new object is creating, thus overriding myObject's own properties aka variables or am I just talking nonsense?
--------------------------- edited -----------------------------
My doubts came after reading this code from some website I can't remember right now:
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);
}
}
}
I mean, why not declare FileWriter, FileReader, BufferedReader and BufferedWriter at the top of the class as they did for the other variables? and why not initialise them as well maybe in the constructor? Why doing it every time the method is called rather than using maybe the same instance variable?
Answer
Yes, if you called myMethod() 10 times it will create 10 unique and separate objects.
The new keyword does exactly what it says on the tin, it creates a brand new object, irrespective of whether one already exists. It creates a new object and stuffs the reference to that object inside the variable it has been given, overwriting any previous value (object) the variable held.
Is the myObject variable reallocated every time?
Again, yes it would be re-allocated with a new object every time the method was called. An interesting note about this would be that the variable wouldn't "really" be re-allocated as you are defining the variable within the method body itself, so every time the method ends it will remove the variables that were defined within its' scope. So what it actually does is create 10 individual variables and assign 10 individual objects, although as I said the others should have been removed automatically so it wouldn't use any additional memory.
In a nutshell: should I write code like that only if I plan to invoke that method only once?
Well as I said, in the example above each object would be destroyed at the end of method execution (assuming you didn't assign the object reference to a variable outside the scope of the method) so in your example you could happily call the method as many times as you wanted but each time would in no way be connected to the previous calls.
I realise my way of writing can be confusing, so if you want me to clarify anything just ask.
Updated Answer to reflect edited question
'why not declare FileWriter, FileReader, BufferedReader and BufferedWriter at the top of the class as they did for the other variables?'
Okay, I assume you understand that the variables are not actually called FileWriter, FileReader, BufferedReader, and BufferedWriter, but rather this is the variable type. Their names are fw, fr, br, and bw. If you don't understand what I mean just ask. From now on I will refer to the variables by the names you did to make reading more easy, afterall fw just stands for FileWriter anyway so there should not be too much confusion.
The key to this question is hidden within the names of the variables themselves. Notice how they either end in Reader or Writer this can give us a subtle clue about their uses. Clearly FileWriter and BufferedWriter are to do with output in some way. By looking over the code we see that our suspicions were right and that at no point other than within the writeText(JTextArea area) method do these variables appear. So if the variable aren't used anywhere else within the code it would make logical sense to define and initialise them within the method that they are used in, not only does it make the code easier to read because we then "know" those variables are only related to that method, but also has the benefit of those variables being removed at the end of method execution, thereby not leaving variables in existence that were only used very briefly. By these rules we can say the same is true of FileReader and BufferedReader.
Observe this example about variable scope. (Look at the comments I added to the code)
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
From this example it becomes more clear as to why the variables are defined in the methods rather than as instance variables and initialised within the constructor. It allows for much cleaner code as well as being more readabe.
Why doing it every time the method is called rather than using maybe the same instance variable?
Well this question has to do with variable types. We couldn't reuse a single variable for all the information as the types would have needed to be different.
If we take all the variables from the code
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
Now we know that we cannot place a value that is not of the same type as the variable into that variable so something like
FileReader fr = new BufferedReader(fr); // Is not valid!
Because the types simply don't match.
Make sense?