Java is the future !

Quiz of the day | OCPJP - Aug 16, 2011

2011-08-16T12:50:00.000+05:30

What will be the result of compiling and running the following code:

Options :
a) true
true
b) false
true
c) false
false
d) None of the above

Solution: Correct choice is option B.
Creating a new instance of the class File, you're not yet making an actual file, you're just creating a filename. So file.exists() return false.
createNewFile() method created an actual file. So file.exists() return true.

How to become a Java developer?

2011-08-16T11:59:00.001+05:30

"I want to be a java developer, What are the all skills that I need to have. I have learned the core java in college but what now?"

Does this sound a familiar question! You too may have a similar question in your mind. Don't worry, This article explains what are all the skills that you will need to be a Java web developer, and what are the skills that you are expected to have when you appear for an interview for a Java/J2EE web developer.

Java developer! But what kind of?

Let me clarify, this article is about the Java web development. As most of the time, when beginner say, 'I want to be a java developer', he actually means he wants to be a java web developer and wants to get involved in developing web applications. Otherwise, Java development in general is a vast field, today Java is used in many types of platforms, that includes Personal computers, Main frames, Hand held portable devices, Mobiles, Smart cards, Games and many more thing. But the biggest stream of java development that creates more jobs than any other stream is the JavaEE platform. The JavaEE platform is used to create the enterprise applications (It includes web applications as well).

So be clear in your mind, This article is about java web development or enterprise application development. Most of the time when you read a job classified for skills, “Spring, Spring MVC, Struts, Hibernate, EJB” they are for java web development.

So, now it’s clear that you want to be a Java web developer and looking for a jump start. So here are the skills that will get you going.

Step 1 : First thing first, know the basics, learn core Java

The first thing you must learn is Core Java. Having a solid foundation in core java will help you when you jump into the advanced java. No matter what Java technologies you plan to work on, you will need to use the core java every day. So it is absolutely must to have a good understanding of the core concepts. Learn the basic programming concepts like variables, branching and looping, logical conditions, data types etc.

Good understanding of core java library is a must

Learn core java library, especially collection framework, Threads, java.lang, java.io packages. If you are targeting the web development, you may not want to waste time on the swing.
Get yourself a good core java book that covers the latest java edition JDK 1.6. (When I was a beginner, I read “The complete reference java”)

Step 2 : Learn to use an IDE (Integrated Development Environment)

While working as a professional, you won’t use the plain text editors to write the code, you will have to know how to use IDE. IDE A.K.A code editor will greatly improve your productivity, and make your life easier. Code editors are used to write, compile, run and debug code. They provide features like syntax highlighting, auto completion, can identify the problems in code even before compiling. These are some of the most common features, but there are many more than just these. I will recommend you to learn eclipse which is one of the most popular IDE amongst java developer, and its free.

Step 3 : Your first step towards web development, HTML, CSS and JavaScript

I will not explain what HTML or CSS is, there are plenty of resources available on the internet. But understand, this is the most important parts of any web application. Second most important thing to learn is JavaScript, let me clarify, the JavaScript is not java, the similarity in name is for historical reasons. Get yourself into the world of web applications with this three skills, learn some tutorials on the internet or get some good book.

Step 4 : The java web components, Servlet API and JSP

Almost every web application running on internet or intranet which is developed in Java has their roots in Servlet API. So next thing to learn is servlets. Servlet API is the only standard API for java web application development. JSP is also based on the servlet API. Almost all the web frameworks, like Spring MVC, Struts, Wicket uses the servlet API under the hood. Get yourself a good book like “head first servlet”. Having the solid understanding of the Servlet API is quite important. Understand the core concepts like, life cycle, request, response, filters, session, config, context etc.

Step 5 : Learn a web container

Web container is a run time environment or server that is used to deploy and run the web applications or more specifically Web components (Eg servlets or JSP)
Web containers does not know how to run struts or Spring MVC, they just understand the servlet API, but still you can run them on a web container, because ultimately they are based on the Servlet API. You can learn the tomcat, that would be sufficient initially.

Step 6 : Learn JDBC

Almost every web application will need to connect to a database for storing and retrieving persistent data. JDBC is the standard API for database connectivity. So it is quite important that you understand the JDBC well.

Step 7 : Learn a web application framework and an ORM framework

A web application framework is actually a set of libraries that makes developing web applications easier. Struts and Spring MVC are good choices. If you are just starting, I would recommend going with Spring MVC.

ORM stands for object to relational mapping, they are based on JDBC and used for storing and querying the database. But unlike JDBC, ORM frameworks operates on objects and provides ways for storing and retrieving objects. (But be clear, they are ultimately using JDBC under the hood). ORM frameworks reduces lots of boilerplate code, improves productivity and makes developers life easier. Hibernate is the best choice. If you are just starting, read and understand JPA (Java persistence API) which is the standard java ORM API. You can use hibernate for running your JPA code.

