Code in Java

Java Program to Find Whether the given words are Anagram or Not

2015-07-19T17:59:00.002+05:30

Anagrams as you might already know, are the words or phrase formed by rearranging the letters of another word. For example: angel and glean or stain and satin.

Well, my description of what the anagrams are ends here as this is not an English grammar tutorial site. What I am more interested in writing out a piece of code to which we can pass the words and can get know whether the words were anagram or not. Well, this is what the solo purpose of this tutorial at least. May be you'd asked such a question somewhere someday, may be in some interview or some coding test, so I just thought to post this here.

So, how do we proceed? Java is such a powerful programming language that using the provided library methods, you might be able to do this in no more than couple of lines of code. Great if you can! But having faced enough number of interviews to assure you of that, the interviewer in most cases, are not that interested in knowing how good you're at memorizing the method and class names but how quickly your brain can find out a solution to the given problem and your approach. So, the chances are that the Java programming interview questions that you'd be asked would expect you to solve the problem without relying much upon the library methods.

Well, we'll do it both ways and we'll just take two words as the input to our method. You can easily extend the code to include more. (var-args might be of some help!)

Using the library methods

This just makes it ridiculously easy! We will be just reading the given strings, sorting them using Arrays.sort() and then comparing the sorted strings. If the sorted strings are equal then the words were anagrams. Simple! Because the anagrams as already stated are the words formed by rearranging the words in hand.

Without using the library methods

Without using the library methods also does not make it any less simpler. We can just first read the two strings, check for their same lengths, take one string character by character and search the other for each characters. And if all characters are found from one string are found in another then the two strings are anagrams because they were of same length.

So, enough of the text, now the program!

Java program to check whether the two strings are anagram or not

import java.util.Arrays;
import java.util.Scanner;

public class AnagramDemo {

 // method to check for the anagrams using built-in methods
 public static boolean isAnagram(String str1, String str2) {

  char[] charArr1 = str1.toCharArray();
  char[] charArr2 = str2.toCharArray();

  // performing sorting of string
  Arrays.sort(charArr1);
  Arrays.sort(charArr2);

  return Arrays.equals(charArr1, charArr2);
 }

 // method to check for the anagrams without using library methods
 public static boolean isAnagramManual(String str1, String str2) {
  // if length itself not equal, return false.
  if (str1.length() != str2.length())
   return false;
  // else do the brainstorming!
  boolean anagram = true;

  for (int i = 0; i < str1.length(); i++) {
   if (str2.indexOf(str1.charAt(i)) == -1)
    anagram = false;
  }

  return anagram;
 }

 public static void main(String[] args) {

  System.out.println("First string");
  Scanner sc = new Scanner(System.in);
  String str1 = sc.nextLine();
  System.out.println("Second string");
  String str2 = sc.nextLine();
  System.out.println("Using library methods:-");
  if (isAnagram(str1, str2))
   System.out.println(str1 + " and " + str2 + " are anagrams!");
  else
   System.out.println(str1 + " and " + str2 + " are NOT anagrams!");

  System.out.println("WITHOUT USING LIBRARY METHODS");
  if (isAnagramManual(str1, str2))
   System.out.println("ANAGRAMS");
  else
   System.out.println("NOT ANAGRAMS");

 }

}

I hope that you find it useful. In case you find any mistakes or the better way of doing it, please write in comments.
In case you have any other Java related question or problem that you want me to write code for, please let me know in comments or mail me.

Program to check if Least Significant Bit for a number is set or not

2015-06-27T19:10:00.002+05:30

In Binary number representation of a number, the rightmost bit (or digit) is called the Least Significant Bit (LSB) and the leftmost bit is called the Most Significant Bit (MSB). As we know while converting a binary representation of a number back to its decimal system representation, we calculate the decimal representation by multiplying the LSB by 2⁰ and then increasing the power of 2 from 0 by 1 on each bit as we go from LSB to MSB.
For example: Suppose we have a binary number: 11001
It's decimal equivalent will be: 1*2⁴ + 1*2³ + 0*2² + 0*2¹ + 1*2⁰ = 25
Let us take another example:
Binary number: 11100
It's decimal equivalent will be: 1*2⁴ + 1*2³ + 1*2² + 0*2¹ + 0*2⁰ = 28

Thing to note from the above discussion

Sometimes in the interviews you do not get the questions directly and to even understand the question properly, you need to have a careful look at the question statement.

Suppose, like in this case, you are asked to write a program to check if the Least Significant Bit of a number is set or not (And you can not make use of the % and / operators.

Here in this question, if you did not get what the interviewer is expecting from you, you might end up wasting a lot of time calculating the binary equivalent of the number and then manually checking the value of its LSB. But thankfully, this is not what this questions expects you to do. Let us go back to the first section of the post where we discussed in brief about the binary to decimal conversions. The one and only thing I wanted you to notice from the above discussion is that, for even numbers, the LSB is not set and for odd, the LSB is always set.

Now understanding this simple logic can save you a lot of efforts in your interviews and coding competitions. Now you would have understood why the examiner has denied you the use of '%' and '/' operators. So, you are basically assigned a challenge of finding whether a given number is odd or even without using the '%' and '/' operators.

There might be many approaches to do that, I will just implement only one in the below Java program method. The method will simply take the input number and return true or false based on whether the LSB is set or not.

public boolean isLSBSet(int number) {

  String num = Integer.toString( number );
  int lastDigit = num.length() - 1;
  //Only for odd numbers, the Least Significant Bit will be set.
  if (num.charAt(lastDigit) == '1' || num.charAt(lastDigit) == '3'
    || num.charAt(lastDigit) == '5' || num.charAt(lastDigit) == '7'
    || num.charAt(lastDigit) == '9')
   return true;
  else
   return false;
 }

We thank DJ Spiess for his tip! The whole above code now can be reduced to one line.

return (number ^ (number - 1)) == 1;

So, Kudos! We now know How to check if number is even or odd without using the modulus '%' or '/' operator. Keep sharing such tips to the community and help us all learn Java in a simple and fun way! :)

Java Program to find occurrence of a pattern in String with (and without) String methods

2015-06-27T18:21:00.003+05:30

Finding patterns in the String : The problem description

Today, I will be writing a program to print the occurrence of a String pattern in the given input String in two ways: one using the String substring() method (which will make the task very easy) and second without using the substring() method (similar but need to do the substring calculation and comparison manually).

The scenario is we have an input String of characters and we want to find the occurrences of some pattern (which will of course be the substring of the input string).

For example:-

Input String: "CODEINJAVATUTORIALSFORJAVABEGINNERS"

Patter String: "JAVA"

Occurrence: 2

Logic for finding the pattern occurrences in the String

We will go for the simple and straightforward logic. And that is, we will be finding all the sub-strings of length equal to the length of the pattern we are looking for. And then from those list of sub-strings, we will pick sub-strings one by one and compare it against the patter string. Whenever the match happens, we will increment the occurrence count. So, the main task here seems to be just finding all the sub-strings of length L equal to the length of pattern string. The rest part is just comparison with the pattern and counting the occurrences.

Using String substring() method

Using the String utility method substring() for finding the sub-strings makes this task extremely easy and straightforward. Below is the method that takes the input string and pattern string and return the number of occurrences of pattern in input string.

public int countOccurenceOfPattern(String input, String pattern) {
  int inputLength = input.length();
  int patternLength = pattern.length();
  int occurrence = 0;

  // Using String methods. In this case we'll need only substring()
  for (int i = 0; i < (inputLength - patternLength); i++) {
   if ((input.substring(i, i + patternLength)).equals(pattern))
    occurrence++;
  }

  return occurrence;
 }

Without using the substring() method

Well, here is when we will have to do a bit of logic building and do the things manually. Well this doesn't complicate the code much and is still very straightforward. We will be creating the substrings of length L equal to length of pattern manually iterating through the two loops and comparing the each substring with the pattern string. Below is the previous method re-written to achieve the same objective without using the substring() method.

public int countOccurenceOfPattern(String input, String pattern) {
  int inputLength = input.length();
  int patternLength = pattern.length();
  int occurrence = 0;

  // Without using substring()
  // In that we will be required to do a bit of logic building ourself.
  String temp = "";

  for (int i = 0; i < (inputLength - patternLength); i++) {
   temp = "";
   for (int j = i; j < (i + patternLength); j++) {
    temp = temp + Character.toString(input.charAt(j));
   }
   if (temp.equals(pattern))
    occurrence++;
  }

  return occurrence;
 }

Circular Shifting of elements in Arrays - Java program to shift array elements circularly

2015-06-24T21:20:00.001+05:30

What do we mean by shifting the elements of an array

Many a times in our programs, we need to shift the elements of our array either to the left or to the right. For example, while dynamically adding any new element in between the existing elements of an array, we will be right shifting the elements after the inserted position. Similarly, we will do a left shift of the elements when we remove an element.

Circular Shifting in Arrays - Right Circular Shift and Left Circular Shift

As we are now familiar with what we mean by shifting the array elements, the term circular adds a little more complexity to the otherwise a simple process of shifting elements of arrays to the left or right.

Left Circular Shifting of Array Elements: In left circular shifting of array elements by N positions, we will take the first N elements starting from the left most side of the array and start placing them from the rear of the array in the same order as we took out them from the front of array.

for example:

Suppose we have an input array like this:

10, 20, 30, 40, 50

After left circular shift by 2 positions, the array would become:-

30, 40, 50, 10, 20

Right Circular Shifting of Array Elements: The Right circular shifting of arrays is exactly opposite to that of the Left circular shifting. In this we will be taking out the N elements from the rear of the array and will be inserting them to the front of the array. The below example would help us to understand this much easily.

for example:-

We have an input array: 10, 20, 30, 40, 50

After right circular shift by 2 positions: 40, 50, 10, 20, 30

Java program to implement left circular shifting and right circular shifting of array elements

public class CodeInJava{

 public static void main(String[] args) {
  CodeInJava obj = new CodeInJava();
  //input array
  int[] inputArray = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
  
  obj.printArray( inputArray );
  
  //circular left shifted array by 2 positions. 
  int[] leftShiftedArray = obj.circularShiftSingle( inputArray, 2, false );
  
  obj.printArray(leftShiftedArray);
  
  //circular right shifted array by 2 positions
  int[] rightShiftedArray = obj.circularShiftSingle( inputArray, 2, true );
  
  obj.printArray( rightShiftedArray );
  
 }
 
