Reference javaranch thread -> http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=042205&p=1

How many String Objects are created when executing the following code?

 11. public String makinStrings( ) { 12. String s = "Fred"; // this line creates one object 13. s = s + "47"; // this line creates two objects 14. s = s.substring( 2, 5); // this line creates one object 15. s = s.toUpperCase( ); // this line creates one object 16. return s.toString() ; 17. } 

Though many ranchers answered already (a seems to be correct answer is 3), the perfect explanation
given by Jim Yingst is here:

Unfortunately this isn't a very good test question, and it's not representative of the questions you'll get on the real exam. The problem is that the compile-time constants "Fred" and "47" have special behavior that's more subtle then you need to know for the exam, and it's ambiguous to say that they were "created" in the code. What happens is, String objects for "Fred" and "47" are created when the class is loaded, not when the method is run. And if the method is run more than once, "Fred" and "47" aren't recreated - they just get re-used. So, if you run the method just once and exit, you get:

"Fred", "47" created when class is loaded.
"Fred47", "ed47", "ED47" created when the method is run.

That's 5 strings total.

If you run the method 5 times, you get

"Fred", "47" created when class is loaded.
"Fred47", "ed47", "ED47" created when the method is run the 1st time
"Fred47", "ed47", "ED47" created when the method is run the 2nd time
"Fred47", "ed47", "ED47" created when the method is run the 3rd time
"Fred47", "ed47", "ED47" created when the method is run the 4th time
"Fred47", "ed47", "ED47" created when the method is run the 5th time

That's 17 strings over 5 method calls.

Additionally, in the event that some other code has used the constants "Fred" or "47" before the method is called, those strings won't be recreated at all. So it's possible that the above code could create just 3 objects when run once, and 15 object when run 5 times.

Based on all this, you can guarantee that at least three String objects are created when the method is run, and at most, five. I would say that three String objects are created in the method, and two may be caused to be created when the class is loaded.

Ultimately I don't think there's any way to determine what the "best" answer is for this question because, the way it's phrased, it's ambiguous. I wouldn't worry too much about it. The real exam won't have a question like this anyway.

JavaRanch Reference Thread -> http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=33&t=025141&p=1

Question by Jose Campana:
Analyze this case and please tell me Why the method with the comment //This method is never reached.

 class Base{ int value = 0; Base(){ addValue(); } void addValue(){ //This method value += 10; } int getValue(){ return value; } } class Derived extends Base{ Derived(){ addValue(); } void addValue(){ value += 20; } } public class Test3 { public static void main(String[] args){ Base b = new Derived(); System.out.println(b.getValue()); } } 

The preceding code prints out 40. And of course, that means that the method addValue() in class Base() never executes.

When inside Base() constructor, it calls the addValue() method, and it uses the one defined in class Derived. but the Question is:

WHY ?

JavaRanch Ref thread -> http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=33&t=011778

Reply from Mike Gershman:

In my view, constructors are misnamed - they alter already initialized variables in already created objects, based on the arguments passed to the constructors in the new syntax and on other sources.

Memory allocation for an object is done by the JVM based on information in the class object. The JVM also initializes the instance variables to their default values. Next, the variable initializers and the initialization blocks are executed together in the order they appear in the source code. They can alter the values of the variables. Finally, the constructors get a chance to modify the variables once again. At that point, the object is considered fully initialized and final variables can no longer be altered.

I have not considered the implications of super() here.

BTW, constructors are not methods. Unlike methods, constructors can alter final variables. There are constraints on constructors that don't apply to methods. And you can't call a constructor directly.

Question1: Inheritance - how many objects created???

 class A{ int a; } class B extends A{ int b; } class Try{ public static void main(String[] args){ B obj = new B() ; } } 

Question from Original Poster Imran Mehrenali:

1) In the above code, when i create an object of Class B, how many objects will get created? Only one object of class B that has 2 members (a and b) or two objects - one of class A that has one member (a), and another of class B that also has only member (b) but can directly acccess the member (a) beloning to object of class A.

2) I was about to ask how many constructors will be called, but have tried this out myself in a java program and have found that 2 constructors (A() and B()) are called while creating an object of class B.
Does this mean that 2 objects are created.

Question1: Inheritance - how many objects created???

 class A{ int a; } class B extends A{ int b; } class Try{ public static void main(String[] args){ B obj = new B() ; } } 

Question from Original Poster Imran Mehrenali:

1) In the above code, when i create an object of Class B, how many objects will get created? Only one object of class B that has 2 members (a and b) or two objects - one of class A that has one member (a), and another of class B that also has only member (b) but can directly acccess the member (a) beloning to object of class A.