That's it. If you know everything I mentioned above well, you are all set to get a job as java web developer.

Step 8 : What next!

Once you are familiar with the things mentioned above, The next step would be to learn the JavaEE (Java enterprise edition). Learn EJB (Enterprise java beans), JSF (Java server faces) and other APIs that are part of the JavaEE. Get a good book that covers the latest JavaEE edition 1.6

Resources

Quiz of the day | OCPJP - 16 Aug 2011

2011-08-16T10:23:00.000+05:30

What is the output for the above code ?

Options :
a) Compile with error - Not allowed to override the return type of a method with a subtype of the original type.
b) class A - return C
c) class B - return D
d) Runtime Exception

char a = '\u000A'. Why is this invalid?

2011-05-14T10:23:00.000+05:30

Unicode escape characters of the form '\Uxxxx', where xxxx is a hexadecimal value, are processed very early in the translation process (see JLS 3.10.4 ). As a result, the special characters '0A' (line feed) and '0D' (carriage return) are interpreted literally as "end of line."
For example, the expression...

char A = '\u000A';

...therefore becomes...

char A =;

...which results in a compile-time error.
To avoid this error, always use the special escape characters '\n' (line feed) and '\r' (carriage return).

Is it allowed to declare the main method private?

2011-05-14T06:41:00.000+05:30

Former JVM versions (pre-1.4) allowed the main method to have any accessibility (private, etc). This incompatibility with Section 12.1.4 of the Java Language Specification has been fixed as of version 1.4. In order to invoke a main method from the command-line, it is now mandatory to declare the main method as follows:

public static void main (String[] args)

If the main method has any access level other than public, it will no longer run from the command-line.

What are some potential trips/traps in the SCJP exam?

2011-04-24T13:47:00.001+05:30

Two top-level public classes cannot be in the same source file.
main() cannot call an instance (non-static) method.
Methods can have the same name as the constructor(s).
Watch for thread initiation with classes that don't have a run() method.
Local classes cannot access non-final variables.
Case statements must have values within permissible range.
Watch for Math class being an option for immutable classes.
instanceOf is not the same as instanceof.
Constructors can be private.
Assignment statements can be mistaken for a comparison; e.g., if(a=true)...
Watch for System.exit() in try-catch-finally blocks.
Watch for uninitialized variable references with no path of proper initialization.
Order of try-catch-finally blocks matters.
main() can be declared final.
-0.0 == 0.0 is true.
A class without abstract methods can still be declared abstract.
Map does not implement Collection.
Dictionary is a class, not an interface.
Collection (singular) is an Interface, but Collections (plural) is a helper class.
Class declarations can come in any order (e.g., derived first, base next, etc.).
Forward references to variables gives a compiler error.
Multi-dimensional arrays can be "sparse" -- i.e., if you imagine the array as a matrix, every row need not have the same number of columns.
Arrays, whether local or class-level, are always initialized
Strings are initialized to null, not empty string.
An empty string is not the same as a null reference.
A declaration cannot be labelled.
continue must be in a loop (e.g., for, do, while). It cannot appear in case constructs.
Primitive array types can never be assigned to each other, even though the primitives themselves can be assigned. For example, ArrayofLongPrimitives = ArrayofIntegerPrimitives gives compiler error even though longvar = intvar is perfectly valid.
A constructor can throw any exception.
Initializer blocks are executed in the order of declaration.
Instance initializers are executed only if an object is constructed.
All comparisons involving NaN and a non-NaN always result in false.
Default type of a numeric literal with a decimal point is double.
int and long operations / and % can throw an ArithmeticException, while float and double / and % never will (even in case of division by zero).
== gives compiler error if the operands are cast-incompatible.
You can never cast objects of sibling classes (sharing the same parent).
equals() returns false if the object types are different. It does not raise a compiler error.
No inner class (non-static inner class) can have a static member.
File class has no methods to deal with the contents of the file.
InputStream and OutputStream are abstract classes.

What's up with integers not being equal to one another? The following code prints "true, true, false, true". Shouldn't it be "true, true, true, true"?

2011-04-24T13:27:00.002+05:30

The key to understanding this is that the JVM uses a process called "boxing" (or "auto-boxing") when converting an int (like 127) to an Integer object. This involves calling the Integer.valueOf(127) method. The JavaDoc:java.lang.Integer#valueOf(int) says: "Returns a Integer instance representing the specified int value. If a new Integer instance is not required, this method should generally be used in preference to the constructor Integer(int), as this method is likely to yield significantly better space and time performance by caching frequently requested values." What that means is that the valueOf() method has a cache of Integer objects, and if the primitive being boxed is in that range, the cached object is returned. It just so happens that 127 is in that range, but 128 is not. So i and j are the same object, while i1 and j1 are not.