 public int[] circularShiftSingle(int[] array, int shift, boolean right) {
  int[] array2 = new int[shift];
  if(right) {
   for (int i = 0;i < shift;i++)
    array2[i] = array[array.length - shift + i];
   System.arraycopy(array, 0, array, shift, array.length - shift);
   for (int i = 0;i < shift;i++) {
    array[i] = array2[i];
   }
  }
  else {
   for (int i = 0;i < shift;i++)
    array2[i] = array[i];
   System.arraycopy(array, shift, array, 0, array.length - shift);
   for (int i = array.length - shift; i < array.length; i++) {
    array[i] = array2[shift + i - array.length];
   }
  }
  return array;
 }
 
 //utility method just to display the elements of an array
 private void printArray(int[] array) {
  for (int element:array)
   System.out.print(element + ", ");
  System.out.println();
 }

}

Output:

10, 20, 30, 40, 50, 60, 70, 80, 90, 100,

30, 40, 50, 60, 70, 80, 90, 100, 10, 20,

10, 20, 30, 40, 50, 60, 70, 80, 90, 100,

The first line shows the input as it is.

The second line shows the input after circular left shifting by 2 positions.

The third line shows the array in 2nd line after circular right shifting by 2 positions.

So, we shifted 2 positions left and then we shift 2 positions right on the same input array and we will get the same input array back in line 3rd.

Java Program to print only the unique elements from the String array without using Collections

2015-06-24T19:41:00.001+05:30

In Java, you'll rarely be writing a program without using the arrays. As the arrays put no limitations on what type of elements you can put in them or do not provide any means to check for the duplicates, there might be some scenarios wherein you might need only the distinct elements from the array instead of all its elements.
Suppose we have an array of Strings and we need only the distinct strings out from that array. Obviously, the same task can be done conveniently using Collections API but there might be cases where you'll be just better off not requiring to put any overhead of using the Collections classes such as Sets in this case. Or if this does not convince you, knowing how to do this without using the Collections will still be worth learning if you're going to appear in some interviews or for some coding competitions. As I have repeatedly mentioned in my posts that Java programming questions on Strings are among the hot favorite for interviewers, so I'll be posting many more such String based java programming questions in my future posts.

Java Program to find only distinct elements of String Array without using Collections


public class CodeInJava {

 public static void main(String[] args) {
  //Input array
  String str[] = {"Java","Struts2","Java","Spring3","C++","Python","Java"};
  
  //Creating new array to store only the unique elements
  String[] uniqueArray = new String[str.length];
  
  //copying the first element directly to uniqueArray
  uniqueArray[0] = str[0];
  
  //Counter to keep track of the index to put next value at in uniqueArray
  int counter = 1;
  
  boolean flag = false;
  for(int i = 1;i < str.length;i++) {
   flag = false;
   for (int j = 0;j < i;j++) {
    if(uniqueArray[j] == null)
     j=i;
    //comparing in case-insensitive manner.
    //In case you need to find unique in case sensitive manner, use equals() only
    else if( str[i].equalsIgnoreCase( uniqueArray[j] ) )
     flag = true;
   }
   if( !flag ) {
    uniqueArray[counter] = str[i];
    counter++;
   }
  }
  
  //Printing the unique elements. Counter stores the number of unique elements in the original array.
  for (int i = 0; i < counter; i++) 
   System.out.println(uniqueArray[i]);

 }

}

Java program to convert String into Integer without Integer.parseInt()

2015-06-23T12:12:00.002+05:30

Although Java SDK provides you with convenient methods to convert the compatible data from one data types to another, but sometimes in interviews and other coding competitions you are also supposed to know how to do those conversions without those built-in methods provided by Java SDK itself. In one such case, one of the most common thing in your java code is to convert the string representation of any number back to native int or Integer data type in Java. Although there is a simple method Integer.parseInt(String num) that you can use to get the string num in int format, but in case you need to do that stuff manually, this post will show you how to do that.

Logic building and approach

We will be first reading the string backwards character by character looking for the digit characters only. Till we keep getting the digit characters, we will use those to formulate our number by using the digits and increment the factor by 10 in each step.

We are simply ignoring the non-digit characters here or otherwise in we want, we can convert each character to its number representation, but I don't think that's what we need. And finally, we will also take care of negative numbers as well. For that we will check for the "-" in the very first place in the String input, if it is "-" then we will make the number negative.

Java Program to Manually convert string to int without Integer.parseInt() method

Below is the simple Java method that takes a String str as input and return the int representation of its digits only.

For example:-

"1263*67%" will return 126367

"a76dsb6l7" will return 76617

"-78fjkd7439" will return -78439

"289289" will return 289289

public int stringToInt(String str) {
  int number = 0, factor = 1; 
  boolean negative = false;
  for (int i = str.length() - 1;i >= 0;i--) {
   //check if the very first character has '-', then the result must be negative
   if((i == 0) && (str.charAt(i) == '-')) {
    negative = true;
    continue;
   }
   //if the string has any non-number characters, continue with the next character ignoring the current one
   else if("0123456789".indexOf( str.charAt(i) ) == -1) {
    continue;
   }
   number+= (str.charAt(i) - '0') * factor;
   factor*= 10;
  }
  if(negative)
   return -number;
  return number;
 }

There might be many other methods to achieve this as well. For instance, we could have used the static methods of Character class such as isDigit() to check for whether the characters are digits or not. In fact, this whole program could have been done using the static methods of Character class. You may want to give it a try!

Java program to reverse a string word by word

2015-06-20T21:04:00.000+05:30

Program to reverse a String word by word in Java

String based programming questions are among the most asked questions in the Java interviews for the freshers as well as the experienced Java developers and Software engineers. And reversing a string word by word or characters by characters is very likely to be asked in any Java technical interview. In this post, I will be writing a program for the former i.e. for reversing a Java String word by word.

For example:-

Input String: Code In Java

Output String: Java In Code

There might be many approaches for solving this and you may want to choose based on your liking and its simplicity.

Below is a Java program to reverse a String word by word.

public class ReverseString {

 public static void main(String[] args) {
  //Input String
  String str = "Code in Java - Programming in Java Tutorials for beginners";
  
  //Approach 1 : Using String Array
  String[] reverseArray = str.split(" ");
  
  //String to store the reversed string
  String reverseString1 = "";
  
  //reading each word from the reverseArray and creating the reverseString1
  for(int i = reverseArray.length-1;i >= 0;i--)
  {
   reverseString1+= reverseArray[i] + " ";   
  }
  
  System.out.println( reverseString1 );
  
  //Approach 2: Using StringBuilder
  StringBuilder revString = new StringBuilder();
  
  //String to store the reversed string
  String reverseString2 = "";
  
  for (int i = 0; i< reverseArray.length;i++) {
   revString.append( reverseArray[ reverseArray.length - 1 - i ]).append(' ');
  }
  
  //creating String from the StringBuilder object
  reverseString2 = revString.toString();
  
  System.out.println( reverseString2 );
  
  //There might be many other approaches to this as well. Please share the same in comments.
 }

}

Java Program to Format the String to Phone Number Format with dashes

2015-06-14T23:58:00.003+05:30

Java Program to format the given input string to phone number format with dashes

Below is a coding challenge question I recently attempted in some competition. Suppose we are given a string that might contain some undesired characters apart from the digits. We are supposed to convert it into a phone number format with dashes with grouping of 3 digits. In case, only 4 digits are left in the end after grouping other numbers in a group of 3, then the numbers should be grouped in 2. In case 5 digits are left in the end, the digits should be grouped in 3 and 2.

For example: "89437438843921" should be converted into 894-374-388-439-21

and "7836473097338" should be converted into 783-647-309-73-38

and "483974937434" should be converted into 483-974-937-434

And in case there are some alphabets and special characters, we should ignore them and remove from the output string.

Java Program to convert a given String to Phone number format with dashes:-

public class PhoneNumberFormat {
 
 public String formatToPhoneNumberFormat(String S) {
  StringBuilder filterOutJunk = new StringBuilder();
  int digitCount = 0;
  for (int i = 0;i < S.length();i++) {
   if("0123456789".indexOf(S.charAt(i))==-1)
    continue;
   digitCount++;
   filterOutJunk.append(S.charAt(i));
  }
  //if the input contains less than 2 digits, return null
  if(digitCount < 2)
   return null;
  //now the filterOutJunk contains only the clean string containing digits only
  filterOutJunk = new StringBuilder(filterOutJunk.toString());
  //start inserting the dashes after 3rd digit
  int insertDashes = 3;
  while (insertDashes < filterOutJunk.length())
  {
   //insert dashes after 3 digits
      filterOutJunk.insert(insertDashes, "-");
      //but if we are left with only four digits in the end
      //enter dashes after 2 digits (2 + 1 = 3 for the fact that dash also takes one place)
      if(insertDashes == (filterOutJunk.length() - 5))
       insertDashes = insertDashes + 3;
      else
       insertDashes = insertDashes + 4;
  }
  return filterOutJunk.toString();
 }
 
 public static void main(String[] args) {
  PhoneNumberFormat t = new PhoneNumberFormat();
  //Hard coded input for testing purpose. Take it from user.
  //Check for maximum input length of 100.
  String input = "47983"; 
  String formatted = t.formatToPhoneNumberFormat(input);
  System.out.println(formatted);
 }

}

Please try out this on your own first and then refer this in case you get stuck somewhere. This will help you learn. And in case you find out this code not working properly for any given input string, please do let me know in comments.

Java Exception Handling Tutorial-2

2012-12-19T01:38:00.001+05:30

Advanced Exception Handling in Java Tutorial with Example Programs

This post is in continuation of the previous Java Exception Handling Tutorial. After reading the previous post, the basic concept of using try and catch block should be clear. The other thing that is to be noted in context of using try and catch block is that try block can not exist alone, it must be followed by at least one catch block or finally block. The next step that you should learn about is the nesting of try blocks.

Nesting Try Blocks

The try statement can be nested. That is, a try statement can be inside the block of another try. Each time a try statement is entered, the context of that exception is pushed on the stack. If an inner try statement does not have a catch handler for a particular exception, the stack is unwound and the next try statement's catch handlers are inspected for a match. This continues until one of the catch statements succeeds, or until all of the nested try statements are exhausted. If no catch statement matches, then the Java run-time system will handle the exception.
Below example program demonstates how the nesting of try blocks work in Java exception handling.

Program to demonstate nesting of try blocks in Java Exception Handling