2) I was about to ask how many constructors will be called, but have tried this out myself in a java program and have found that 2 constructors (A() and B()) are called while creating an object of class B.
Does this mean that 2 objects are created.

Reply from Ernest Friedman-Hill, Sheriff and Author in JavaRanch:
The answer is **just one object.

An instance of B includes an A "part". Imagine a piece of paper 1 inch square, call it A. Then think of a B object as a piece of paper 2 inches square, with a 1-inch square drawn onto it labeled "A". The A constructor is called to initialize the A part of the single B object.

JavaRanch reference thread -> http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=043103

But just when i thought that it was fairly clear, I found a question like this one:

 Assume the following method is properly synchronized and called from a thread A on an object B: wait(2000); After calling this method, when will the thread A become a candidate to get another turn at the CPU? A. After object B is notified, or after two seconds. B. After the lock on B is released, or after two seconds. C. Two seconds after object B is notified. D. Two seconds after lock B is released. Which one is the correct? 

The books says that A, but I simply don't get it, to me, there are no correct question.

The answer is ONLY ONE. But most refined answer is Only one Public Class, since there may be public nested class inside the same .java file which is legally allowed.

source : A Javaranch thread -> http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=33&t=023337

Reference from the JavaRanch thread ->

http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=039606

What is the output of the below program?

 public class Increment { public static int getNum(int x) { return x++; } public static void main(String[] args) { System.out.println(getNum(44)); } } 

The options for the answers are :

 (a) 44 (b) 45 (c) 46 

Output:

The answer is :

 (a) 44 

Reason with Explanation by Henry:
When the getNum() method calculates to value to be returned, it will use the value of x before it gets incremented (post increment means the value of x will be incremented after it has been used).

Sure, the value of x will be incremented, but the value to be returned has already been calculated by then.

Reason with Explanation by me:
Its more or less the same of assignment.

When you have

 int x = 2; int y = x++; System.out.println("x = "+x+", y = "+y); 

The above SOP will print the value as:

 x = 3, y = 2 

Why? and How? The value of x is being used in the operation first (ie., assignment). After the appropriate operation (here assignment) is done, the value of x is incremented! Right?

The same holds good in terms of your method as well. The value of x is being used for its operation (here, return value) first and then its incremented. But that does NOT mean that the updated value of x (incremented here) will be reflected back because the updation happens only after the value of x is being used (returned).

Hope this helps!

famous question on how many objects are created with respect to Strings (and literals).
Reference from javaranch: http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=039347
(though there were similar threads for the same post, this one is recent)

 String s1 = "spring "; String s2 = s1 + "summer "; s1.concat("fall "); s2.concat(s1); s1 += "winter "; System.out.println(s1 + " " + s2); 

Answer:

 a. 8 b. 6 c. 10 d. 4 

Answer is c. 10

Explanation
1 object ("spring") created in line 1
2 objects ("springsummer" and "summer") in line 2
2 objects ("springfall" and "fall") in line 3
1 object ("springsummerspring") in line 4
2 objects ("springwinter" and "winter") in line 5
2 objects ("spring "(with space at end) and "spring springsummer") in line 6

So in total there are ten objects

 int[][] 2dArray = new int[3][]; 

 int[][] 2dArray = new int[3][2]; 

Pick the correct answer from the options given below:

1. (1,1)
2. (2,2)
3. (1,4)
4. (2,4)
5. (2,3)