Source: CodeRanch

How to convert a String array to ArrayList?

2011-04-24T11:48:00.002+05:30

1.

2.

3.

Note: In the solution no 1 Arrays.asList() is efficient because it doesn't need to copy the content of the array. This method returns a List that is a "view" onto the array - a wrapper that makes the array look like a list. When you change an element in the list, the element in the original array is also changed. Note that the list is fixed size - if you try to add elements to the list, you'll get an exception.

If you only need read access to the array as if it is a List and you don't want to add or remove elements from the list, then only use solution no 1.

Source: JavaRanch

Difference between Class reference and Interface reference

2011-04-24T01:18:00.003+05:30

Interface provides the base for the concrete classes. It defines the contract which must be full filled by the implementing classes. So it can be use full in case where you need polymorphism. for example if you have some classes and interface like:

Here if you want to do some generic work which is common for both the doctors (doCheckUp) you should use the interface like

In this case no matter which object you are passing it will call the doCheckUp method of corresponding object. But your concrete class can have some extra methods and if you want to use those methods then you have to call the methods using corresponding concrete class objects.

So If you want to use the generic common methods, you should use the interface instance.

Top 10 errors java programmers make

2011-01-30T18:58:00.002+05:30

Whether you program regularly in Java, and know it like the back of your hand, or whether you're new to the language or a casual programmer, you'll make mistakes. It's natural, it's human, and guess what? You'll more than likely make the same mistakes that others do, over and over again. Here's my top ten list of errors that we all seem to make at one time or another, how to spot them, and how to fix them.

10. Accessing non-static member variables from static methods (such as main)

Many programmers, particularly when first introduced to Java, have problems with accessing member variables from their main method. The method signature for main is marked static - meaning that we don't need to create an instance of the class to invoke the main method. For example, a Java Virtual Machine (JVM) could call the class MyApplication like this :-

MyApplication.main ( command_line_args );

This means, however, that there isn't an instance of MyApplication - it doesn't have any member variables to access! Take for example the following application, which will generate a compiler error message.

public class StaticDemo
{
        public String my_member_variable = "somedata";

public static void main (String args[])
        {
  // Access a non-static member from static method
                System.out.println ("This generates a compiler error" +
   my_member_variable );
        }
}

If you want to access its member variables from a non-static method (like main), you must create an instance of the object. Here's a simple example of how to correctly write code to access non-static member variables, by first creating an instance of the object.

public class NonStaticDemo
{
        public String my_member_variable = "somedata";

        public static void main (String args[])
        {
                NonStaticDemo demo = new NonStaticDemo();

  // Access member variable of demo
                System.out.println ("This WON'T generate an error" +
                        demo.my_member_variable );
        }
}

9. Mistyping the name of a method when overriding

Overriding allows programmers to replace a method's implementation with new code. Overriding is a handy feature, and most OO programmers make heavy use of it. If you use the AWT 1.1 event handling model, you'll often override listener implementations to provide custom functionality. One easy trap to fall into with overriding, is to mistype the method name. If you mistype the name, you're no longer overriding a method - you're creating an entirely new method, but with the same parameter and return type.

public class MyWindowListener extends WindowAdapter {
 // This should be WindowClosed
 public void WindowClose(WindowEvent e) {
  // Exit when user closes window
  System.exit(0);
 }
});

Compilers won't pick up on this one, and the problem can be quite frustrating to detect. In the past, I've looked at a method, believed that it was being called, and taken ages to spot the problem. The symptom of this error will be that your code isn't being called, or you think the method has skipped over its code. The only way to ever be certain is to add a println statement, to record a message in a log file, or to use good trace debugger (like Visual J++ or Borland JBuilder) and step through line by line. If your method still isn't being called, then it's likely you've mistyped the name.

8. Comparison assignment ( = rather than == )

This is an easy error to make. If you're used other languages before, such as Pascal, you'll realize just how poor a choice this was by the language's designers. In Pascal, for example, we use the := operator for assignment, and leave = for comparison. This looks like a throwback to C/C++, from which Java draws its roots.
Fortunately, even if you don't spot this one by looking at code on the screen, your compiler will. Most commonly, it will report an error message like this : "Can't convert xxx to boolean", where xxx is a Java type that you're assigning instead of comparing.

7. Comparing two objects ( == instead of .equals)

When we use the == operator, we are actually comparing two object references, to see if they point to the same object. We cannot compare, for example, two strings for equality, using the == operator. We must instead use the .equals method, which is a method inherited by all classes from java.lang.Object.
Here's the correct way to compare two strings.

String abc = "abc"; String def = "def";

// Bad way
if ( (abc + def) == "abcdef" )
{
    ......
}

// Good way
if ( (abc + def).equals("abcdef") )
{
   .....
}

6. Confusion over passing by value, and passing by reference