import java.util.*;
class DemoExceptionHandling2{
 public static void main(String [] args){
  Scanner s = new Scanner(System.in);
  int a = 1;
  int b = 1;
  int n = 0;
  int c[] = {1};
  //enter value of B as zero to cause a divide by zero exception in Outer try block
  System.out.println("Enter value of B:");
  b=s.nextInt();
  //Outer Try Block
  try{
   System.out.println("Outer Try Block Entered!");
   System.out.println("A/B="+a/b);  //divide by zero exception occurs here if b=0
   System.out.println("No Exception has occured in Outer try block!!");
   //Inner Try Block
   try{
    System.out.println("Nested Try Block Entered!");
    System.out.println("Enter 0 to run normal, 1 or greater to cause ArrayIndexOutOfBoundsException:");
    n = s.nextInt();
    System.out.println("C= "+c[n]);
    System.out.println("Enter value of B again:"); //enter zero to cause divide by zero Arithmetic Exception
    b = s.nextInt();
    System.out.println("a/b ="+a/b);
    System.out.println("No exception in inner try block has occured!!");
   }
   //inner catch block will only catch Array Index Out of Bounds Exceptions
   catch(ArrayIndexOutOfBoundsException e){
    System.out.println("Exception caught in Inner catch block : "+e);
   }

  }
  //This outer catch block will catch Arithmetic Exceptions
  catch(ArithmeticException ae){
   System.out.println("Exception Caught in Outer Catch Block 1: "+ae);
  }
  //This outer catch block will catch all the uncaught Exceptions
  catch(Exception eo){
   System.out.println("Exception Caught in Outer Block 2: "+eo);
  }
  //finally block will execute every time
  finally{
   System.out.println("The code inside the finally block is executing...");
  }
  System.out.println("Line after try-catch-finally Block!");
 }
}

The above program simply demonstrates the concept of nesting try blocks in Java. I encourage you to try it yourself by adjusting the different values and notice how and which exception is being caught where. But anyway, I would like to brief the results of the above program. When you make b=0, the exception in outer try block occurs and then the whole try block including the nested inner block is skipped and the exception is caught by first catch block (which is coded to catch ArithmeticException such as divide by zero) and then the finally block is executed followed by any code afterwards. But when you make b=1, outer try block works fine and inner try block is reached. If you make n>1, then it causes ArrayIndexOutOfBoundsException to occur, which is caught by the inner catch block. But if ArrayIndexOutOfBoundsException is not caused but a Divide by Zero exception in inner try block, then there is no corresponding catch block to catch that ArithmeticException and in that case that exception is caught in the outer catch block.

Difference between throw and throws

throw: throw keyword is used to explicitly throw any exception in your java program, till now all the exceptions that were caught by the catch block, were thrown by the Java run-time system. The general form of using throw keyword is:
throw ThrowableInstance;
Here the ThrowableInstance is an object of Throwable class or any of its subclasses. Let me remind you that Throwable is the base class of Exception class, which in turn is the base class of all the exceptions. One can use the new keyword to create the object of Throwable class.

throw new IllegalAccessException;

throw new IllegalAccessException("demo exception");

The above two options of throwing occurs due to the presence of at least two constructors of Throwable and all of its sub-classes. One without the parameter and one with string parameter describing that exception.
throws: throws is used with methods to signal that the method might cause some exception (s) that it is not equipped to handle, so that the calling method can do the exception handling arrangements while calling that function. If a method is capable of causing an exception that it does not handle, then it must specify the type of exceptions it can cause using throws keyword followed by the comma separated list of all the exception classes that it is suspected to cause. Any method that calls such method with throws declaration must provide means of handling all those exceptions by either enclosing the function call in try-catch-finally block or rethrowing those exceptions to its calling methods, if any.
The general form of using throws is like:
type method-name(parameter-list) throws exception-list
for example:

double anyMethod(double x, double y) throws IOException, FileNotFoundException, IllegalAccessException{//method-body}

Defining and Using your own Exceptions

Java also enables you to create your own exceptions to handle situations specific to your applications. Although most of the errors are handled by Java's built-in exceptions, but being able to create your own exceptions might come handly in some particular situations depending on your application. Creating your own Exceptions is very easy, you just need to define a subclass of Exception class and specify the constructors and the other methods you want to add to specify your particular exception scenario. This new built class does not inherit any functions from Exception class as Exception class does not even define any methods of its own; it inherits from Throwable class.
Below is the simple example to demonstate how to define your own exceptions in java.

class MyException extends Exception{
 private int i;
 MyException(int x){
  i=x;
 }
}
public class MyCustomException{
 static void displayNumber(int x) throws MyException{
  System.out.println("called displayNumber("+x+")");
  if(x>15)
  {
   throw new MyException(x);
  }
  System.out.println("MyException did not occur!");
 }
  public static void main(String args[]){
   try{
    displayNumber(5);
    displayNumber(25);
   }catch(MyException me){
    System.out.println("MyException Caught: "+me);
   }
  }
 }

Exceptions handling in java is a great tool which you can handle to ensure the smooth and uninterrupted execution of your program. The above tutorials are still the basic level tutorials meant for beginners in Java only. Once you get over with these, you can try more advanced use of the Exceptions Handling in java.
If you have any questions regarding this and the previous tutorials, you can write in the comments below.

Java Exception Handling Tutorial

2012-12-03T01:00:00.004+05:30

Exception Handling in Java Tutorial with Example Programs

Exceptions in Java - What are Java Exceptions?

A Java Exception is an abnormal condition that arises during the execution of a program and also called a run-time error. An exception in Java signals the unusual or catastrophic situations that can arise.
Examples of Java Exceptions are:

Incorrect user input such as division by zero
File that needs to be opened not found
Network connection problem

Types of Java Exceptions

Like anything else in this world, Exceptions can also be categorized! Based on whether or not you are required to handle the exception, there are two types of exceptions: Checked and Unchecked Exceptions.

Exception Class Heirarchy

Checked Exceptions: These are the type of exceptions for which the compiler checks to ensure that your code is prepared for handling such exceptions. These are the exceptions that you can expect to occur frequently and you must handle them in your code. The conditions that generate such exceptions are generally outside the control of your program and they can occur in a correct program. But you can anticipate them and thus you must write code to deal with them. Programmatically, checked exceptions are the instances of the Exception class or one of its subclasses, excluding RuntimeException subtree.

Unchecked Exceptions: The compiler does not check for such type of exceptions. Unchecked Exceptions comprise of run time exceptions (of type RuntimeException or its subclasses) and errors (of type Error or its subclasses). Runtime Exceptions occur due to program bugs and include exceptions such as division by zero and invalid array indexing. You can not recover from an unchecked exception and you are not required to handle such type of exceptions either, but still you can do so if you want. ArithmeticException class is an example of unchecked exception. Errors are the exceptions that are not expected to be caught under normal circumstances by your program. They are used by the Java run time environment to indicate errors related to run time environment itself. Stack Overflow is an example of error.

Exception Handling in Java

We will come across five keywords while learning Exception Handling in java: try, catch, finally, throw and throws. To handle the java exceptions, try and catch are the two major keywords that you will be using. Simply enclose the code that is expected to produce some kind of exception by try block and catch that exception in the catch block immediately following the try block. Whenever an exception occurs, an object is created and thrown containing the information about that exception. To catch this thrown block, you must specify the catch block(s). The catch block receives this thrown object as its parameter and then you can specify the code to handle this exception.
Java Program Example to illustrate the Exception Handling in java.

  class DemoExceptionHandling{
 public static void main(String args[]){
  int a=5;
  int b=0;
  System.out.println("We are about to enter in a try block!...");
  try {
   System.out.println("a/b="+a/b);
   System.out.println("This will not be printed.");
   } catch (ArithmeticException ae){
    System.out.println("Exception Caught: "+ae.getMessage());
    }
  System.out.println("Statement after catch block.");
 }
}

In the above example ArithmeticException thrown by the try block is caught by the catch block which is coded to receive ArithmeticException object. Now what if, if the catch block would contain some other parameter type than the thrown exception? In that case, the exception thrown will not be caught due to the absence of appropriate catch block and the program will terminate without executing any other line from the method. You may create as many catch blocks as you want, each for receiving the particular types of exception. Alternatively, you can create a catch block to receive all types of exceptions by configuring it to receive the object of class Exception itself, which is the super class of all the exceptions.
One major benefit of having an error signalled by an exception is that it separates the code that deals with errors from the code that is executed when things are moving along smoothly. Another positive aspect of exceptions is that they provide a way of enforcing a response to particular errors.

Use of finally Block in Java Exception Handling

In case the exception could not be caught, the program will terminate and no further lines of code will be executed after the line where the exception occurred. But in some situation you may desire to execute some lines of code irrespective of the fact whether or not the catch block corresponding to the try block has been caught. In that you should use finally block. The finally block is executed almost always even if the exception is not caught.
Example Java Program to illustrate the use of finally block

class DemoExceptionHandling{
 public static void main(String args[]){
  int a=5;
  int b=0;
  System.out.println("We are about to enter in a try block!...");
  try {
   System.out.println("a/b="+a/b);
   System.out.println("This will not be printed.");
   } catch (ArrayIndexOutOfBoundException oe){
    System.out.println("Exception Caught: "+oe.getMessage());
    }
    finally{
     System.out.println("Finally block will execute always!");
    }
  System.out.println("Statement after catch and finally block.");
 }
}

In the above example, the finally block will be executed always, whether the exception is caught or not. If the exception is caught by the appropriate catch block, then the execution of the program will continue after the finally block also. But if the exception in try block has not been caught by the appropriate catch block, then the control will be transferred to the finally block and after that the program will terminate.

What happens when exception handler is not provided?

You must be thinking what would happen, if exception handling is avoided in a java program. When you do not provide provisions of exception handling, java does it for you by default. Whenever an exception occurs, the java run-time detects it and creates an exception object and throws it. Now since there are no exception handlers created, the thrown exception object will be caught by the default handler provided by the java run time. The default handler displays a string describing the exception, prints a stack trace from the point at which the exception occurred, and terminates the program. So, in order to avoid this immature termination of program, exception handling is used.
Exceptions should not be overused at all. The reason for this is that dealing with exceptions involves quite a lot of processing overhead, so if your program is handling exceptions a lot of the time it will be a lot slower than it needs to be. For Example, a user entering incorrect input to your program for instance is a normal event and should be handled without recourse to exceptions.
This post is just for the basic introduction of the Exceptions in Java and Handling Exceptions in Java. To know little more about Exception Handling in Java such as nested try blocks, difference between throw and throws and creating your own exception classes, Read Java Exception Handling Tutorial-2.

Core Java Project Desktop Application : Cab Invoice Generator

2012-10-02T15:52:00.001+05:30

Invoice Generator Core Java Desktop Application Using Swing

Description

Invoice Generator is a Core Java Project for generating the invoices for a Rent-a-Cab company. It takes the details of the invoices via a form and then calculates the various subtotals, service taxes, rates applicable etc on the basis of choices entered and then generates the invoice for the user.

It also allows you to Add, Edit or Remove the cabs, define and modify the various rent packages for customers, billing schemes etc. The company owner can change each and every detail about how the invoice will be calculated and generated.

I have used the MS-Access database for simplicity as this project is intentionally for the beginners in java programming. If you want to run the project, you must have to create the DSN with the name "invoice" and point it to the database that is provided with this project. Alternatively you can create the DSN with any name but in that case you will have to change the DSN name in each occurence of DSN in the project.

I have left out the various checks for type of data that can be entered in the fields and other validation checks in almost every forms. So you can download the project source code and do it yourself.

I will also additional functionalities like PRINT the invoice to this project in a week or two as and when I will get time. But for now it is a good beginner level Core Java Project for you to look at and understand the basic concepts and try some modification of your own. Like I have built it for a Rent-a-Cab company but you can modify it to accomodate the needs of some other firm.

I could not proof-check every form and details of the project due to time constrainsts as I built this project for a friend of mine as he needed the same for submitting in some institute. So, I want you to take a look at it and ask your queries and suggestions about what could I have done better in this (except the validation checks, that I have left out intentionally due to lack of time).

Snapshots


Main Form Page


Settings for Cabs


Settings Page for Rent Packages


Generated Invoice

Download Project With Source Code and Database:

Download Cab Invoice Generator Jar File

Download Associated Database File

Download All-in-One Zip File with Source Code and Database

More Core Java Projects

JDBC : Connection to databases

2012-06-23T00:11:00.001+05:30

What is JDBC?

JDBC is an API that encapsulates the low−level calls needed for database access and interaction into one common interface. Both the Java Development Kit (JDK) and Java Runtime Environment (JRE) contain the API as part of the standard distribution. The API’s interfaces and classes reside in the java.sql and javax.sql packages. The standard components are packaged in java.sql while the enterprise elements are in javax.sql.

Steps for building a simple JDBC application

1. Import Packages

2. Register JDBC Driver

3. Open a Connection

4. Execute a Query

5. Extract data from Result Set

6. Clean-Up Environment

A Simple Program to demonstrate the JDBC application working:

This is a simple program that retrieves and displays the values of particular columns from the Employees table stored in the database.


//STEP 1. Import packages

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.Date;
import java.sql.SQLException;

public class FirstQuery {
   public static void main(String[] args) {
   Connection conn = null;     //Define Connection variable
   try{                        //Begin standard error handling

//STEP 2: Register JDBC driver

     String driver = "oracle.jdbc.driver.OracleDriver"; //for oracle database
     Class.forName(driver);
//STEP 3: Open a connection
     System.out.println("Connecting to database...");
     String jdbcUrl = "jdbc:oracle:thin:@localhost:1521:XE";
/* this url will be different for the different databases */
     String user = "username"; 
     String password = "password";
     conn = DriverManager.getConnection(jdbcUrl,user,password);

//STEP 4: Execute a query

     Statement stmt = conn.createStatement();
     String sql;
     sql = "SELECT SSN, Name, Salary, Hiredate FROM Employees";
     ResultSet rs = stmt.executeQuery(sql);

//STEP 5: Extract data from result set

     while(rs.next()){
//Retrieve by column name

     int ssn= rs.getInt("ssn");
     String name = rs.getString("name");
//Retrieve by column index as an example

     double salary = rs.getDouble(3);
     Date date = rs.getDate(4);

//Display values

     System.out.print("SSN: " + ssn);
     System.out.print(", Name: " + name);
     System.out.print(", Salary: $" + salary);
     System.out.println(", HireDate: " + date);
   }

//STEP 6: Clean−up environment

  rs.close();
  stmt.close();
  conn.close();
 }catch(SQLException se){

//Handle errors for JDBC

 se.printStackTrace();
 }catch(Exception e){

//Handle errors for Class.forName

 e.printStackTrace();
 }finally{

//finally block used to close resources

 try{
       if(conn!=null)
           conn.close();

   }catch(SQLException se){
       se.printStackTrace();
   }
 }
 System.out.println("Finished!");
}      //end of main
}

The Expected Output after you have created the databse with some values of these columns:

Connecting to database...

SSN: 111111111, Name: Harish, Salary: $5000.55, HireDate: 2010−09−16

SSN: 419876541, Name: Vikas, Salary: $1500.75, HireDate: 2011−03−05

SSN: 312654987, Name: Aman, Salary: $2000.95, HireDate: 2012−01−11

SSN: 123456789, Name: Sumit, Salary: $3080.05, HireDate: 2009−09−07

SSN: 987654321, Name: John, Salary: $4351.27, HireDate: 2011−12−31

Finished!

The values that you will store in the databse will be shown.

This was just a simple demonstration program to just give some idea about the JDBC connectivity.
In the later posts, the more detailed and programs for entering the data in the databse, updating and creating the database using either Statement or preparedStatement objects.

New Core Java Projects Added

2011-08-19T02:20:00.001+05:30

I have collected some of the best Core Java Projects for you to work upon.
There are six Core Java Projects synopsis cum project report that will help you develop the project. All the projects can be developed in Java SE. You may use any IDE of your choice but I would prefer Netbeans 7 as I find it more comfortable and easy to use even though it eats up more memory!
I have studied all the project reports in detail but I haven't developed them all. I have only collected them from the different sources and have put them together for your convenience.
If you have any difficulties in developing on the following given projects, you may contact me.
Your feedback is important so do join this blog and forget not to write in your ideas, suggestions and problems as comments.
Core Java Projects (Synopsis)

(***Difficulty Level is High and You will also be required additional Hardware Resources to build these projects)

Packages in Java

2011-07-27T16:05:00.001+05:30

Java Packages

What is a Java Package

A package is a collection of classes and the related functions within the classes.

Packages are container for classes that are used to keep the class name space compartmentalized. For example, you can create a class named “Abc” in your package “mypackage” without being concerned to it being colliding with other class also named as “Abc”. And then you can write your own methods in it for the later use by you or anyone that uses that package.

Packages are stored in a hierarchical way. That means you can create a package inside a package. This is like a box contained inside a box.

Now how to create a package? Well this is simple, you just need to use the keyword ‘package’ followed by the name of the package.

This is the general form of the package statement:

package mypackage;

Here package is the keyword for creating the package called mypackage.

Java uses file system directories to store packages. For example, the .class files for any classes you declare to be part of mypackage must be stored in a directory called mypackage. Remember that case is significant, and the directory name must match the package name exactly.

You can create a hierarchy of packages. To do so, simply separate each package name from the one above it by use of a period. The general form of a multileveled package statement is shown here:

package pkg1[.pkg2[.pkg3]];

A package hierarchy must be reflected in the file system of your Java development system. For example, a package declared as

package java.awt.image

needs to be stored in java/awt/image, java\awt\image, or java:awt:image on your UNIX, Windows, or Macintosh file system, respectively. Be sure to choose your package names carefully. You cannot rename a package without renaming the directory in which the classes are stored.

How to Use the package

Now after you have created the package, you would want to use it in your program. For that you must import the package in your program.

Suppose if you created the above package mypackage, then you can import it by using import statement.

import mypackage.*;

The above import statement will import all the classes inside the mypackage package. If you want to import only specific class, you can import it by specifying the class name instead of *.

import mypackage.MyClass;

EXAMPLE PROGRAM

//creating the package
//save each class of the package in a separate file named as the name of the //class e.g. save this file as “Calculation.java”
package mypackage;
public class Calculation
{
            public int Add(int x, int y)
            {
                        return(x+y);
            }
            public float Add(float x, float y)
            {
                        return(x+y);
            }
            public int div(int x, int y)
            {
                        return(x/y);
            }
            public float div(float x, float y)
            {
                        return(x/y);
            }
}
Now Create another class in which you will be using this package.
//using my package
// save the file as “UsingPackage.java”
import mypackage.Calculation;
import java.util.*;
class UsingPackage
{
            public static void main(String args[])
            {
                        Scanner s = new Scanner(System.in);
                        Calculation c = new Calculation();
                        System.out.println("Enter two Numbers:");
                        int x = s.nextInt();
                        int y = s.nextInt();
                        System.out.println(c.Add(x,y));
                        System.out.println("Enter two Numbers:");
                        float a = s.nextFloat();
                        float b = s.nextFloat();
                        System.out.println(c.Add(a,b));
            }
}

ACCESS PROTECTION

The following table applies only to the members of the class. A class can only have two access modifiers : default and public.

	Private	Default	Protected	Public
Same Class	Yes	Yes	Yes	Yes
Same Package Subclass	No	Yes	Yes	Yes
Same package non-subclass	No	Yes	Yes	Yes
Different Package Subclass	No	No	Yes	Yes
Different package non-Subclass	No	No	No	Yes

We can alter the access protection of the members and the classes in the package according to the need.

Constructors in Java

2011-07-14T23:57:00.001+05:30

Constructors

A constructor initializes an object immediately upon creation. It has the same name as the class in which it resides and is syntactically similar to a method. Once defined, the constructor is automatically called immediately after the object is created, before the new operator completes. Constructors look a little strange because they have no return type, not even void. This is because the implicit return type of a class’ constructor is the class type itself. It is the constructor’s job to initialize the internal state of an object so that the code creating an instance will have a fully initialized, usable object immediately.

EXAMPLE:

/* Here, Box uses a constructor to initialize the dimensions of a box.

class Box {

double width;

double height;

double depth;

// This is the constructor for Box.

Box() {

System.out.println("Constructing Box");

width = 10;

height = 10;

depth = 10;

}

// compute and return volume

double volume() {

return width * height * depth;

}

class BoxDemo6 {

public static void main(String args[]) {

// declare, allocate, and initialize Box objects

Box mybox1 = new Box();

Box mybox2 = new Box();

double vol;

// get volume of first box

vol = mybox1.volume();

System.out.println("Volume is " + vol);

// get volume of second box

vol = mybox2.volume();

System.out.println("Volume is " + vol);

}

OUTPUT:

Constructing Box

Volume is 1000.0

Parameterized Constructors

While the Box( ) constructor in the preceding example does initialize a Box object, it is not very useful—all boxes have the same dimensions. What is needed is a way to construct Box objects of various dimensions. The easy solution is to add parameters to the constructor. As you can probably guess, this makes them much more useful. For example, the following version of Box defines a parameterized constructor which sets the dimensions of a box as specified by those parameters. Pay special attention to how Box objects are created.

EXAMPLE:

/* Here, Box uses a parameterized constructor to initialize the dimensions of a box.

class Box {

double width;

double height;

double depth;

THE JAVA LANGUAGE

// This is the constructor for Box.

Box(double w, double h, double d) {

width = w;

height = h;

depth = d;

}

// compute and return volume

double volume() {

return width * height * depth;

}

class BoxDemo7 {

public static void main(String args[]) {

// declare, allocate, and initialize Box objects

Box mybox1 = new Box(10, 20, 15);

Box mybox2 = new Box(3, 6, 9);

double vol;

// get volume of first box

vol = mybox1.volume();

System.out.println("Volume is " + vol);

// get volume of second box

vol = mybox2.volume();

System.out.println("Volume is " + vol);

}

The output from this program is shown here:

Volume is 3000.0

Volume is 162.0

Using the Command Line Arguements

2011-07-14T23:52:00.001+05:30

Command Line Arguements
Sometimes, there might arise a need for a program to run it in accordance with the specific input provided at the time of running the program. Command line arguements serve this purpose in java by allowing the user to input some values at the time of running the java program.
As the name implies, this feature is for only the programs which run on/from the command line interface. The input provided at the command line along with the instruction of running the java application, is stored in a String array and can be used in the program to make changes in the way program will behave.
Syntax:
They are directly passed to the main() of the java program.
public static void main(String args[])
the args[] is an array of strings, and it is called as command line arguements because the value of args[] can only be given at the run time from the command line. But wonder how to use it in your program?
This is simple, take a loot at the demo code that makes use of the command line arguements.

//Demo Code for using the Command Line Arguements in your program

class CommandLineArgs

{

public static void main(String args[])

{

int sum = 0;

for(int i=0;i<args.length;i++)

{

sum = sum + Integer.parseInt(args[i]);

}

System.out.println("Sum is "+sum);

}

}

You might want to read or download the chapter wise Java SE tutorials.

Structure of Java Program

2011-07-14T23:33:00.001+05:30

Source File Layout/ Java Program Structure

A Java Technology source file takes the following form:

[<package_declaration>]

<import_declaration>*

<class_declaration>+

NOTE: - The plus (+) indicates one or more. To be meaningful, a source file must contain at least one class definition.

1. The order of the items is important. That is, any import statements must precede all class declarations and, if you use a package declaration, it must precede both the classes and imports.

2. The name of the source file must be the same as the name of the public class declaration in that file. A source file can include more than one class declaration, but only one class can be declared public.

3. If a source file contains no public class declarations, then the name of the source file is not restricted. However, it is good practice to have one source file for every class declaration and the name of the file is identical to the name of the class.

Declaring Classes in Java

The Java Technology class declaration takes the following form:

<modifier>* class <class_name> {

<attribute_declaration>*

<constructor_declaration>*

<method_declaration>*

}

Example:

public class Vehicle

{

private int x,y; //declaring methods

public void setValues(int a, int b) //declaring methods

{

x = a;

y = b;

}

Declaring Attributes

The declaration of an object attribute takes the following form:

<modifier>* <type> <name> [= <initial_value>];

Example:

public class Foo

{

private int x;

private float y = 1000.0F;

private String name = “Harish Sharma”;

}

Declaring Methods

The method declaration in Java is similar to that used in C and C++.

The declaration takes the following basic form:

<modifier>* <return_type> <name> (<arguement>*)

{

<statement>*;

}

Example:

public class Dog

{

private int weight;

public int getWeight()

{

return weight;

}

public void setWeight(int newWeight)

{

If(newWeight>0)

{

Weight = newWeight;

}

Accessing Object Members

Example

public class AccessObjects

{

public static void main(String arg[])

{

Dog d = new Dog();

System.out.println("Dog d's weight is"+ d.getWeight());

d.setWeight(45);

System.out.println("Dog d's weight is"+ d.getWeight());

d.setWeight(-45);

System.out.println("Dog d's weight is"+ d.getWeight());

}

First Java Program

2011-07-09T14:07:00.001+05:30

Getting Started with Java: Here is a simple Java program that just displays a custom message on screen say “Hello this is my first Java Program”.

I first write the program and then discuss the various parts of it.

Code:

//first java program

class FirstJava

{

public static void main(String args[])

{

System.out.println("This is my first java program");

}

Compile the code:

first save the program with the name "FirstJava.java".If you wrote the code using notepad then save the filename is double quotes otherwise the program will be saved as FirstJava.java.txt which will be a txt file not a .java file.

Then go to command prompt by typing cmd in the Run dialog box or in the search bar.

Now at the command prompt:

Change the directory using cd command to the directory where you saved the file FirstJava.java

then type javac FirstJava.java

if the code contains errors the list of errors will be displayed, otherwise the command prompt will appear.

It means that the code has been compiled and it contains no errors.

You can also check that a file FirstJava.class has been created in the directory where you saved your program. This is because when you compile the code the Java compiler converts the source code into intermediate "Byte Code" which is saved in a .class file.

And this Byte code can be run on any platform thus facilitating the Platform In-dependency feature of Java.

Running the code:

To Run the code:

type java FirstJava at the command from the same directory where you have saved the file.

The output will appear as:

This is my first java program

Naming Conventions to Follow in Java

For Naming Methods:

Follow Camel Rule : The rule is that function name must begin with a small letter and if the function name consists of two or more words, then the first letter of every other word must begin with a Capital letter.

Examples of some method names:

display()

displayAge()

showMyName()

createVariableLengthArray()

For Naming Classes:

Follow Pascal Rule : The rule is that a class name must begin with a capital letter and if the name of the class contains two or more than two words then first letter of every word must be capital.

Examples of some class names:

Demo

MyDate

Addition

For Naming Variables:

Variable naming follows the same rule as methods naming.

But name for a constant variable must be in all capitals.

Installing the JDK and Setting the Environment Variables

2011-07-09T13:26:00.001+05:30

Want to get started with Java and set up your computer for Java, then this post is for you only. Every Java programmer I know starts off with writing the Java programs in any text editor such Notepad and compile and run it using Java tools on command line. But to make sure all goes well, you must need to install Java properly and Set up the environment variables for Java.

Installing the Java 2 SDK (or JDK)

If you don’t have the Java 2 SDK(Software Development Kit) or simply JDK installed on your system, Follow these steps to install the JDK on your system:
1. Download the latest Java SDK version from the Oracle official site.

2. Now browse the jdk setup file on your computer and double-click on the setup file to open it. Now follow the on screen instructions to install the JDK on your system. JRE is also installed along with the JDK.
3. You can check if the JDK has been correctly installed or not by looking in the C:\Program Files\Java\. You must see the jdk1.6.0_26 folder and jre1.6.0_26 folder in it. 1.6.0_26 is the version of the jdk and it can be different depending upon which version did you download from the site.
4. Now you have successfully installed the JDK, the next step is to set the Environment Variables for your Java (JDK).

Setting up the Environment Variables

1. Right click on My Computer and click on “Properties”. Then in
the Computer Properties window, on the left panel click on the “Advanced System Settings”, this will open the new “System Properties window.”
2. Go to Advanced tab and right down the window, click on the “Environment Variables”.
3. Now in the Environment Variables box, either you can set the variables for local user or for System variables. Local variables will only work for the current user and the System Variables will work for all the users.
4. Now for creating the variable for System Variables so that all the user can use the jdk, Find the “Path” variable in the list and click on Edit button.
5. Now place the ; followed by the path to the bin folder inside your jdk. For example ";C:\Program Files\Java\jdk1.6.0_07\bin "
6. For local variable, you must create the PATH variable by pressing “New” button and setting its value as " ;C:\Program Files\Java\jdk1.6.0_07\bin; "
7. Now in the local variables, create a New variable “classpath” and set its value to “.” i.e. a single dot.
8. Now you are done and all ready to use the jdk for creating the java applications.

Need for Setting Environment Variables

Need for setting PATH variable:

Setting the PATH variable enables the user to use the java tools given in the bin folder from any directory on your system.
If you don’t set this variable, you can only access those tools from the bin directory only.

Need for Setting the CLASSPATH variable:

Setting the CLASSPATH variable enables your class definition to be found across all the directories. If you don’t set this variable, the program source will compile fine but will show the exception at run time that class definition not found.
So by setting the classpath variable to “.” ensures that current working directory is included in the list to found the class definition.

Now, as you have set up the environment variables, you are all set to write your first java program.
After that I recommend you to go through the Java Tutorials PDF books one by one and improve your java programming skills.
Once you start gaining confidence, you can test your skills by preparing Core Java Projects listed here with the project synopses.

Java Myths- Fact versus Fiction

2011-05-03T15:32:00.002+05:30

Inside Java :
Java myths - fact versus fiction

There are so many myths about Java. This month, I'll look at some of the more persistent ones, and try to dispel any doubt.

Fiction :
Applets can read your hard-drive, and delete         files

Fact :
Any attempt by an applet to access local files will throw a         SecurityException. If uncaught, the applet will crash, but no file         access will occur.

The only exception to this rule is for digitally signed         applets, which may be granted additional privileges. Your browser will         display a dialog box, asking you if you want to accept the identity of         the applet author. Choose no if unsure, and you'll always be safe.

Fiction :
Java requires a web browser. Java only runs in         a web browser.

Fact :
Java code comes in many forms. The most familiar to users is the         applet, which runs inside a web browser. However, this is only the tip         of the iceberg.

Java applications can be run just like normal programs.         By installing a JVM from vendors like Sun or Microsoft, you gain the         ability to run Java programs. It's just like normal programs, such as         Microsoft Word.

Java servlets run inside a web server. Servlets are a         replacement for CGI scripts, and Active Server Pages (ASP). Servlets are         actually really fast, and can be more efficient than CGI scripts.

Fiction :
Java is a hundred times slower than C, so you         shouldn't ever use it for "serious" programming.

Fact :

The original Java Virtual Machines were slow, so slow that a         comparable C application was about twenty times faster. The gap between         C/C++ and Java is growing smaller though, thanks to better designed JVMs,         and Just-In-Time (JIT) compilers that convert bytecode to native machine         code at runtime.

Much of the cause for speed concerns is actually over         applet loading - large applets take a long time to load initially.         Thankfully, Java applications and servlets are not subject to such slow         loading times. 

Fiction :
There's no point learning any language other         than Java - it will dominate the software industry and put C++         programmers out of work.

Fact :
There are many languages suited to very narrow and specific tasks         (such as artificial intelligence) that Java will never overcome. While         it is true that Java has had phenomenal growth, and significantly eroded         the role of C++, it still has a long way to go. Java excels in         portability and Internet support - but C++ still offers better         performance and the ability to interact with the operating system.

Fiction :
Applets are inherently unreliable. The         differences between Netscape and Internet Explorer make it impossible to         write stable applets.

Fact :
The problems with the behavior of applets running under browsers is         due to the different JVMs - between browsers and browser versions. These         differences can be frustrating for developers and users. There are often         workarounds though, and applets should always be tested with a variety         of browsers.

The optimal solution is to use a single JVM, which will         be used across all browsers. Sound like fantasy? Sun Microsystems, the         creators of Java, have come up with the Java Plug-in. The Java Plug-in         bypasses the browser's JVM, and uses its own. This means that users with         the plug-in installed can always rely on uniform performance, regardless         of which browser they use. For more information, see the  Java Plug-in         page.

Top 10 Errors Java Programmers Make

2011-04-30T22:48:00.002+05:30

Top Ten Errors Java Programmers Make

(How to spot them. How to fix/prevent them.)

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 uses both,         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 are passing 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!

Comparison: C++ and Java

2011-04-30T22:41:00.003+05:30

Comparing C++ and Java

                          Many developers already have                 experience with an object-oriented programming language like                 C++. As you make the transition to Java, you will encounter many                 differences, despite some strong similarities. In this excerpt from "Thinking in Java", Bruce                 Eckel highlights the important differences that C++ programmers                 should be aware of.
             
         

As a C++ programmer, you already have the basic  idea of object-oriented programming, and the syntax of Java no doubt  looks familiar to you. This makes sense since Java was derived from C++.         However, there are a surprising number of differences between  C++ and Java.

These differences are intended to be significant  improvements, and if you understand the differences you'll see why Java  is such a beneficial programming language. This         article takes you through the important features that  distinguish Java from C++.

The biggest potential stumbling block is speed: interpreted Java runs in the range of 20 times slower than C. Nothing prevents the Java language from being compiled and there are just-in-time compilers appearing at this writing that offer significant speed-ups. It is not inconceivable that full native compilers will appear for the more popular platforms, but without those there are classes of problems that will be insoluble with Java because of the speed issue.
Java has both kinds of comments like C++ does.
Everything must be in a class. There are no global functions or global data. If you want the equivalent of globals, make static methods and static data within a class. There are no structs or enumerations or unions, only classes.
All method definitions are defined in the body of the class. Thus, in C++ it would look like all the functions are inlined, but they’re not (inlines are noted later).
Class definitions are roughly the same form in Java as in C++, but there’s no closing semicolon. There are no class declarations of the form class foo, only class definitions.
```
class aType {
    void aMethod( ) { /* method body */ }
}
```
There’s no scope resolution operator :: in Java. Java uses the dot for everything, but can get away with it since you can define elements only within a class. Even the method definitions must always occur within a class, so there is no need for scope resolution there either. One place where you’ll notice the difference is in the calling of static methods: you say ClassName.methodName( );. In addition, package names are established using the dot, and to perform a kind of C++ #include you use the import keyword. For example: import java.awt.*;. (#include does not directly map to import, but it has a similar feel to it).
Java, like C++, has primitive types for efficient access. In Java, these are boolean, char, byte, short, int, long, float, and double. All the primitive types have specified sizes that are machine independent for portability. (This must have some impact on performance, varying with the machine.) Type-checking and type requirements are much tighter in Java. For example:

1. Conditional expressions can be only boolean, not integral.

2. The result of an expression like X + Y must be used; you can’t just say "X + Y" for the side effect.
The char type uses the international 16-bit Unicode character set, so it can automatically represent most national characters.
Static quoted strings are automatically converted into String objects. There is no independent static character array string like there is in C and C++.
Java adds the triple right shift >>> to act as a "logical" right shift by inserting zeroes at the top end; the >> inserts the sign bit as it shifts (an "arithmetic" shift).
Although they look similar, arrays have a very different structure and behavior in Java than they do in C++. There’s a read-only length member that tells you how big the array is, and run-time checking throws an exception if you go out of bounds. All arrays are created on the heap, and you can assign one array to another (the array handle is simply copied). The array identifier is a first-class object, with all of the methods commonly available to all other objects.
All objects of non-primitive types can be created only via new. There’s no equivalent to creating non-primitive objects "on the stack" as in C++. All primitive types can be created only on the stack, without new. There are wrapper classes for all primitive classes so that you can create equivalent heap-based objects via new. (Arrays of primitives are a special case: they can be allocated via aggregate initialization as in C++, or by using new.)
No forward declarations are necessary in Java. If you want to use a class or a method before it is defined, you simply use it – the compiler ensures that the appropriate definition exists. Thus you don’t have any of the forward referencing issues that you do in C++.
Java has no preprocessor. If you want to use classes in another library, you say import and the name of the library. There are no preprocessor-like macros.
Java uses packages in place of namespaces. The name issue is taken care of by putting everything into a class and by using a facility called "packages" that performs the equivalent namespace breakup for class names. Packages also collect library components under a single library name. You simply import a package and the compiler takes care of the rest.
Object handles defined as class members are automatically initialized to null. Initialization of primitive class data members is guaranteed in Java; if you don’t explicitly initialize them they get a default value (a zero or equivalent). You can initialize them explicitly, either when you define them in the class or in the constructor. The syntax makes more sense than that for C++, and is consistent for static and non-static members alike. You don’t need to externally define storage for static members like you do in C++.
There are no Java pointers in the sense of C and C++. When you create an object with new, you get back a reference (which I’ve been calling a handle in this book). For example: String s = new String("howdy"); However, unlike C++ references that must be initialized when created and cannot be rebound to a different location, Java references don’t have to be bound at the point of creation. They can also be rebound at will, which eliminates part of the need for pointers. The other reason for pointers in C and C++ is to be able to point at any place in memory whatsoever (which makes them unsafe, which is why Java doesn’t support them). Pointers are often seen as an efficient way to move through an array of primitive variables; Java arrays allow you to do that in a safer fashion. The ultimate solution for pointer problems is native methods (discussed in Appendix A). Passing pointers to methods isn’t a problem since there are no global functions, only classes, and you can pass references to objects.
The Java language promoters initially said "No pointers!", but when many programmers questioned how you can work without pointers, the promoters began saying "Restricted pointers." You can make up your mind whether it’s "really" a pointer or not. In any event, there’s no pointer arithmetic.
Java has constructors that are similar to constructors in C++. You get a default constructor if you don’t define one, and if you define a non-default constructor, there’s no automatic default constructor defined for you, just like in C++. There are no copy constructors, since all arguments are passed by reference.
There are no destructors in Java. There is no "scope" of a variable per se, to indicate when the object’s lifetime is ended – the lifetime of an object is determined instead by the garbage collector. There is a finalize( ) method that’s a member of each class, something like a C++ destructor, but finalize( ) is called by the garbage collector and is supposed to be responsible only for releasing "resources" (such as open files, sockets, ports, URLs, etc). If you need something done at a specific point, you must create a special method and call it, not rely upon finalize( ). Put another way, all objects in C++ will be (or rather, should be) destroyed, but not all objects in Java are garbage collected. Because Java doesn’t support destructors, you must be careful to create a cleanup method if it’s necessary and to explicitly call all the cleanup methods for the base class and member objects in your class.
Java has method overloading that works virtually identically to C++ function overloading.
Java does not support default arguments.
There’s no goto in Java. The one unconditional jump mechanism is the break label or continue label, which is used to jump out of the middle of multiply-nested loops.
Java uses a singly-rooted hierarchy, so all objects are ultimately inherited from the root class Object. In C++, you can start a new inheritance tree anywhere, so you end up with a forest of trees. In Java you get a single ultimate hierarchy. This can seem restrictive, but it gives a great deal of power since you know that every object is guaranteed to have at least the Object interface. C++ appears to be the only OO language that does not impose a singly rooted hierarchy.
Java has no templates or other implementation of parameterized types. There is a set of collections: Vector, Stack, and Hashtable that hold Object references, and through which you can satisfy your collection needs, but these collections are not designed for efficiency like the C++ Standard Template Library (STL). The new collections in Java 1.2 are more complete, but still don’t have the same kind of efficiency as template implementations would allow.
Garbage collection means memory leaks are much harder to cause in Java, but not impossible. (If you make native method calls that allocate storage, these are typically not tracked by the garbage collector.) However, many memory leaks and resouce leaks can be tracked to a badly written finalize( ) or to not releasing a resource at the end of the block where it is allocated (a place where a destructor would certainly come in handy). The garbage collector is a huge improvement over C++, and makes a lot of programming problems simply vanish. It might make Java unsuitable for solving a small subset of problems that cannot tolerate a garbage collector, but the advantage of a garbage collector seems to greatly outweigh this potential drawback.
Java has built-in multithreading support. There’s a Thread class that you inherit to create a new thread (you override the run( ) method). Mutual exclusion occurs at the level of objects using the synchronized keyword as a type qualifier for methods. Only one thread may use a synchronized method of a particular object at any one time. Put another way, when a synchronized method is entered, it first "locks" the object against any other synchronized method using that object and "unlocks" the object only upon exiting the method. There are no explicit locks; they happen automatically. You’re still responsible for implementing more sophisticated synchronization between threads by creating your own "monitor" class. Recursive synchronized methods work correctly. Time slicing is not guaranteed between equal priority threads.
Instead of controlling blocks of declarations like C++ does, the access specifiers (public, private, and protected) are placed on each definition for each member of a class. Without an explicit access specifier, an element defaults to "friendly," which means that it is accessible to other elements in the same package (equivalent to them all being C++ friends) but inaccessible outside the package. The class, and each method within the class, has an access specifier to determine whether it’s visible outside the file. Sometimes the private keyword is used less in Java because "friendly" access is often more useful than excluding access from other classes in the same package. (However, with multithreading the proper use of private is essential.) The Java protected keyword means "accessible to inheritors and to others in this package." There is no equivalent to the C++ protected keyword that means "accessible to inheritors only" (private protected used to do this, but the use of that keyword pair was removed).
Nested classes. In C++, nesting a class is an aid to name hiding and code organization (but C++ namespaces eliminate the need for name hiding). Java packaging provides the equivalence of namespaces, so that isn’t an issue. Java 1.1 has inner classes that look just like nested classes. However, an object of an inner class secretly keeps a handle to the object of the outer class that was involved in the creation of the inner class object. This means that the inner class object may access members of the outer class object without qualification, as if those members belonged directly to the inner class object. This provides a much more elegant solution to the problem of callbacks, solved with pointers to members in C++.
Because of inner classes described in the previous point, there are no pointers to members in Java.
No inline methods. The Java compiler might decide on its own to inline a method, but you don’t have much control over this. You can suggest inlining in Java by using the final keyword for a method. However, inline functions are only suggestions to the C++ compiler as well.
Inheritance in Java has the same effect as in C++, but the syntax is different. Java uses the extends keyword to indicate inheritance from a base class and the super keyword to specify methods to be called in the base class that have the same name as the method you’re in. (However, the super keyword in Java allows you to access methods only in the parent class, one level up in the hierarchy.) Base-class scoping in C++ allows you to access methods that are deeper in the hierarchy). The base-class constructor is also called using the super keyword. As mentioned before, all classes are ultimately automatically inherited from Object. There’s no explicit constructor initializer list like in C++, but the compiler forces you to perform all base-class initialization at the beginning of the constructor body and it won’t let you perform these later in the body. Member initialization is guaranteed through a combination of automatic initialization and exceptions for uninitialized object handles.
```
public class Foo extends Bar
{
   public Foo(String msg) {
      super(msg); // Calls base constructor
   }
   