This can be a frustrating problem to diagnose, because when you look at the code, you might be sure that its passing by reference, but find that its actually being passed by value. Java usesboth, so you need to understand when you're passing by value, and when you're passing by reference.
When you pass a primitive data type, such as a char, int, float, or double, to a function then you are passing by value. That means that a copy of the data type is duplicated, and passed to the function. If the function chooses to modify that value, it will be modifying the copy only. Once the function finishes, and control is returned to the returning function, the "real" variable will be untouched, and no changes will have been saved. If you need to modify a primitive data type, make it a return value for a function, or wrap it inside an object.
When you pass a Java object, such as an array, a vector, or a string, to a function then you arepassing by reference. Yes - a String is actually an object, not a primitive data type. So that means that if you pass an object to a function, you are passing a reference to it, not a duplicate. Any changes you make to the object's member variables will be permanent - which can be either good or bad, depending on whether this was what you intended.
On a side note, since String contains no methods to modify its contents, you might as well be passing by value.

5. Writing blank exception handlers

I know it's very tempting to write blank exception handlers, and to just ignore errors. But if you run into problems, and haven't written any error messages, it becomes almost impossible to find out the cause of the error. Even the simplest exception handler can be of benefit. For example, put a try { .. } catch Exception around your code, to catch ANY type of exception, and print out the message. You don't need to write a custom handler for every exception (though this is still good programming practice). Don't ever leave it blank, or you won't know what's happening.
For example

public static void main(String args[])
{
    try {
 // Your code goes here..
    }
    catch (Exception e)
    {
 System.out.println ("Err - " + e );
    }
}

4. Forgetting that Java is zero-indexed

If you've come from a C/C++ background, you may not find this quite as much a problem as those who have used other languages. In Java, arrays are zero-indexed, meaning that the first element's index is actually 0. Confused? Let's look at a quick example.

// Create an array of three strings
String[] strArray = new String[3];

// First element's index is actually 0
strArray[0] = "First string";

// Second element's index is actually 1
strArray[1] = "Second string";

// Final element's index is actually 2
strArray[2] = "Third and final string";

In this example, we have an array of three strings, but to access elements of the array we actually subtract one. Now, if we were to try and access strArray[3], we'd be accessing the fourth element. This will case an ArrayOutOfBoundsException to be thrown - the most obvious sign of forgetting the zero-indexing rule.
Other areas where zero-indexing can get you into trouble is with strings. Suppose you wanted to get a character at a particular offset within a string. Using the String.charAt(int) function you can look this information up - but under Java, the String class is also zero-indexed. That means than the first character is at offset 0, and second at offset 1. You can run into some very frustrating problems unless you are aware of this - particularly if you write applications with heavy string processing. You can be working on the wrong character, and also throw exceptions at run-time. Just like the ArrayOutOfBoundsException, there is a string equivalent. Accessing beyond the bounds of a String will cause a StringIndexOutOfBoundsException to be thrown, as demonstrated by this example.

public class StrDemo
{
 public static void main (String args[])
 {
        String abc = "abc";

        System.out.println ("Char at offset 0 : " + abc.charAt(0) );
        System.out.println ("Char at offset 1 : " + abc.charAt(1) );
        System.out.println ("Char at offset 2 : " + abc.charAt(2) );

 // This line should throw a StringIndexOutOfBoundsException
        System.out.println ("Char at offset 3 : " + abc.charAt(3) );
 }
}

Note too, that zero-indexing doesn't just apply to arrays, or to Strings. Other parts of Java are also indexed, but not always consistently. The java.util.Date, and java.util.Calendar classes start their months with 0, but days start normally with 1. This problem is demonstrated by the following application.

import java.util.Date;
import java.util.Calendar;

public class ZeroIndexedDate
{
        public static void main (String args[])
        {
                // Get today's date
                Date today = new Date();
 
  // Print return value of getMonth
  System.out.println ("Date.getMonth() returns : " +
    today.getMonth());

  // Get today's date using a Calendar
  Calendar rightNow = Calendar.getInstance();

  // Print return value of get ( Calendar.MONTH )
  System.out.println ("Calendar.get (month) returns : " +
   rightNow.get ( Calendar.MONTH ));

}
}

Zero-indexing is only a problem if you don't realize that its occurring. If you think you're running into a problem, always consult your API documentation.

3. Preventing concurrent access to shared variables by threads

When writing multi-threaded applications, many programmers (myself included) often cut corners, and leave their applications and applets vulnerable to thread conflicts. When two or more threads access the same data concurrently, there exists the possibility (and Murphy's law holding, the probability) that two threads will access or modify the same data at the same time. Don't be fooled into thinking that such problems won't occur on single-threaded processors. While accessing some data (performing a read), your thread may be suspended, and another thread scheduled. It writes its data, which is then overwritten when the first thread makes its changes.
Such problems are not just limited to multi-threaded applications or applets. If you write Java APIs, or JavaBeans, then your code may not be thread-safe. Even if you never write a single application that uses threads, people that use your code WILL. For the sanity of others, if not yourself, you should always take precautions to prevent concurrent access to shared data.
How can this problem be solved? The simplest method is to make your variables private (but you do that already, right?) and to use synchronized accessor methods. Accessor methods allow access to private member variables, but in a controlled manner. Take the following accessor methods, which provide a safe way to change the value of a counter.

public class MyCounter
{
 private int count = 0; // count starts at zero

 public synchronized void setCount(int amount)
 { 
  count = amount;
 }
 
 public synchronized int getCount()
 {
  return count;
 }
}

2. Capitalization errors

This is one of the most frequent errors that we all make. It's so simple to do, and sometimes one can look at an uncapitalized variable or method and still not spot the problem. I myself have often been puzzled by these errors, because I recognize that the method or variable does exist, but don't spot the lack of capitalization.
While there's no silver bullet for detecting this error, you can easily train yourself to make less of them. There's a very simple trick you can learn :-

all methods and member variables in the Java API begin with lowercase letters
all methods and member variables use capitalization where a new word begins e.g - getDoubleValue()

If you use this pattern for all of your member variables and classes, and then make a conscious effort to get it right, you can gradually reduce the number of mistakes you'll make. It may take a while, but it can save some serious head scratching in the future.

(drum roll)

And the number one error that Java programmers make !!!!!

1. Null pointers!

Null pointers are one of the most common errors that Java programmers make. Compilers can't check this one for you - it will only surface at runtime, and if you don't discover it, your users certainly will.
When an attempt to access an object is made, and the reference to that object is null, a NullPointerException will be thrown. The cause of null pointers can be varied, but generally it means that either you haven't initialized an object, or you haven't checked the return value of a function.
Many functions return null to indicate an error condition - but unless you check your return values, you'll never know what's happening. Since the cause is an error condition, normal testing may not pick it up - which means that your users will end up discovering the problem for you. If the API function indicates that null may be returned, be sure to check this before using the object reference!
Another cause is where your initialization has been sloppy, or where it is conditional. For example, examine the following code, and see if you can spot the problem.

public static void main(String args[])
{
 // Accept up to 3 parameters
 String[] list = new String[3];

 int index = 0;

 while ( (index < args.length) && ( index < 3 ) )
 {
  list[index++] = args[index];
 }

 // Check all the parameters 
 for (int i = 0; i < list.length; i++)
 {
  if (list[i].equals "-help")
  {
   // .........
  }
  else
  if (list[i].equals "-cp")
  {
   // .........
  }
  // else .....
 } 
}

This code (while a contrived example), shows a common mistake. Under some circumstances, where the user enters three or more parameters, the code will run fine. If no parameters are entered, you'll get a NullPointerException at runtime. Sometimes your variables (the array of strings) will be initialized, and other times they won't. One easy solution is to check BEFORE you attempt to access a variable in an array that it is not equal to null.

Summary

These errors represent but some of the many that we all make. Though it is impossible to completely eliminate errors from the coding process, with care and practice you can avoid repeating the same ones. Rest assured, however, that all Java programmers encounter the same sorts of problems. It's comforting to know, that while you work late into the night tracking down an error, someone, somewhere, sometime, will make the same mistake!

Source : javacoffeebreak

Top 5 reasons that make SCJP Certification Exam tough

2010-12-05T13:20:00.002+05:30

1.You are not in reality of the exam preparation
Most of the time preparation for this certification exam is approached in the conventional style especially the way you did preparation back in school and college days. However the reality of this exam is that you are no longer in school or in college (some exceptions maybe there) you are in a full time job and you have to manage job responsibilities and also are going to study after a break. Hence the preparation approach must be also different.

Solution : Plan ahead
Rather than beating yourself up for not studying the way you did earlier design a new approach as the circumstances are different now. Make a study plan keeping the reality of the current circumstance in mind.

2.You only prepare theoretical aspects of the exam
The SCJP exam now-a-days having more coding questions. Small code snippets are given and either with compilation errors or code logic errors need to be answered.

Solution : Practice practice practice...
SCJP questions can be best answered if you have done hands on programming in Java and if not then you will need to practise many such questions that give you exposure of coding. Look for mock tests/sample practise tests that have you practise a lot of coding.

3.Preparing Alone
Preparing for the certification exam alone is a trap you will never be able to study alone as you have never done that in school/college etc you had your entire class friends preparing with you.

Solution : get a group of committed people to take the exam with you
Get a friend/colleague or register in a Java forum to belong to a group of people and prepare along with them. Not only will it be fun but it" also give you the required competition and keep you on your toes.

4.Nothing happens over night
You might have heard of this great person in your office who passed the exam in 1 week or 1 month and now you are impatient as to how long it will take for you to be certified. You plan for 1 month and soon the plan goes to the dogs so now you are really impatient and in your mind you have made it a very tough exam that will take lots to pass.

Solution : Build brick by Brick
Don't try to learn the entire language in a week/month, take your time. Keep the objective of learning and not just somehow passing the certification exam. Learn "why" something works a given way, not just that it works one way. This will surely see you long way in your journey as a Java professional.

5. Am I ready to take the test?
This is a tough one to answer. And exam will always be an exam meaning it will always give butterfly in your stomach and make you feel like throwing up the moment you think of taking the exam.

Solution : Don"t be guided by you feelings
Here again I will point to the first point, keep in touch with the reality of your exam preparation. Let the scores in the practise tests/mock tests guide you whether you are ready for the exam or not. If you are scoring 85% + in the mock tests do go take the exam.

Quiz of the Day | December 3, 2010

2010-12-03T07:20:00.003+05:30

What will be the output when you compile and execute the following program?
Choose one answer.
a. Prints true
b. Prints false
c. Prints 9
d. Prints 2
e. Compiler error : Incorrect declaration of main method
f. None of these

Solution : Choice F is the correct answer.

The code does not compile because the && operator works only with boolean operands. If both operands are true, the && operator returns true and false in all the other cases. In this case, integer operands arepassed to the && operator, so the code does not compile. Since the code does not compile, choices A to D are incorrect.

Choice E is incorrect because there is nothing wrong with the declaration of the main method. The modifiers public and static can appear in any order. Also, the main method takes a String[] as the argument.

Source : "Facebook Community"

How to obtain from where a Class is loaded

2010-11-22T06:29:00.004+05:30

Source : "rgagnon.com"

Quiz of the Day | November 7, 2010

2010-11-07T03:22:00.003+05:30

What will happen when you attempt to compile and run the above code? (Assume that the code is compiled and run with assertions enabled.)

a. It will print odd and even numbers from 0 to 9 correctly (0 even and 1 odd).
b. It will print odd and even numbers from 0 to 9 incorrectly (0 odd and 1 even).
c. Compilation error at line 9.
d. Compilation error at line 10.
e. It will result in an infinite loop.

Solution : Choice A is the correct answer.

The code will compile successfully and it will print odd and even numbers from 0 to 9 correctly, without reversing even and odd.

Let's look at the execution of the code. The assert statement at line 9 asserts that "i%2==0" must be true, which will be true for all the even numbers in the range 0 to 9 (0, 2, 4, 6, and 8), and false for all the odd numbers in the range 0 to 9 (1, 3, 5, 7, and 9). When the assert statement is evaluated to true, the second expression on the right hand side of the colon is not evaluated. On the other hand, when the assert statement is evaluated to false, the expression on the right hand side of the colon is evaluated and an AssertionError is thrown.

When the for loop starts with i=0, the assert condition at line 9 is evaluated to true, hence the other expression i-- is not evaluated, the value of i (0 here) is printed at line 10. Next, i is incremented to 1 in the next iteration of the for loop. The assert condition at line 9 is false in this case, hence the expression i--is evaluated (i becomes 0) and an AssertionError is thrown. The print statement at line 10 is not executed in this case. The catch statement at line 12 catches this error and the print statement at line 14 increments i with ++i and prints its value (which is 1 in this case). The same process is repeated for all the numbers, thus effectively printing all the even and odd number correctly.

The key here lies in understanding when the right-hand side expression of an assert statement gets evaluated. It gets evaluated *only* when the boolean left-hand side expression is evaluated to false. Hence, the loop will not result in an infinite loop.

Source : "Facebook community"

Converting a 2d array of ints to char and string in Java

2010-11-06T13:02:00.003+05:30

Question : How can i convert the ints in a 2d array into chars, and strings?

If i copy ints to a char array i just get the ascii code.

For example

public int a[5][5]

//some code

public String b[5][5] = public int a[5][5]

Answer : Quite frankly, the easiest approach would simply leave your array as-is... and convert int values toString's when you use them:

Integer.toString(a[5][5]);

Alternatively, you could start with a String[][] array in the first place, and simply convert your intvalues to String when adding them:

a[5][5] = new String(myInt);

If you really do need to convert an array of type int[][] to one of type String[][], you would have to do so manually with a two-layer for() loop:

String[][] converted = new String[a.length][];
for(int index = 0; index < a.length; index++) {
    converted[index] = new String[a[index].length];
    for(int subIndex = 0; subIndex < a[index].length; subIndex++){
        converted[index][subIndex] = Integer.toString(a[index][subIndex]);
    }
}

All three of these approaches would work equally well for conversion to type char rather thanString.

Source : Stack-Overflow

Quiz of the Day | November 6, 2010

2010-11-06T01:20:00.006+05:30

What value is printed out by executing the above code?

a. 2.7
b. 1.7
c. 0.0
d. -1.0

Solution : Choice A is the correct answer.

In Java, all parameters are passed by value. In case of primitives, the copy of the variable is passed, while in case of object references, it's the copy of the reference that is passed.

When the argument is a primitive type, pass-by-value means that the method can change the value of the passed argument (in the method scope) but, the called method cannot change the value of the variable in the calling method.

When the argument is of reference type, pass-by-value means that the method cannot change the object reference, but can invoke the object's methods and modify the accessible variables within the object.

In the example above, d is passed as value, hence the change done in the doMinus() method doesn't reflect on d outside the doMinus() method. Thus, the value printed is 2.7

Source : "Facebook community"

Quiz of the Day | November 5, 2010 [2]

2010-11-05T17:03:00.003+05:30

What will be printed on standard output if the following class is executed using the command "java Test 1 two 3" ?

a. 1
b. two
c. NumberFormatException
d. ArrayIndexOutOfBoundsException
e. Code does not compile

Solution : Choice C is the correct answer.

In Java, command line arguments are stored in the args array which is an argument to the main method. The index of the args array starts with 0 and the first command line argument is the word after the classname. Thus, args[0] will be 1 and args[1] will be "two".

The parseInt() method of the Integer class parses the String argument to the int type. The String passed to the parseInt() method should have only digits, with an exception that it can start with '-' to indicate a negative number. Otherwise, NumberFormatException will be thrown. Thus, when "two" is passed to the parseInt() method, NumberFormatException will be thrown.

Please note that there is nothing wrong with the definition of main, the static word can come after or before public keyword.

Source : "Facebook community"

Quiz of the Day | November 5, 2010

2010-11-05T16:54:00.005+05:30

What will be the result of compiling the following programs and executing it using the following command - java Child?

a. Prints 9
b. Compiler error at line 5
c. Compiler error at line 6
d. None of the above

Solution : Choice C is the correct answer.

You cannot access the protected variable in the Parent class from the Child class using the parent class reference. The Child class does inherit the variable x, but it can be accessed only by an object reference of the Child class. There is no error at line 5. It is legal to refer to a class as packagename.classname even if the package is already imported. So choice B is incorrect.

Source : "Facebook community"

Quiz of the Day | November 4, 2010

2010-11-04T01:54:00.003+05:30

Given the code below, which access modifiers (public, protected, or private) can legally be placed before the myMethod() method on line 3, if no other changes are made to the code? If line 3 is left as it is, which keywords can legally be placed before the myMethod method on line 8?

a. private or nothing (default) on line 3. Nothing (default) or protected or public on line 8.
b. public or protected on line 3. private or nothing (default) on line 8.
c. Nothing (default) or protected or public on line 3. private or nothing (default) on line 8.
d. public on line 3 and private on line8.

Solution : Choice A is the correct answer.

The basic principle is that a method cannot be overridden to be more private. Since the method is being overridden to be friendly (default access / no modifier), it can only be private or friendly in the superclass. Secondly, if the method in superclass is left as it is (i.e., friendly access), the method in subclass can be friendly, protected, or public.

Source : "Facebook community"

Quiz of the Day | November 3, 2010

2010-11-03T10:04:00.005+05:30

What will be the result of running the following code?
a.) The output: Value is - Hello
b.) The output: Value is - Hello world
c.) A compiler error
d.) No output
e.) An exception