   public baz(int i) { // Override
      super.baz(i); // Calls base method
   }
}
```
Inheritance in Java doesn’t change the protection level of the members in the base class. You cannot specify public, private, or protected inheritance in Java, as you can in C++. Also, overridden methods in a derived class cannot reduce the access of the method in the base class. For example, if a method is public in the base class and you override it, your overridden method must also be public (the compiler checks for this).
Java provides the interface keyword, which creates the equivalent of an abstract base class filled with abstract methods and with no data members. This makes a clear distinction between something designed to be just an interface and an extension of existing functionality via the extends keyword. It’s worth noting that the abstract keyword produces a similar effect in that you can’t create an object of that class. An abstract class may contain abstract methods (although it isn’t required to contain any), but it is also able to contain implementations, so it is restricted to single inheritance. Together with interfaces, this scheme prevents the need for some mechanism like virtual base classes in C++.

To create a version of the interface that can be instantiated, use the implements keyword, whose syntax looks like inheritance:
```
public interface Face {
   public void smile();
}

public class Baz extends Bar implements Face {
   public void smile( ) {
      System.out.println("a warm smile");
   }
}
```
There’s no virtual keyword in Java because all non-static methods always use dynamic binding. In Java, the programmer doesn’t have to decide whether to use dynamic binding. The reason virtual exists in C++ is so you can leave it off for a slight increase in efficiency when you’re tuning for performance (or, put another way, "If you don’t use it, you don’t pay for it"), which often results in confusion and unpleasant surprises. The final keyword provides some latitude for efficiency tuning – it tells the compiler that this method cannot be overridden, and thus that it may be statically bound (and made inline, thus using the equivalent of a C++ non-virtual call). These optimizations are up to the compiler.
Java doesn’t provide multiple inheritance (MI), at least not in the same sense that C++ does. Like protected, MI seems like a good idea but you know you need it only when you are face to face with a certain design problem. Since Java uses a singly-rooted hierarchy, you’ll probably run into fewer situations in which MI is necessary. The interface keyword takes care of combining multiple interfaces.
Run-time type identification functionality is quite similar to that in C++. To get information about handle X, you can say, for example:
X.getClass().getName();
To perform a type-safe downcast you say:
derived d = (derived)base;
just like an old-style C cast. The compiler automatically invokes the dynamic casting mechanism without requiring extra syntax. Although this doesn’t have the benefit of easy location of casts as in C++ "new casts," Java checks usage and throws exceptions so it won’t allow bad casts like C++ does.

Exception handling in Java is different because there are no destructors. A finally clause can be added to force execution of statements that perform necessary cleanup. All exceptions in Java are inherited from the base class Throwable, so you’re guaranteed a common interface.

public void f(Obj b) throws IOException {
   myresource mr = b.createResource();
   try {
      mr.UseResource();

   } catch (MyException e) {
      // handle my exception
   } catch (Throwable e) {
      // handle all other exceptions
   } finally {
      mr.dispose(); // special cleanup
   }
}

Exception specifications in Java are vastly superior to those in C++. Instead of the C++ approach of calling a function at run-time when the wrong exception is thrown, Java exception specifications are checked and enforced at compile-time. In addition, overridden methods must conform to the exception specification of the base-class version of that method: they can throw the specified exceptions or exceptions derived from those. This provides much more robust exception-handling code.
Java has method overloading, but no operator overloading. The String class does use the + and += operators to concatenate strings and String expressions use automatic type conversion, but that’s a special built-in case.
The const issues in C++ are avoided in Java by convention. You pass only handles to objects and local copies are never made for you automatically. If you want the equivalent of C++’s pass-by-value, you call clone( ) to produce a local copy of the argument (although the clone( ) mechanism is somewhat poorly designed – see Chapter 12). There’s no copy-constructor that’s automatically called.

To create a compile-time constant value, you say, for example:

static final int SIZE = 255; static final int BSIZE = 8 * SIZE;
Because of security issues, programming an "application" is quite different from programming an "applet." A significant issue is that an applet won’t let you write to disk, because that would allow a program downloaded from an unknown machine to trash your disk. This changes somewhat with Java 1.1 digital signing, which allows you to unequivocally know everyone that wrote all the programs that have special access to your system (one of which might have trashed your disk; you still have to figure out which one and what to do about it.). Java 1.2 also promises more power for applets
Since Java can be too restrictive in some cases, you could be prevented from doing important tasks such as directly accessing hardware. Java solves this with native methods that allow you to call a function written in another language (currently only C and C++ are supported). Thus, you can always solve a platform-specific problem (in a relatively non-portable fashion, but then that code is isolated). Applets cannot call native methods, only applications.
Java has built-in support for comment documentation, so the source code file can also contain its own documentation, which is stripped out and reformatted into HTML via a separate program. This is a boon for documentation maintenance and use.
Java contains standard libraries for solving specific tasks. C++ relies on non-standard third-party libraries. These tasks include (or will soon include):
- Networking
- Database Connection (via JDBC)
- Multithreading
- Distributed Objects (via RMI and CORBA)
- Compression
- Commerce
The availability and standard nature of these libraries allow for more rapid application development.
Java 1.1 includes the Java Beans standard, which is a way to create components that can be used in visual programming environments. This promotes visual components that can be used under all vendor’s development environments. Since you aren’t tied to a particular vendor’s design for visual components, this should result in greater selection and availability of components. In addition, the design for Java Beans is simpler for programmers to understand; vendor-specific component frameworks tend to involve a steeper learning curve.
If the access to a Java handle fails, an exception is thrown. This test doesn’t have to occur right before the use of a handle; the Java specification just says that the exception must somehow be thrown. Many C++ runtime systems can also throw exceptions for bad pointers.
Generally, Java is more robust, via:
- Object handles initialized to null (a keyword)
- Handles are always checked and exceptions are thrown for failures
- All array accesses are checked for bounds violations
- Automatic garbage collection prevents memory leaks
- Clean, relatively fool-proof exception handling
- Simple language support for multithreading
- Bytecode verification of network applets

The Inside Java: The Java Programming Language

2011-04-30T22:28:00.002+05:30

Inside Java :
The Java Programming Language

Java - an island of Indonesia, a         type of coffee, and a         programming language. Three very different meanings, each in         varying degrees         of importance. Most programmers, though, are interested in the Java         programming language. In just a few short years (since late 1995), Java has taken the         software community by storm. Its phenomenal success has made Java the         fastest growing programming language ever. There's plenty of hype about         Java, and what it can do. Many programmers, and end-users, are confused         about exactly what it is, and what Java offers.

Java is a revolutionary language

The properties that make Java so attractive are present         in other programming languages. Many languages are ideally suited for         certain types of applications, even more so than Java. But Java brings         all these properties together, in one language. This is a revolutionary         jump forward for the software industry.

Let's look at some of the properties in more detail: -

object-oriented
portable
multi-threaded
automatic garbage collection
secure
network and "Internet" aware
simplicity and ease-of-use

Object-oriented

Many older languages, like C and Pascal, were procedural         languages. Procedures (also called functions) were blocks of code that         were part of a module or application. Procedures passed parameters         (primitive data types like integers, characters, strings, and floating         point numbers). Code was treated separately to data. You had to pass         around data structures, and procedures could easily modify their         contents. This was a source of problems, as parts of a program could         have unforeseen effects in other parts. Tracking down which procedure         was at fault wasted a great deal of time and effort, particularly with         large programs.

In some procedural language, you could even obtain the         memory location of a data structure. Armed with this location, you could         read and write to the data at a later time, or accidentally overwrite         the contents.

Java is an object-oriented language. An         object-oriented language deals with objects. Objects contain         both data (member variables) and code (methods). Each object belongs to         a particular class, which is a blueprint describing the member         variables and methods an object offers. In Java, almost every variable         is an object of some type or another - even strings. Object-oriented         programming requires a different way of thinking, but is a better way to         design software than procedural programming.

There are many popular object-oriented languages         available today. Some like Smalltalk and Java are designed from  the         beginning to be object-oriented. Others, like C++, are partially  object-oriented, and partially procedural. In C++, you can still         overwrite the contents of data structures and objects, causing  the         application to crash. Thankfully, Java prohibits direct access  to memory         contents, leading to a more robust system.

Portable

Most programming languages are designed for a specific         operating system and processor architecture. When source code (the         instructions that make up a program) are compiled, it is converted to machine         code which can be executed only on one type of machine. This process         produces native code, which is extremely fast.

Another type of language is one that is interpreted.         Interpreted code is read by a software application (the interpreter),         which performs the specified actions. Interpreted code often doesn't         need to be compiled - it is translated as it is run. For this reason,         interpreted code is quite slow, but often portable across different         operating systems and processor architectures.

Java takes the best of both techniques. Java code is         compiled into a platform-neutral machine code, which is called Java bytecode.         A special type of interpreter, known as a Java Virtual Machine (JVM), reads the         bytecode, and processes it. Figure One shows a disassembly of a small Java         application. The bytecode, indicated by the arrow, is represented in text         form here, but when compiled it is represented as bytes to conserve         space.

Figure One - Bytecode disassembly for "HelloWorld"         

The approach Java takes offers some big advantages over         other interpreted languages. Firstly, the source code is protected from         view and modification - only the bytecode needs to be made available to         users. Secondly, security mechanisms can scan bytecode for signs of         modification or harmful code, complimenting the other security         mechanisms of Java. Most of all though, it means that Java code can be         compiled once, and run on any machine and operating system combination         that supports a Java Virtual Machine (JVM). Java can run on Unix,         Windows, Macintosh, and even the Palm Pilot. Java can even run inside a         web browser, or a web server. Being portable means that the application         only has to be written once - and can then execute on a wider range of         machines. This saves a lot of time, and money.

Multi-threaded

If you've ever written complex applications in C, or         PERL, you'll probably have come across the concept of multiple processes         before. An application can split itself into separate copies, which run         concurrently. Each copy replicates code and data, resulting in increased         memory consumption. Getting the copies to talk together can be complex,         and frustrating. Creating each process involves a call to the operating         system, which consumes extra CPU time as well.

A better model is to use multiple threads of execution,         referred to as threads for short. Threads can share data and         code, making it easier to share data between thread instances. They also         use less memory and CPU overhead. Some languages, like C++, have support         for threads, but they are complex to use. Java has support for multiple         threads of execution built right into the language. Threads require a         different way of thinking, but can be understood very quickly. Thread         support in Java is very simple to use, and the use of threads in         applications and applets is quite commonplace.

Automatic garbage collection

No, we're not talking about taking out the trash (though         a computer that could literally do that would be kind of neat). The term         garbage collection refers to the reclamation of unused memory space.         When applications create objects, the JVM allocates memory space for         their storage. When the object is no longer needed (no reference to the         object exists), the memory space can be reclaimed for later use. 

Languages like C++ force programmers to allocate and         deallocate memory for data and objects manually. This adds extra         complexity, but also causes another problem - memory leaks. When         programmers forget to deallocate memory, the amount of free memory         available is decreased. Programs that frequently create and destroy         objects may eventually find that there is no memory left. In Java, the         programmer is free from such worries, as the JVM will perform automatic         garbage collection of objects.

Secure

Security is a big issue with Java. Since Java applets         are downloaded remotely, and executed in a browser, security is of great         concern. We wouldn't want applets reading our personal documents,         deleting files, or causing mischief. At the API level, there are strong         security restrictions on file and network access for applets, as well as         support for digital signatures to verify the integrity of downloaded         code. At the bytecode level, checks are made for obvious hacks, such as         stack manipulation or invalid bytecode. The strong security mechanisms         in Java help to protect against inadvertent or intentional security         violations, but it is important to remember that no system is perfect.         The weakest link in the chain is the Java Virtual Machine on which it is         run - a JVM with known security weaknesses can be prone to attack. It is         also worth noting that while there have been a few identified weaknesses         in JVMs, they are rare, and usually fixed quickly. 

Network and "Internet" aware

Java was designed to be "Internet" aware, and         to support network programming. The Java API provides extensive network         support, from sockets and IP addresses, to URLs and HTTP. It's extremely         easy to write network applications in Java, and the code is completely         portable between platforms. In languages like C/C++, the networking code         must be re-written for different operating systems, and is usually more         complex. The networking support of Java saves a lot of         time, and effort.

Java also includes support for more exotic network         programming, such as remote-method invocation (RMI), CORBA and Jini.         These distributed systems technologies make Java an attractive choice         for large distributed systems.

Simplicity and ease-of-use

Java draws its roots from the C++ language. C++ is         widely used, and very popular. Yet it is regarded as a complex language,         with features like multiple-inheritance, templates and pointers that are         counter-productive. Java, on the other hand, is closer to a         "pure" object-oriented language. Access to memory pointers is         removed, and object-references are used instead. Support for multiple-inheritance         has been removed, which lends itself to clearer and simpler class         designs. The I/O and network library is very easy to use, and the Java         API provides developers with lots of time-saving code (such as         networking and data-structures).  After using Java for awhile, most         developers are reluctant to return to other languages, because of the         simplicity and elegance of Java.

Summary

Java provides developers with many advantages. While         most of these are present in other languages, Java combines all of these         together into one language. The rapid growth of Java has been nothing         short of phenomenal, and shows no signs (yet!) of slowing down. In next         month's column, I'll talk more about the heart of Java - the Java         Virtual Machine.

Java : Advantages, Scope and Future

2011-04-24T17:37:00.001+05:30

JAVA is an object oriented programming language and it was intended to serve as a new way to manage software complexity. Java refers to a number of computer software products and specifications from Sun Microsystems that together provide a system for developing application software and deploying it in a cross-platform environment. Java is used in a variety of computing platforms from embedded devices and mobile phones on the low end, to enterprise servers and supercomputers on the high end. Java is nearly everywhere in mobile phones, Web servers and enterprise applications, and while less common on desktop computers; Java applets are often used to provide improved functionality while browsing the World Wide Web.

Some advantages of JAVA:

It is an open source, so users do not have to struggle with heavy license fees each year
Platform independent
Java API's can easily be accessed by developers
Java perform supports garbage collection, so memory management is automatic
Java always allocates objects on the stack
Java embraced the concept of exception specifications
Multi-platform support language and support for web-services
Using JAVA we can develop dynamic web applications
It allows you to create modular programs and reusable codes

Another advantage of JAVA is that, ones the program is written in java we can run it anywhere means that application developed through Java is platform independent. JAVA based enterprise applications perform well because stable JAVA standards help developers to create multilevel applications with a component based approach.

JAVA programming enables secure and high performance software development on multiple platforms. Many companies in India have well-qualified software engineers having expertise in Java, Java Script, J2SE, JSP, and J2ME, JAVA Programming Services help your businesses to do better. They provide variety of Java development services including project solutions.

Introduction to Java

2011-04-23T21:52:00.001+05:30

History

Java is a programming language created by James Gosling from Sun Microsystems in 1991. The first public available version of Java (Java 1.0) was released 1995. Over time several version of Java were released which enhanced the language and its libraries. The current version of Java is Java 1.6 also known as Java 6.0.

From the Java programming language the Java platform evolved. The Java platform allows that code is written in other languages then the Java programming language and still runs on the Java virtual machine.

Overview

The Java programming language consists out of a Java compiler, the Java virtual machine, and the Java class libraries. The Java virtual machine (JVM) is a software implementation of a computer that executes programs like a real machine.

The Java compiler translates Java coding into so-called byte-code. The Java virtual machine interprets this byte-code and runs the program.

The Java virtual machine is written specifically for a specific operating system.

The Java runtime environment (JRE) consists of the JVM and the Java class libraries.

Characterstics

The target of Java is to write a program once and then run this program on multiple operating systems.
Java has the following properties:

Platform independent: Java programs use the Java virtual machine as abstraction and do not access the operating system directly. This makes Java programs highly portable. A Java program which is standard complaint and follows certain rules can run unmodified all several platforms, e.g. Windows or Linux.
Object-orientated programming language: Except the primitive data types, all elements in Java are objects.
Strongly-typed programming language: Java is strongly-typed, e.g. the types of the used variables must be pre-defined and conversion to other objects is relatively strict, e.g. must be done in most cases by the programmer.
Interpreted and compiled language: Java source code is transfered into byte-code which does not depend on the target platform. This byte-code will be interpreted by the Java Virtual machine (JVM). The JVM contains a so called Hotspot-Compiler which translates critical byte-code into native code.
Automatic memory management: Java manages the memory allocation and de-allocation for creating new objects. The program does not have direct access to the memory. The so-called garbage collector deletes automatically object to which no active pointer exists.

The Java syntax is similar to C++. Java is case sensitive, e.g. the variables myValue and myvalue will be treated as different variables.

Development with Java

The programmer writes Java source code in an text editor which supports plain text. Normally the programmer uses an IDE (integrated development environment) for programming. An IDE support the programmer in the task of writing code, e.g. it provides auto-formatting of the source code, highlighting of the important keywords, etc.
At some point the programmer (or the IDE) calls the Java compiler (javac). The Java compiler creates platform independent code which is called bytecode. This byte-code is stored in ".class" files.
Bytecode can be executed by the Java runtime environment. The Java runtime environment (JRE) is a program which knows how to run the bytecode on the operating system. The JRE translates the bytecode into native code and executes it, e.g. the native code for Linux is different then the native code for Windows.
By default, the compiler puts each class file in the same directory as its source file. You can specify a separate destination directory with -d

Code in Java

Java Program to Find Whether the given words are Anagram or Not

Using the library methods

Without using the library methods

Java program to check whether the two strings are anagram or not

Program to check if Least Significant Bit for a number is set or not

Thing to note from the above discussion

Java Program to find occurrence of a pattern in String with (and without) String methods

Finding patterns in the String : The problem description

Logic for finding the pattern occurrences in the String

Using String substring() method

Without using the substring() method

Circular Shifting of elements in Arrays - Java program to shift array elements circularly

What do we mean by shifting the elements of an array

Circular Shifting in Arrays - Right Circular Shift and Left Circular Shift

Java program to implement left circular shifting and right circular shifting of array elements

Output:

Java Program to print only the unique elements from the String array without using Collections

Java Program to find only distinct elements of String Array without using Collections

Java program to convert String into Integer without Integer.parseInt()

Logic building and approach

Java Program to Manually convert string to int without Integer.parseInt() method

Java program to reverse a string word by word

Program to reverse a String word by word in Java

Java Program to Format the String to Phone Number Format with dashes

Java Program to format the given input string to phone number format with dashes

Java Program to convert a given String to Phone number format with dashes:-

Java Exception Handling Tutorial-2

Advanced Exception Handling in Java Tutorial with Example Programs

Nesting Try Blocks

Program to demonstate nesting of try blocks in Java Exception Handling

Difference between throw and throws

Defining and Using your own Exceptions

Java Exception Handling Tutorial

Exception Handling in Java Tutorial with Example Programs

Exceptions in Java - What are Java Exceptions?

Types of Java Exceptions

Exception Handling in Java

Use of finally Block in Java Exception Handling

What happens when exception handler is not provided?

Core Java Project Desktop Application : Cab Invoice Generator

Invoice Generator Core Java Desktop Application Using Swing

Description

Snapshots

Download Project With Source Code and Database:

JDBC : Connection to databases

What is JDBC?

Steps for building a simple JDBC application

A Simple Program to demonstrate the JDBC application working:

The Expected Output after you have created the databse with some values of these columns:

New Core Java Projects Added

Packages in Java

Java Packages

What is a Java Package

How to Use the package

EXAMPLE PROGRAM

ACCESS PROTECTION

Constructors in Java

Using the Command Line Arguements

Structure of Java Program

First Java Program

Installing the JDK and Setting the Environment Variables

Setting up the Environment Variables

Need for Setting Environment Variables

Java Myths- Fact versus Fiction

Inside Java :Java myths - fact versus fiction

Top 10 Errors Java Programmers Make

Top Ten Errors Java Programmers Make

(How to spot them. How to fix/prevent them.)

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

9. Mistyping the name of a method when overriding

8. Comparison assignment ( = rather than == )

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

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

5. Writing blank exception handlers

4. Forgetting that Java is zero-indexed

3. Preventing concurrent access to shared variables by threads

2. Capitalization errors

(drum roll)

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

Inside Java :
Java myths - fact versus fiction

Inside Java :
The Java Programming Language