Solution : Choice B is the correct answer.

Since the OR operator used here is not the short-circuit operator (which is "||"), both operands are evaluated even though the first operanditself is true which guarantees that the whole condition is true. Thus the value of the StringBuffer instance s after the evaluation of the boolean condition is "Hello world" and hence choice B is correct.

Please note here that if we had used "||" operator instead of "|", the correct answer would have been choice A, because in that case the right-hand side operand wouldn't have been evaluated as the left-hand side operand would have been true.

Source : "Facebook community"

Quiz of the Day | November 2, 2010

2010-11-03T09:59:00.002+05:30

What will happen when we try to compile the following code?

a. The compiler objects to line 3 comparing an Object with an array.
b. The compiler objects to line 5 casting an Object to an array of int primitives.
c. The compiler objects to line 11 comparing an Object to an array of Objects.
d. It compiles without error.

Solution : Choice D is the correct answer.

The "instanceof" operator tests the class of an object at runtime. It returns true if the type of the left-hand argument is the same as, or is some subtype of, the class or interface specified by the right-hand operand. Arrays are also objects, so they can be referred to by variables of type Object. Hence comparing Object type to array using instanceof is allowed. So choices A, B and C are incorrect.

Source : "Facebook community"

Quiz of the Day | November 1, 2010

2010-11-01T02:06:00.001+05:30

Which of the following statements about the following code fragment are true?

a.) The code compiles successfully and displays "Test".
b.) Changing the code at line 13 to "public void print(int x)" will allow the code to compile correctly.
c.) The code fails to compile. The compiler complains about duplicate methods.
d.) Changing the return type on line 13 from 'void' to 'int' will allow the code to compile correctly.

Solution : Choices B and C are the correct answers.

The code appears to be attempting to overload the print() method.

However, the only differentiating feature between the methods is the static keyword. This is insufficient for overloading. Therefore, choice C is correct and choice A is incorrect because the code fails to compile due to duplicate methods.

Choice B is correct because the methods are different overloaded versions of the print() methods.

Choice D is incorrect because the return parameters are not sufficient to differentiate between the overloaded methods.

More about overloading is available at http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.4.9

Source : "Facebook community"

Quiz of the Day | Oct 31, 2010

2010-10-31T02:03:00.001+05:30

How many objects will be eligible for garbage collection after the execution of line 9 in the following code?
a.) 8
b.) 14
c.) 15
d.) 16

Solution : This code creates 16 objects of type Double. Out of which, 15 Double objects are created by the iterations of the nested for loops at lines 6 and 7, and one more Double object is created at line 5. The very first iteration of the loop makes the object created at line 5 eligible for garbage collection. With each iteration of the loop, a new object is created and assigned to 'x', and the old (or previously created) object becomes eligible for garbage collection. Only the most recently created object (for i=4 and j=2) is not eligible for garbage collection.

Thus, out of the created 16 objects (including the one created at line 5), a total of 15 objects have become eligible for garbage collection after the execution of line 9.

Actually, as explained in the earlier paragraph, each iteration of the loop (line 8) makes the previously created object eligible for garbage collection. Thus, by the time both nested loops finish their execution (before execution of line 9), a total of 15 objects have become eligible for garbage collection. The execution of line 9 itself does not affect garbage collection in any way. Want to know more?

You can read more about garbage collection at -
http://java.sun.com/docs/books/performance/1st_edition/html/JPAppGC.fm.html
http://www.developer.com/tech/article.php/628881

Source : "Facebook community"

Quiz of the Day | Oct 30, 2010

2010-10-30T19:37:00.003+05:30

Which of the following statements are true about the relationships between the following classes?
a.) A Bar is a Baz
b.) A Foo has a Bar
c.) A Baz is a Foo
d.) A Foo is a Baz
e.) A Baz has a Bar

Solution : Choices B, C, and E are the correct answers. An instance of the Baz class is also an instance of the class Foo since the Baz class extends the Foo class. So choice C is correct.

A Baz has a Bar, since instances of the Baz class contain an instance of the Bar class by reference. So choice E is correct.

A Foo has a Baz, since instances of the Foo class contain an instance of the Baz class by reference. Since a Foo has a Baz, which in turn has a Bar, a Foo has a Bar. So choice B is also correct.

Choice A is incorrect because Bar does not extend Baz. Choice D is also incorrect because Foo does not extend Baz either. Refer http://cnx.rice.edu/content/m11709/latest/ for more details.

Source : "Facebook community"

Quiz of the Day | Oct 29, 2010

2010-10-29T18:11:00.006+05:30

Which of the following statements are true?

a. As soon as the reference count for an object reaches zero, it will be immediately garbage collected.
b. The finalize() method will not be invoked more than once by the JVM on the same object.
c. The finalize() method cannot be overloaded.
d. The garbage collection implementation is JVM-dependent.
e. If the finalize() method is overridden, a call to the super class's finalize() method is inserted automatically by the compiler.

Solution : Choices B and D are the correct answers.

As specified by the Java API documentation, the finalize() method is never invoked more than once by a Java virtual machine for any given object. Also, the garbage collection indeed is implementation-dependent. This is what the Java Virtual Machine Specification (JVMS) has to say about memory management -

"The heap is created on virtual machine start-up. Heap storage for objects is reclaimed by an automatic storage management system (known as a garbage collector); objects are never explicitly deallocated. The Java virtual machine assumes no particular type of automatic storage management system, and the storage management technique may be chosen according to the implementor's system requirements."

Choice A is incorrect because when the reference count for an object reaches zero, it becomes eligible for garbage collection but that *does not* necessarily mean that it will be immediately garbage collected.

It is perfectly legal to overload the finalize() method like any other method. However, the JVM will always invoke the default, no arguments finalize() method. Hence choice C is incorrect.

Choice E is incorrect because if you override the finalize() method, you must explicitly call the superclass' finalize() method. The compiler *does not* automatically insert this call. Want to know more?

You can read more about garbage collection at -http://java.sun.com/docs/books/performance/1st_edition/html/JPAppGC.fm.html
Also, the API documentation of the Object class contains the necessary information about the finalize() method -
http://java.sun.com/j2se/1.4/docs/api/java/lang/Object.html

Source : "Facebook community"