Saturday, February 14, 2009

Table Of Contents-start here

ad:Now its easy to earn money online, click to know how!!


1. Introduction

2. Start studying Java

3. Java Basic Elements

4. Java Operators

5. Control Flow Statements


Now its easy to earn money online, click to know how!!


6. Classes, Objects

7. Access Modifiers

8. Class Constructors

9. Inheritance

10.Abstract classes

11. Interfaces

12.Object typecasting

Now its easy to earn money online, click to know how!!

13.Method Overriding

14.Java Strings

15.String Buffers

16.Exceptions

17.A sample program

Now its easy to earn money online, click to know how!!
Posted by at No comments:

One program using all the knowledge!!!!!!

java.util.
Class Date

java.lang.Object
extended by java.util.Date

All Implemented Interfaces:
Cloneable, Comparable, Serializable

Direct Known Subclasses:
Date, Time, Timestamp

public class Date extends Object
implements Serializable, Cloneable, Comparable

The class Date represents a specific instant in time, with millisecond precision.

Java Date Source Code

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateUtility {



 /* Add Day/Month/Year to a Date
  add() is used to add  values to a Calendar object.
  You specify which Calendar field is to be affected by the operation
  (Calendar.YEAR, Calendar.MONTH, Calendar.DATE).
  */

 public static final String DATE_FORMAT = "dd-MM-yyyy";
 //See Java DOCS for different date formats
 // public static final String DATE_FORMAT = "yyyy-MM-dd";

 public static void addToDate() {
  System.out.println("1. Add to a Date Operation\n");
  SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
  //Gets a calendar using the default time zone and locale.
  Calendar c1 = Calendar.getInstance();
  Date d1 = new Date();
  //  System.out.println("Todays date in Calendar Format : "+c1);
  System.out.println(”c1.getTime() : ” + c1.getTime());
  System.out.println(”c1.get(Calendar.YEAR): “+ c1.get(Calendar.YEAR));
  System.out.println(”Todays date in Date Format : ” + d1);
  c1.set(1999, 0, 20); //(year,month,date)
  System.out.println(”c1.set(1999,0 ,20) : ” + c1.getTime());
  c1.add(Calendar.DATE, 20);
  System.out.println(”Date + 20 days is : “+ sdf.format(c1.getTime()));
  System.out.println();
  System.out.println(”————————————-”);
 }

 /*Substract Day/Month/Year to a Date

  roll() is used to substract values to a Calendar object.
  You specify which Calendar field is to be affected by the operation
  (Calendar.YEAR, Calendar.MONTH, Calendar.DATE).  

  Note: To substract, simply use a negative argument.
  roll() does the same thing except you specify if you want to roll up (add 1)
  or roll down (substract 1) to the specified Calendar field. The operation only
  affects the specified field while add() adjusts other Calendar fields.
  See the following example, roll() makes january rolls to december in the same
  year while add() substract the YEAR field for the correct result. Hence add()
  is preferred even for subtraction by using a negative element.

  */

 public static void subToDate() {

  System.out.println(”2. Subtract to a date Operation\n”);
  SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
  Calendar c1 = Calendar.getInstance();
  c1.set(1999, 0, 20);
  System.out.println(”Date is : ” + sdf.format(c1.getTime()));
  // roll down, substract 1 month
  c1.roll(Calendar.MONTH, false);
  System.out.println(”Date roll down 1 month : “+ sdf.format(c1.getTime()));
  c1.set(1999, 0, 20);

  System.out.println(”Date is : ” + sdf.format(c1.getTime()));
  c1.add(Calendar.MONTH, -1);
  // substract 1 month
  System.out.println(”Date minus 1 month : “+ sdf.format(c1.getTime()));
  System.out.println();
  System.out.println(”————————————-”);
 }

 public static void daysBetween2Dates() {

  System.out.println(”3. No of Days between 2 dates\n”);
  Calendar c1 = Calendar.getInstance(); //new GregorianCalendar();
  Calendar c2 = Calendar.getInstance(); //new GregorianCalendar();
  c1.set(1999, 0, 20);
  c2.set(1999, 0, 22);
  System.out.println(”Days Between ” + c1.getTime() + ” and ”
    + c2.getTime() + ” is”);
  System.out.println((c2.getTime().getTime() - c1.getTime()
    .getTime()) / (24 * 3600 * 1000));
  System.out.println();
  System.out.println(”————————————-”);
 }

 public static void daysInMonth() {

  System.out.println(”4. No of Days in a month for a given date\n”);
  Calendar c1 = Calendar.getInstance(); // new GregorianCalendar();
  c1.set(1999, 6, 20);
  int year = c1.get(Calendar.YEAR);
  int month = c1.get(Calendar.MONTH);
  // int days = c1.get(Calendar.DATE);
  int[] daysInMonths = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 };
  daysInMonths[1] += DateUtility.isLeapYear(year) ? 1 : 0;
  System.out.println(”Days in ” + month + “th month for year” + year
    + “is ” + daysInMonths[c1.get(Calendar.MONTH)]);
  System.out.println();

Earning money online become easy now, click to know
Earning money online become easy now, click to know
  System.out.println(”————————————-”);
 }

 public static void validateAGivenDate() {

  System.out.println(”5. Validate a given date\n”);
  String dt = “20011223″;
  String invalidDt = “20031315″;
  String dateformat = “yyyyMMdd”;
  Date dt1 = null, dt2 = null;
  try {
   SimpleDateFormat sdf = new SimpleDateFormat(dateformat);
   sdf.setLenient(false);
   dt1 = sdf.parse(dt);
   dt2 = sdf.parse(invalidDt);
   System.out.println(”Date is ok = ” + dt1 + “(” + dt + “)”);
  } catch (ParseException e) {

Earning money online become easy now, click to know

   System.out.println(e.getMessage());
  } catch (IllegalArgumentException e) {
   System.out.println(”Invalid date”);
  }
  System.out.println();
  System.out.println(”————————————-”);
 }

 public static void compare2Dates() {

  System.out.println(”6. Comparision of 2 dates\n”);
  SimpleDateFormat fm = new SimpleDateFormat(”dd-MM-yyyy”);
  Calendar c1 = Calendar.getInstance();
  Calendar c2 = Calendar.getInstance();
  c1.set(2000, 02, 15);
  c2.set(2001, 02, 15);
  System.out.print(fm.format(c1.getTime()) + ” is “);
  if (c1.before(c2)) {
   System.out.println(”less than ” + fm.format(c2.getTime()));
  } else if (c1.after(c2)) {
   System.out.println(”greater than ” + fm.format(c2.getTime()));
  } else if (c1.equals(c2)) {

Earning money online become easy now, click to know

   System.out.println(”is equal to ” + fm.format(c2.getTime()));
  }
  System.out.println();
  System.out.println(”————————————-”);
 }

 public static void getDayofTheDate() {

  System.out.println(”7. Get the day for a given date\n”);
  Date d1 = new Date();
  String day = null;
  DateFormat f = new SimpleDateFormat(”EEEE”);
  try {
   day = f.format(d1);
  } catch (Exception e) {
   e.printStackTrace();
  }
  System.out.println(”The day for ” + d1 + ” is ” + day);
  System.out.println();
  System.out.println(”————————————-”);
 }

 //Utility Method to find whether an Year is a Leap year or Not
 public static boolean isLeapYear(int year) {

  if ((year % 100 != 0) || (year % 400 == 0)) {
   return true;
  }
  return false;
 }

 public static void main(String args[]) {
  addToDate(); //Add day, month or year to a date field.
  subToDate(); //Subtract day, month or year to a date field.
  daysBetween2Dates();
  //The “right” way would be to compute the Julian day number of
  //both dates and then do the subtraction.
Earning money online become easy now, click to know
  daysInMonth();//Find the number of days in a month for a date
  validateAGivenDate();//Check whether the date format is proper
  compare2Dates(); //Compare 2 dates
  getDayofTheDate();
 }
}

Output

1. Add to a Date Operation

c1.getTime() : Sat Mar 31 10:47:54 IST 2007
c1.get(Calendar.YEAR): 2007
Todays date in Date Format : Sat Mar 31 10:47:54 IST 2007
c1.set(1999,0 ,20) : Wed Jan 20 10:47:54 IST 1999
Date + 20 days is : 09-02-1999

——————————————————-
2. Subtract to a date Operation

Date is : 20-01-1999
Date roll down 1 month : 20-12-1999
Date is : 20-01-1999
Date minus 1 month : 20-12-1998

——————————————————-
3. No of Days between 2 dates

Days Between Wed Jan 20 10:47:54 IST 1999 and Fri Jan 22 10:47:54 IST 1999 is
2

——————————————————-
4. No of Days in a month for a given date

Days in 6th month for year 1999 is 31

——————————————————-
5. Validate a given date

Unparseable date: “20031315″

——————————————————-
6. Comparision of 2 dates

15-03-2000 is less than 15-03-2001

——————————————————-
7. Get the day for a given date

The day for Sat Mar 31 10:47:54 IST 2007 is Saturday

Posted by at No comments:

Java Exceptions

Exceptions in java are any abnormal, unexpected events or extraordinary conditions that may occur at runtime. They could be file not found exception, unable to get connection exception and so on. On such conditions java throws an exception object. Java Exceptions are basically Java objects. No Project can never escape a java error exception. Java exception handling is used to handle error conditions in a program systematically by taking the necessary action. Exception handlers can be written to catch a specific exception such as Number Format exception, or an entire group of exceptions by using a generic exception handlers. Any exceptions not specifically handled within a Java program are caught by the Java run time environment

An exception is a subclass of the Exception/Error class, both of which are subclasses of the Throwable class. Java exceptions are raised with the throw keyword and handled within a catch block.

A Program Showing How the JVM throws an Exception at runtime

public class DivideException {

   public static void main(String[] args) {
    division(100,4);  // Line 1
    division(100,0);        // Line 2
       System.out.println(”Exit main().”);
   }
public static void division(int totalSum, int totalNumber) {

    System.out.println(”Computing Division.”);
    int average  = totalSum/totalNumber;
       System.out.println(”Average : “+ average);
   }
}

An ArithmeticException is thrown at runtime when Line 11 is executed because integer division by 0 is an illegal operation. The “Exit main()” message is never reached in the main method

Output

Computing Division.
java.lang.ArithmeticException: / by zero
Average : 25
Computing Division.
at DivideException.division(DivideException.java:11)
at DivideException.main(DivideException.java:5)
Exception in thread “main”

Exceptions in Java

Throwable Class

The Throwable class provides a String variable that can be set by the subclasses to provide a detail message that provides more information of the exception occurred. All classes of throwables define a one-parameter constructor that takes a string as the detail message.

The class Throwable provides getMessage() function to retrieve an exception. It has a printStackTrace() method to print the stack trace to the standard error stream. Lastly It also has a toString() method to print a short description of the exception. For more information on what is printed when the following messages are invoked, please refer the java docs.

Syntax

String getMessage()

void printStackTrace()

String toString()

Class Exception

The class Exception represents exceptions that a program faces due to abnormal or special conditions during execution. Exceptions can be of 2 types: Checked (Compile time Exceptions)/ Unchecked (Run time Exceptions).

Class RuntimeException

Runtime exceptions represent programming errors that manifest at runtime. For example ArrayIndexOutOfBounds, NullPointerException and so on are all subclasses of the java.lang.RuntimeException class, which is a subclass of the Exception class. These are basically business logic programming errors.

Class Error

Errors are irrecoverable condtions that can never be caught. Example: Memory leak, LinkageError etc. Errors are direct subclass of Throwable class.

Checked and Unchecked Exceptions

Checked exceptions are subclass’s of Exception excluding class RuntimeException and its subclasses. Checked Exceptions forces programmers to deal with the exception that may be thrown. Example: Arithmetic exception. When a checked exception occurs in a method, the method must either catch the exception and take the appropriate action, or pass the exception on to its caller

Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked. Unchecked exceptions , however, the compiler doesn’t force the programmers to either catch the exception or declare it in a throws clause. In fact, the programmers may not even know that the exception could be thrown. Example: ArrayIndexOutOfBounds Exception. They are either irrecoverable (Errors) and the program should not attempt to deal with them, or they are logical programming errors. (Runtime Exceptions). Checked exceptions must be caught at compile time. Runtime exceptions do not need to be. Errors often cannot be.

Exception Statement Syntax

Exceptions are handled using a try-catch-finally construct, which has the Syntax

try {

} catch ( ) { // 0 or more

}
} finally { // finally block

}

try Block
The java code that you think may produce an exception is placed within a try block for a
suitable catch block to handle the error.

If no exception occurs the execution proceeds with the finally block else it will look for the
matching catch block to handle the error. Again if the matching catch handler is not found execution
proceeds with the finally block and the default exception handler throws an exception.. If an exception is
generated within the try block, the remaining statements in the try block are not executed.

catch Block
Exceptions thrown during execution of the try block can be caught and handled in a catch block. On exit from a catch block, normal execution continues and the finally block is executed
(Though the catch block throws an exception).

finally Block
A finally block is always executed, regardless of the cause of exit from the try block, or whether any catch block was executed. Generally finally block is used for freeing resources, cleaning up, closing connections etc. If the finally clock executes a control transfer statement such as a return or a break statement, then this control
statement determines how the execution will proceed regardless of any return or control statement present in the try or catch.

The following program illustrates the scenario.

try {
   
} catch ( ) { // 0 or more
   


}
} finally {                               // finally block
   
}

Output

Computing Division.
Exception : / by zero
Finally Block Executes. Exception Occurred
result : -1

Below is a program showing the Normal Execution of the Program.

Please note that no NullPointerException is generated as was expected by most people

public class DivideException2 {

   public static void main(String[] args) {
    int result  = division(100,0);        // Line 2
       System.out.println(”result : “+result);
   }

   public static int division(int totalSum, int totalNumber) {
    int quotient = -1;
    System.out.println(”Computing Division.”);
    try{
     quotient  = totalSum/totalNumber;

    }

earn money online become easy now, click to know

     catch(Exception e){
     System.out.println(”Exception : “+ e.getMessage());
    }
    finally{
     if(quotient != -1){
      System.out.println(”Finally Block Executes”);
      System.out.println(”Result : “+ quotient);
     }else{
      System.out.println(”Finally Block Executes. Exception Occurred”);
      return quotient;
     }

    }
    return quotient;
   }
}

Output

null (And not NullPointerException)

Rules for try, catch and finally Blocks

1. For each try block there can be zero or more catch blocks, but only one finally block.

2. The catch blocks and finally block must always appear in conjunction with a try block.

3. A try block must be followed by either at least one catch block or one finally block.

4. The order exception handlers in the catch block must be from the most specific exception

Java exception handling mechanism enables you to catch exceptions in java using try, catch, finally block. be An exception consists of a block of code called a try block, a block of code called a catch block, and the finally block. Let’s examine each of these in detail.

public class DivideException1 {

   public static void main(String[] args) {
    division(100,0);        // Line 2
       System.out.println(”Main Program Terminating”);
   }

   public static void division(int totalSum, int totalNumber) {
    int quotient = -1;
    System.out.println(”Computing Division.”);
    try{
     quotient  = totalSum/totalNumber;
     System.out.println(”Result is : “+quotient);
    }
earn money online become easy now, click to know
     catch(Exception e){
     System.out.println(”Exception : “+ e.getMessage());
    }
    finally{
     if(quotient != -1){
      System.out.println(”Finally Block Executes”);
      System.out.println(”Result : “+ quotient);
     }else{
      System.out.println(”Finally Block Executes. Exception Occurred”);
     }

    }
   }
}

Output

Computing Division.
Exception : / by zero
Finally Block Executes. Exception Occurred
Main Program Terminating

As shown above when the divide by zero calculation is attempted, an ArithmeticException is thrown. and program execution is transferred to the catch statement. Because the exception is thrown from the try block, the remaining statements of the try block
are skipped. The finally block executes.

Defining new EXCEPTIONS!!
We can have our own custom Exception handler to deal with special exception conditions instead of using existing exception classes. Custom exceptions usually extend the Exception class directly or any subclass of Exception (making it checked).
The super() call can be used to set a detail message in the throwable. Below is an example that shows the use of Custom exception’s along with how the throw and throws clause are used.

class BadTemperature extends Exception{
 BadTemperature( String reason ){
  super ( reason );
   }
}

class TooHot extends BadTemperature{

 TooHot(){
  super (”Default messaeg : Hot”);
   }

earn money online become easy now, click to know

 TooHot(String message){
  super (message);
   }
}

class TooCold extends BadTemperature{

 TooCold(){
  super (”Default messaeg : Cold”);
   }

 TooCold(String message){
  super (message);
   }
}

class TempertureObject{

 int temperature;

   TempertureObject( int temp ) {
    temperature = temp;
   }

   void test() throws TooHot, TooCold {
    if ( temperature < 70 ) throw new TooCold(”Very Cold”);
       if ( temperature > 80 ) throw new TooHot(”Very Hot”);
   }
}

earn money online become easy now, click to know

public class ExceptionExample1{  

 private static void temperatureReport( TempertureObject batch ){
  try{   batch.test();
           System.out.println( “Perfect Temperature” );
       }
       catch ( BadTemperature bt ){
        System.out.println( bt.getMessage( ) );
       }
   }

   public static void main( String[] args ){
    temperatureReport( new TempertureObject( 100 ) );
       temperatureReport( new TempertureObject( 50 ) );
       temperatureReport( new TempertureObject( 75 ) );
   }
}

Output

Very Hot
Very Cold
Perfect Temperature

throw, throws statement

A program can explicitly throw an exception using the throw statement besides the implicit exception thrown.

The general format of the throw statement is as follows:

throw ;

The Exception reference must be of type Throwable class or one of its subclasses. A detail message can be passed to the constructor when the exception object is created.

throw new TemperatureException(”Too hot”);

A throws clause can be used in the method prototype.

Method() throws ,…, {

}

Each can be a checked or unchecked or sometimes even a custom Exception. The exception type specified in the throws clause in the method prototype can be a super class type of the actual exceptions thrown. Also an overriding method cannot allow more checked exceptions in its throws clause than the inherited method does.

When an exception is thrown, normal execution is suspended. The runtime system proceeds to find a matching catch block that can handle the exception. Any associated finally block of a try block encountered along the search path is executed. If no handler is found, then the exception is dealt with by the default exception handler at the top level. If a handler is found, execution resumes with the code in its catch block. Below is an example to show the use of a throws and a throw statement.

public class DivideException3 {

   public static void main(String[] args) {
    try{
     int result  = division(100,10);
     result  = division(100,0);
        System.out.println(”result : “+result);
    }
       catch(ArithmeticException e){
     System.out.println(”Exception : “+ e.getMessage());
    }
   }

   public static int division(int totalSum, int totalNumber) throws ArithmeticException {
    int quotient = -1;
    System.out.println(”Computing Division.”);
    try{
     if(totalNumber == 0){
      throw new ArithmeticException(”Division attempt by 0″);
     }
     quotient  = totalSum/totalNumber;

    }

earn money online become easy now, click to know

     finally{
     if(quotient != -1){
      System.out.println(”Finally Block Executes”);
      System.out.println(”Result : “+ quotient);
     }else{
      System.out.println(”Finally Block Executes. Exception Occurred”);
     }

    }
    return quotient;
   }
}

Output

Computing Division.
Finally Block Executes
Result : 10
Computing Division.
Finally Block Executes. Exception Occurred
Exception : Division attempt by 0

Using break and return with Exceptions

This example demonstrates the use of the break, continue and return statements with exceptions. Note that the finally block is executed always except when the return statement is executed.

public class ExceptionExample6 {

 public static void main(String[] args) {

  int x = 10, y = 2;
  int counter = 0;
  boolean flag = true;
  while (flag) {
  start:
   try {
    if ( y > 1 )
     break start;
    if ( y < 0 )
     return;
    x = x / y;
    System.out.println ( “x : ” + x + ” y : “+y );
   }
   catch ( Exception e ) {

earn money online become easy now, click to know


    System.out.println ( e.getMessage() );
   }
   finally {
    ++counter;
    System.out.println ( “Counter : ” + counter );
   }
   –y;
  }
 }
}

Output

Counter : 1
x : 10 y : 1
Counter : 2
/ by zero
Counter : 3
Counter : 4

Handling Multiple Exceptions

It should be known by now that we can have multiple catch blocks for a particular try block to handle many different kind of exceptions that can be generated. Below is a program to demonstrate the use of multiple catch blocks.

import java.io.DataInputStream;
import java.io.IOException;

import javax.swing.JOptionPane;
public class ExceptionExample7{
   static int numerator, denominator;

   public ExceptionExample7( int t, int b ){
 numerator = t;
 denominator = b;
   }

   public int divide( ) throws ArithmeticException{

earn money online become easy now, click to know

     return numerator/denominator;
   }

   public static void main( String args[] ){

    String num, denom;

    num = JOptionPane.showInputDialog(null, “Enter the Numerator”);
    denom = JOptionPane.showInputDialog(null, “Enter the Denominator”);

  try{
      numerator = Integer.parseInt( num );
      denominator = Integer.parseInt( denom );
  }
  catch ( NumberFormatException nfe ){
      System.out.println( “One of the inputs is not an integer” );
      return;
  }
       catch ( Exception e ){
      System.out.println( “Exception: ” + e.getMessage( ) );
      return;
       }

  ExceptionExample7 d = new ExceptionExample7( numerator, denominator );
  try{
      double result = d.divide( );
      JOptionPane.showMessageDialog(null, “Result : ” + result);
  }
  catch ( ArithmeticException ae ){
   System.out.println( “You can’t divide by zero” );
  }
  finally{
   System.out.println( “Finally Block is always Executed” );
     }
   }
}
Posted by at No comments:

Java String Buffer

StringBuffer Class

StringBuffer class is a mutable class unlike the String class which is immutable. Both the capacity and character string of a StringBuffer Class. StringBuffer can be changed dynamically. String buffers are preferred when heavy modification of character strings is involved (appending, inserting, deleting, modifying etc). Strings can be obtained from string buffers. Since the StringBuffer class does not override the equals() method from the Object class, contents of string buffers should be converted to String objects for string comparison.
A StringIndexOutOfBoundsException is thrown if an index is not valid when using wrong index in String Buffer manipulations

Creation of StringBuffers

StringBuffer Constructors

public class StringBufferDemo {

 public static void main(String[] args) {
  //     Examples of Creation of Strings
  StringBuffer strBuf1 = new StringBuffer(”Bob”);
  StringBuffer strBuf2 = new StringBuffer(100); //With capacity 100
  StringBuffer strBuf3 = new StringBuffer(); //Default Capacity 16
  System.out.println(”strBuf1 : ” + strBuf1);
  System.out.println(”strBuf2 capacity : ” + strBuf2.capacity());
  System.out.println(”strBuf3 capacity : ” + strBuf3.capacity());
 }
}

Output

strBuf1 : Bob
strBuf2 capacity : 100
strBuf3 capacity : 16

StringBuffer Functions

The following program explains the usage of the some of the basic StringBuffer methods like ;

1. capacity()
Returns the current capacity of the String buffer.

2. length()
Returns the length (character count) of this string buffer.

3. charAt(int index)
The specified character of the sequence currently represented by the string buffer, as indicated by the index argument, is returned.

4. setCharAt(int index, char ch)
The character at the specified index of this string buffer is set to ch

5. toString()
Converts to a string representing the data in this string buffer

6. insert(int offset, char c)
Inserts the string representation of the char argument into this string buffer.
Note that the StringBuffer class has got many overloaded ‘insert’ methods which can be used based on the application need.

7. delete(int start, int end)
Removes the characters in a substring of this StringBuffer

8. replace(int start, int end, String str)
Replaces the characters in a substring of this StringBuffer with characters in the specified String.

9. reverse()
The character sequence contained in this string buffer is replaced by the reverse of the sequence.

10. append(String str)
Appends the string to this string buffer.
Note that the StringBuffer class has got many overloaded ‘append’ methods which can be used based on the application need.

11. setLength(int newLength)
Sets the length of this String buffer.

public class StringBufferFunctionsDemo {

 public static void main(String[] args) {
  //     Examples of Creation of Strings
  StringBuffer strBuf1 = new StringBuffer(”Bobby”);
  StringBuffer strBuf2 = new StringBuffer(100); //With capacity 100
  StringBuffer strBuf3 = new StringBuffer(); //Default Capacity 16
  System.out.println(”strBuf1 : ” + strBuf1);
  System.out.println(”strBuf1 capacity : ” + strBuf1.capacity());
  System.out.println(”strBuf2 capacity : ” + strBuf2.capacity());
  System.out.println(”strBuf3 capacity : ” + strBuf3.capacity());
  System.out.println(”strBuf1 length : ” + strBuf1.length());
  System.out.println(”strBuf1 charAt 2 : ” + strBuf1.charAt(2));
  //     A StringIndexOutOfBoundsException is thrown if the index is not valid.
  strBuf1.setCharAt(1, ‘t’);
  System.out.println(”strBuf1 after setCharAt 1 to t is : ”
    + strBuf1);
  System.out
    .println(”strBuf1 toString() is : ” + strBuf1.toString());
  strBuf3.append(”beginner-java-tutorial”);
  System.out.println(”strBuf3 when appended with a String : ”
    + strBuf3.toString());
  strBuf3.insert(1, ‘c’);
  System.out.println(”strBuf3 when c is inserted at 1 : ”
    + strBuf3.toString());
  strBuf3.delete(1, ‘c’);
  System.out.println(”strBuf3 when c is deleted at 1 : ”
    + strBuf3.toString());
  strBuf3.reverse();
  System.out.println(”Reversed strBuf3 : ” + strBuf3);
  strBuf2.setLength(5);
  strBuf2.append(”jdbc-tutorial”);
  System.out.println(”strBuf2 : ” + strBuf2);
  //     We can clear a StringBuffer using the following line
  strBuf2.setLength(0);
  System.out.println(”strBuf2 when cleared using setLength(0): ”
    + strBuf2);
 }
}



Output

strBuf1 : Bobby
strBuf1 capacity : 21
strBuf2 capacity : 100
strBuf3 capacity : 16
strBuf1 length : 5
strBuf1 charAt 2 : b
strBuf1 after setCharAt 1 to t is : Btbby
strBuf1 toString() is : Btbby
strBuf3 when appended with a String : beginner-java-tutorial
strBuf3 when c is inserted at 1 : bceginner-java-tutorial
strBuf3 when c is deleted at 1 : b
Reversed strBuf3 : b
strBuf2 :

Posted by at No comments:

Java Strings

Strings in java

Java String Class is immutable, i.e. Strings in java, once created and initialized, cannot be changed on the same reference. A java.lang.String class is final which implies no class and extend it. The java.lang.String class differs from other classes, one difference being that the String objects can be used with the += and + operators for concatenation. Two useful methods for String objects are equals( ) and substring( ). The equals( ) method is used for testing whether two Strings contain the same value. The substring( ) method is used to obtain a selected portion of a String.

Java.lang.String class creation

A simple String can be created using a string literal enclosed inside double quotes as shown;

String str1 = “My name is bob”;

Since a string literal is a reference, it can be manipulated like any other String reference. The reference value of a string literal can be assigned to another String reference.

If 2 or more Strings have the same set of characters in the same sequence then they share the same reference in memory. Below illustrates this phenomenon.

String str1 = “My name is bob”;
String str2 = “My name is bob”;
String str3 = “My name ”+ “is bob”; //Compile time expression
String name = “bob”;
String str4 = “My name is” + name;
String str5 = new String(“My name is bob”);

In the above code all the String references str1, str2 and str3 denote the same String object, initialized with the character string: “My name is bob”. But the Strings str4 and str5 denote new String objects.

Constructing String objects can also be done from arrays of bytes, arrays of characters, or string buffers. A simple way to convert any primitive value to its string representation is by concatenating it with the empty string (”"), using the string concatenation operator (+).

public class StringsDemo {

   public static void main(String[] args) {

    byte[] bytes = {2, 4, 6, 8};

    char[] characters = {’a', ‘b’, ‘C’, ‘D’};

    StringBuffer strBuffer = new StringBuffer(”abcde”);

//     Examples of Creation of Strings

    String byteStr = new String(bytes);
Earn money online, click here

Strings in java

Java String Class is immutable, i.e. Strings in java, once created and initialized, cannot be changed on the same reference. A java.lang.String class is final which implies no class and extend it. The java.lang.String class differs from other classes, one difference being that the String objects can be used with the += and + operators for concatenation.

Two useful methods for String objects are equals( ) and substring( ). The equals( ) method is used for testing whether two Strings contain the same value. The substring( ) method is used to obtain a selected portion of a String.

Java.lang.String class creation

A simple String can be created using a string literal enclosed inside double quotes as shown;

String str1 = “My name is bob”;

Since a string literal is a reference, it can be manipulated like any other String reference. The reference value of a string literal can be assigned to another String reference.

If 2 or more Strings have the same set of characters in the same sequence then they share the same reference in memory. Below illustrates this phenomenon.

String str1 = “My name is bob”;
String str2 = “My name is bob”;
String str3 = “My name ”+ “is bob”; //Compile time expression
String name = “bob”;
String str4 = “My name is” + name;
String str5 = new String(“My name is bob”);

In the above code all the String references str1, str2 and str3 denote the same String object, initialized with the character string: “My name is bob”. But the Strings str4 and str5 denote new String objects.

Constructing String objects can also be done from arrays of bytes, arrays of characters, or string buffers. A simple way to convert any primitive value to its string representation is by concatenating it with the empty string (”"), using the string concatenation operator (+).

public class StringsDemo {

   public static void main(String[] args) {

    byte[] bytes = {2, 4, 6, 8};

    char[] characters = {’a', ‘b’, ‘C’, ‘D’};

    StringBuffer strBuffer = new StringBuffer(”abcde”);

//     Examples of Creation of Strings

    String byteStr = new String(bytes);     
Earn money online, click here Earn money online, click here
     String charStr = new String(characters);

    String buffStr = new String(strBuffer);

    System.out.println(”byteStr : “+byteStr);

    System.out.println(”charStr : “+charStr);

    System.out.println(”buffStr : “+buffStr);

   }

}
Output

byteStr :
charStr : abCD
buffStr : abcde

String Equality

public class StringsDemo2 {

 public static void main(String[] args) {
  String str1 = “My name is bob”;
  String str2 = “My name is bob”;
  String str3 = “My name ” + “is bob”; //Compile time expression
  String name = “bob”;
  String str4 = “My name is ” + name;
  String str5 = new String(”My name is bob”);
  System.out.println(”str1 == str2 : ” + (str1 == str2));
  System.out.println(”str2 == str3 : ” + (str2 == str3));
  System.out.println(”str3 == str1 : ” + (str3 == str1));
  System.out.println(”str4 == str5 : ” + (str4 == str5));
  System.out.println(”str1 == str4 : ” + (str1 == str4));
  System.out.println(”str1 == str5 : ” + (str1 == str5));

Earn money online, click hereEarn money online, click hereEarn money online, click here

  System.out.println(”str1.equals(str2) : ” + str1.equals(str2));
  System.out.println(”str2.equals(str3) : ” + str2.equals(str3));
  System.out.println(”str3.equals(str1) : ” + str3.equals(str1));
  System.out.println(”str4.equals(str5) : ” + str4.equals(str5));
  System.out.println(”str1.equals(str4) : ” + str1.equals(str4));
  System.out.println(”str1.equals(str5) : ” + str1.equals(str5));
 }
}

Output

str1 == str2 : true
str2 == str3 : true
str3 == str1 : true
str4 == str5 : false
str1 == str4 : false
str1 == str5 : false
str1.equals(str2) : true
str2.equals(str3) : true
str3.equals(str1) : true
str4.equals(str5) : true
str1.equals(str4) : true
str1.equals(str5) : true

Java String Functions

The following program explains the usage of the some of the basic String methods like ;

1. compareTo(String anotherString)
Compares two strings lexicographically.

2. charAt(int index)
Returns the character at the specified index.

3. getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Copies characters from this string into the destination character array.

4. length()
Returns the length of this string.

5. equals(Object anObject)
Compares this string to the specified object.

6. equalsIgnoreCase(String anotherString)
Compares this String to another String, ignoring case considerations.

7. toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.

7. toLowerCase()

Converts all of the characters in this String to upper case using the rules of the default locale.

9. concat(String str)
Concatenates the specified string to the end of this string.

10. indexOf(int ch)

Returns the index within this string of the first occurrence of the specified character.

11. indexOf(int ch, int fromIndex)

Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

12. indexOf(String str)

Returns the index within this string of the first occurrence of the specified substring.

13. indexOf(String str, int fromIndex)

Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.

14. lastIndexOf(int ch)

Returns the index within this string of the last occurrence of the specified character.

15. lastIndexOf(int ch, int fromIndex)

Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.

16. lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.

17. lastIndexOf(String str, int fromIndex)

Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.

18. substring(int beginIndex)

Returns a new string that is a substring of this string.

19. substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.

20. replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

21. trim()

Returns a copy of the string, with leading and trailing whitespace omitted.

22. toString()

This object (which is already a string!) is itself returned.

public class StringsDemo3 {

 public static void main(String[] args) {
  String str1 = “My name is bob”;
  char str2[] = new char[str1.length()];
  String str3 = “bob”;
  String str4 = “cob”;
  String str5 = “BoB”;
  String str6 = “bob”;
  System.out.println(”Length of the String str1 : ” + str1.length());
  System.out.println(”Character at position 3 is : ”
    + str1.charAt(3));
  str1.getChars(0, str1.length(), str2, 0);
  System.out.print(”The String str2 is : “);
  for (int i = 0; i < str2.length; i++) {
   System.out.print(str2[i]);
  }
  System.out.println();
  System.out.print(”Comparision Test : “);
  if (str3.compareTo(str4) < 0) {
   System.out.print(str3 + ” < ” + str4);
  } else if (str3.compareTo(str4) > 0) {
   System.out.print(str3 + ” > ” + str4);
  }
Earn money online, click hereEarn money online, click hereEarn money online, click here

else {
   System.out.print(str3 + ” equals ” + str4);
  }
  System.out.println();
  System.out.print(”Equals Test”);
  System.out.println(”str3.equalsIgnoreCase(5) : ”
    + str3.equalsIgnoreCase(str5));
  System.out.println(”str3.equals(6) : ” + str3.equals(str6));
  System.out.println(”str1.equals(3) : ” + str1.equals(str3));
  str5.toUpperCase(); //Strings are immutable
  System.out.println(”str5 : ” + str5);
  String temp = str5.toUpperCase();
  System.out.println(”str5 Uppercase: ” + temp);
  temp = str1.toLowerCase();
  System.out.println(”str1 Lowercase: ” + str1);
  System.out.println(”str1.concat(str4): ” + str1.concat(str4));
  String str7temp = ”  \t\n Now for some Search and Replace Examples    “;
  String str7 = str7temp.trim();
  System.out.println(”str7 : ” + str7);
  String newStr = str7.replace(’s’, ‘T’);
  System.out.println(”newStr : ” + newStr);
  System.out.println(”indexof Operations on Strings”);
  System.out.println(”Index of p in ” + str7 + ” : ”
    + str7.indexOf(’p'));
  System.out.println(”Index of for in ” + str7 + ” : ”
    + str7.indexOf(”for”));
  System.out.println(”str7.indexOf(for, 30) : ”
    + str7.indexOf(”for”, 30));
  System.out.println(”str7.indexOf(’p', 30) : ”
    + str7.indexOf(’p', 30));
  System.out.println(”str7.lastIndexOf(’p') : ”
    + str7.lastIndexOf(’p'));
  System.out.println(”str7.lastIndexOf(’p', 4) : ”
    + str7.lastIndexOf(’p', 4));
  System.out.print(”SubString Operations on Strings”);
  String str8 = “SubString Example”;
  String sub5 = str8.substring(5); // “ring Example”
  String sub3_6 = str8.substring(3, 6); // “Str”
  System.out.println(”str8 : ” + str8);
  System.out.println(”str8.substring(5) : ” + sub5);
  System.out.println(”str8.substring(3,6) : ” + sub3_6);
 }
}


Output

Length of the String str1 : 14
Character at position 3 is : n
The String str2 is : My name is bob
Comparision Test : bob < cob
Equals Teststr3.equalsIgnoreCase(5) : true
str3.equals(6) : true
str1.equals(3) : false
str5 : BoB
str5 Uppercase: BOB
str1 Lowercase: My name is bob
str1.concat(str4): My name is bobcob
str7 : Now for some Search and Replace Examples
newStr : Now for Tome Search and Replace ExampleT
Indexof Operations on Strings
Index of p in Now for some Search and Replace Examples : 26

Index of for in Now for some Search and Replace Examples : 4
str7.indexOf(for, 30) : -1
str7.indexOf(’p', 30) : 36
str7.lastIndexOf(’p') : 36
str7.lastIndexOf(’p', 4) : -1
SubString Operations on Stringsstr8 : SubString Example
str8.substring(5) : ring Example
str8.substring(3,6) : Str

Below is a program to check for Alpha Numeric character’s in the string.

public class TestAlphaNumericCharacters {

 private void isAlphaNumeric(final String input) {
  boolean isCharFlag = false;
  boolean isNumberFlag = false;
  final char[] chars = input.toCharArray();
  for (int x = 0; x < chars.length; x++) {
   char c = chars[x];
Earn money online, click hereEarn money online, click hereEarn money online, click hereEarn money online, click here
   //              lowercase && uppercase alphabet
   if ((c >= ‘a’) && (c <= ‘z’) || (c >= ‘A’) && (c <= ‘Z’)) {
    isCharFlag = true;
    continue;
   }
   if ((c >= ‘0′) && (c <= ‘9′)) { // numeric
    isNumberFlag = true;
    continue;
   }
  }
  System.out.println(”characters are present:” + isCharFlag);
  System.out.println(”Numbers are present :” + isNumberFlag);
 }
 public static void main(String[] args) {
  TestAlphaNumericCharacters tANC = new TestAlphaNumericCharacters();
  tANC.isAlphaNumeric(”beginn3ers”);
 }
}

Output

characters are present:true
Numbers are present :true

Below is a java program to Reverse a string (Reverse by words / characters)

import java.util.*;

public class StringReverse {

 public static void main(String[] args) {
  String input = “beginner java tutorial”;
  Stack stack = new Stack(); //A Stack is a Last In First Out Data Structure
  StringTokenizer stringTokenizer = new StringTokenizer(input);
  while (stringTokenizer.hasMoreTokens()) {
   stack.push(stringTokenizer.nextElement());
  }
  System.out.println(”Original String: ” + input);
  System.out.print(”Reversed String by Words: “);
  while (!stack.empty()) {
   System.out.print(stack.pop());
   System.out.print(” “);
  }
  System.out.println();
  System.out.print(”Reversed String by characters: “);
  StringBuffer rev = new StringBuffer(input).reverse();
  System.out.print(rev);
 }
}


Output

Original String: beginner java tutorial
Reversed String by Words: tutorial java beginner
Reversed String by characters: lairotut avaj rennigeb


    String charStr = new String(characters);

    String buffStr = new String(strBuffer);

    System.out.println(”byteStr : “+byteStr);

    System.out.println(”charStr : “+charStr);

    System.out.println(”buffStr : “+buffStr);

   }

}


Output

byteStr :
charStr : abCD
buffStr : abcde


String Equality

public class StringsDemo2 {

 public static void main(String[] args) {
  String str1 = “My name is bob”;
  String str2 = “My name is bob”;
  String str3 = “My name ” + “is bob”; //Compile time expression
  String name = “bob”;
  String str4 = “My name is ” + name;
  String str5 = new String(”My name is bob”);
  System.out.println(”str1 == str2 : ” + (str1 == str2));
  System.out.println(”str2 == str3 : ” + (str2 == str3));
  System.out.println(”str3 == str1 : ” + (str3 == str1));
  System.out.println(”str4 == str5 : ” + (str4 == str5));
  System.out.println(”str1 == str4 : ” + (str1 == str4));
  System.out.println(”str1 == str5 : ” + (str1 == str5));
  System.out.println(”str1.equals(str2) : ” + str1.equals(str2));
  System.out.println(”str2.equals(str3) : ” + str2.equals(str3));
  System.out.println(”str3.equals(str1) : ” + str3.equals(str1));
  System.out.println(”str4.equals(str5) : ” + str4.equals(str5));
  System.out.println(”str1.equals(str4) : ” + str1.equals(str4));
  System.out.println(”str1.equals(str5) : ” + str1.equals(str5));
 }
}

Output

str1 == str2 : true
str2 == str3 : true
str3 == str1 : true
str4 == str5 : false
str1 == str4 : false
str1 == str5 : false
str1.equals(str2) : true
str2.equals(str3) : true
str3.equals(str1) : true
str4.equals(str5) : true
str1.equals(str4) : true
str1.equals(str5) : true

Java String Functions

The following program explains the usage of the some of the basic String methods like ;

1. compareTo(String anotherString)
Compares two strings lexicographically.

2. charAt(int index)
Returns the character at the specified index.

3. getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Copies characters from this string into the destination character array.

4. length()
Returns the length of this string.

5. equals(Object anObject)
Compares this string to the specified object.

6. equalsIgnoreCase(String anotherString)
Compares this String to another String, ignoring case considerations.

7. toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.

7. toLowerCase()
Converts all of the characters in this String to upper case using the rules of the default locale.

9. concat(String str)
Concatenates the specified string to the end of this string.

10. indexOf(int ch)

Returns the index within this string of the first occurrence of the specified character.

11. indexOf(int ch, int fromIndex)

Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.

12. indexOf(String str)

Returns the index within this string of the first occurrence of the specified substring.

13. indexOf(String str, int fromIndex)

Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.

14. lastIndexOf(int ch)

Returns the index within this string of the last occurrence of the specified character.

15. lastIndexOf(int ch, int fromIndex)

Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.

16. lastIndexOf(String str)

Returns the index within this string of the rightmost occurrence of the specified substring.

17. lastIndexOf(String str, int fromIndex)

Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.

18. substring(int beginIndex)

Returns a new string that is a substring of this string.

19. substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.

20. replace(char oldChar, char newChar)

Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar.

21. trim()

Returns a copy of the string, with leading and trailing whitespace omitted.

22. toString()

This object (which is already a string!) is itself returned.

public class StringsDemo3 {

 public static void main(String[] args) {
  String str1 = “My name is bob”;
  char str2[] = new char[str1.length()];
  String str3 = “bob”;
  String str4 = “cob”;
  String str5 = “BoB”;
  String str6 = “bob”;
  System.out.println(”Length of the String str1 : ” + str1.length());
  System.out.println(”Character at position 3 is : ”
    + str1.charAt(3));
  str1.getChars(0, str1.length(), str2, 0);
  System.out.print(”The String str2 is : “);
  for (int i = 0; i < str2.length; i++) {
   System.out.print(str2[i]);
  }
  System.out.println();
  System.out.print(”Comparision Test : “);
  if (str3.compareTo(str4) < 0) {
   System.out.print(str3 + ” < ” + str4);
  } else if (str3.compareTo(str4) > 0) {
   System.out.print(str3 + ” > ” + str4);
  } else {
   System.out.print(str3 + ” equals ” + str4);
  }
  System.out.println();
  System.out.print(”Equals Test”);
  System.out.println(”str3.equalsIgnoreCase(5) : ”
    + str3.equalsIgnoreCase(str5));
  System.out.println(”str3.equals(6) : ” + str3.equals(str6));
  System.out.println(”str1.equals(3) : ” + str1.equals(str3));
  str5.toUpperCase(); //Strings are immutable
  System.out.println(”str5 : ” + str5);
  String temp = str5.toUpperCase();
  System.out.println(”str5 Uppercase: ” + temp);
  temp = str1.toLowerCase();
  System.out.println(”str1 Lowercase: ” + str1);
  System.out.println(”str1.concat(str4): ” + str1.concat(str4));
  String str7temp = ”  \t\n Now for some Search and Replace Examples    “;
  String str7 = str7temp.trim();
  System.out.println(”str7 : ” + str7);
  String newStr = str7.replace(’s’, ‘T’);
  System.out.println(”newStr : ” + newStr);
  System.out.println(”indexof Operations on Strings”);
  System.out.println(”Index of p in ” + str7 + ” : ”
    + str7.indexOf(’p'));
  System.out.println(”Index of for in ” + str7 + ” : ”
    + str7.indexOf(”for”));
  System.out.println(”str7.indexOf(for, 30) : ”
    + str7.indexOf(”for”, 30));
  System.out.println(”str7.indexOf(’p', 30) : ”
    + str7.indexOf(’p', 30));
  System.out.println(”str7.lastIndexOf(’p') : ”
    + str7.lastIndexOf(’p'));
  System.out.println(”str7.lastIndexOf(’p', 4) : ”
    + str7.lastIndexOf(’p', 4));
  System.out.print(”SubString Operations on Strings”);
  String str8 = “SubString Example”;
  String sub5 = str8.substring(5); // “ring Example”
  String sub3_6 = str8.substring(3, 6); // “Str”
  System.out.println(”str8 : ” + str8);
  System.out.println(”str8.substring(5) : ” + sub5);
  System.out.println(”str8.substring(3,6) : ” + sub3_6);
 }
}

Output

Length of the String str1 : 14
Character at position 3 is : n
The String str2 is : My name is bob
Comparision Test : bob < cob
Equals Teststr3.equalsIgnoreCase(5) : true
str3.equals(6) : true
str1.equals(3) : false
str5 : BoB
str5 Uppercase: BOB
str1 Lowercase: My name is bob
str1.concat(str4): My name is bobcob
str7 : Now for some Search and Replace Examples
newStr : Now for Tome Search and Replace ExampleT
Indexof Operations on Strings
Index of p in Now for some Search and Replace Examples : 26
Index of for in Now for some Search and Replace Examples : 4
str7.indexOf(for, 30) : -1
str7.indexOf(’p', 30) : 36
str7.lastIndexOf(’p') : 36
str7.lastIndexOf(’p', 4) : -1
SubString Operations on Stringsstr8 : SubString Example
str8.substring(5) : ring Example
str8.substring(3,6) : Str

Below is a program to check for Alpha Numeric character’s in the string.

public class TestAlphaNumericCharacters {

 private void isAlphaNumeric(final String input) {
  boolean isCharFlag = false;
  boolean isNumberFlag = false;
  final char[] chars = input.toCharArray();
  for (int x = 0; x < chars.length; x++) {
   char c = chars[x];
   //              lowercase && uppercase alphabet
   if ((c >= ‘a’) && (c <= ‘z’) || (c >= ‘A’) && (c <= ‘Z’)) {
    isCharFlag = true;
    continue;
   }
   if ((c >= ‘0′) && (c <= ‘9′)) { // numeric
    isNumberFlag = true;
    continue;
   }
  }
  System.out.println(”characters are present:” + isCharFlag);
  System.out.println(”Numbers are present :” + isNumberFlag);
 }
 public static void main(String[] args) {
  TestAlphaNumericCharacters tANC = new TestAlphaNumericCharacters();
  tANC.isAlphaNumeric(”beginn3ers”);
 }
}

Output

characters are present:true
Numbers are present :true

Below is a java program to Reverse a string (Reverse by words / characters)

import java.util.*;

public class StringReverse {

 public static void main(String[] args) {
  String input = “beginner java tutorial”;
  Stack stack = new Stack(); //A Stack is a Last In First Out Data Structure
  StringTokenizer stringTokenizer = new StringTokenizer(input);
  while (stringTokenizer.hasMoreTokens()) {
   stack.push(stringTokenizer.nextElement());
  }
  System.out.println(”Original String: ” + input);
  System.out.print(”Reversed String by Words: “);
  while (!stack.empty()) {
   System.out.print(stack.pop());
   System.out.print(” “);
  }
  System.out.println();
  System.out.print(”Reversed String by characters: “);
  StringBuffer rev = new StringBuffer(input).reverse();
  System.out.print(rev);
 }
}

Output

Original String: beginner java tutorial
Reversed String by Words: tutorial java beginner
Reversed String by characters: lairotut avaj rennigeb

Posted by at No comments:

Method Overriding in Java

The new method definition must have the same method signature (i.e., method name and parameters) and return type. Only parameter types and return type are chosen as criteria for matching method signature. So if a subclass has its method parameters as final it doesn’t really matter for method overriding scenarios as it still holds true. The new method definition cannot narrow the accessibility of the method, but it can widen it. The new method definition can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the super class

A program to explain the different concepts of Java Method Overridding

class CustomException extends Exception {

}

class SuperClassWithDifferentMethods {

protected int field1 = 10;
protected static int field2 = 20;
public void method1() {
System.out.println("SuperClassWithDifferentMethods.method1()");
}
public final void method2() {
System.out.println("SuperClassWithDifferentMethods.method2()");
}
private void method3() {
System.out.println("SuperClassWithDifferentMethods.method3()");
}
private final void method4() {

System.out.println(”SuperClassWithDifferentMethods.method4()”);
}
public static void method5() {
System.out.println(”SuperClassWithDifferentMethods.method5()”);
}
public void method6() throws Exception {
System.out.println(”SuperClassWithDifferentMethods.method6()”);
}
private void method7() {
System.out.println(”SuperClassWithDifferentMethods.method7()”);
}
private void method8(int x) {
System.out.println(”SuperClassWithDifferentMethods.method8()”);
}
public static void method9() {
System.out.println(”SuperClassWithDifferentMethods.method9()”);
}
}

class OverridingClass extends SuperClassWithDifferentMethods {

public int field1 = 30;
public static int field2 = 40;
public void method1() {
System.out.println(”OverridingClass.method1()”);
}
//We can’t override a public final method
/* public final void method2(){

System.out.println(”OverridingClass.method2()”);

}*/
private void method3() {
System.out.println(”OverridingClass.method3()”);
}
private final void method4() {
System.out.println(”OverridingClass.method4()”);
}
public static void method5() {
System.out.println(”OverridingClass.method5()”);
}
public void method6() throws CustomException {
System.out.println(”OverridingClass.method6()”);
}
public void method7() {
System.out.println(”OverridingClass.method7()”);
}
public void method8(final int x) {
System.out.println(”OverridingClass.method8()”);
}
//A static method cannot be overridden to be non-static instance method
/*public void method9() {

System.out.println(”OverridingClass.method9()”);

}*/
}

public class MethodOverridingDemo {

public static void main(String[] args) {
OverridingClass oc1 = new OverridingClass();
SuperClassWithDifferentMethods sc3 = new OverridingClass();
oc1.method1();
oc1.method2();
// Since its private, the below 2 methods are not visible
/* oc1.method3();

oc1.method4();*/
oc1.method5();
try {
oc1.method6();
} catch (CustomException e) {
e.printStackTrace();
}
oc1.method7();
oc1.method8(100);
System.out.println(”oc1.field1 : ” + oc1.field1);
System.out.println(”oc1.field2 : ” + oc1.field2);
System.out.println(”sc3.field1 : ” + sc3.field1);
System.out.println(”sc3.field2 : ” + sc3.field2);
sc3.method5();
OverridingClass overClass = new OverridingClass();
SuperClassWithDifferentMethods supClass = (SuperClassWithDifferentMethods) overClass;
supClass.method5();
supClass.method1();
}
}


Output

OverridingClass.method1()
SuperClassWithDifferentMethods.method2()
OverridingClass.method5()
OverridingClass.method6()
OverridingClass.method7()
OverridingClass.method8()
oc1.field1 : 30
oc1.field2 : 40
sc3.field1 : 10
sc3.field2 : 20
SuperClassWithDifferentMethods.method5()
SuperClassWithDifferentMethods.method5()
OverridingClass.method1()

Download MethodOverridingDemo.java

The new method definitions in the subclass OverridingClass have the same signature and the same return type as the methods in the superclass SuperClassWithDifferentMethods. The new overridden method6 definition specifies a subset of the exceptions (CustomException). The new overridden method7 definition also widens the accessibility to public from private. The overriding method8 also declares the parameter to be final, which is not a part of the method signature and Method Overriding holds good. A static method cannot be overridden to be non-static instance method as shown in the overridden method declaration of method9. A static method is class-specific and not part of any object, while overriding methods are invoked on behalf of objects of the subclass. There are no such restrictions on the fields, as for fields only the field names matter. A final method cannot be overridden, an attempt to which will result in a compile-time error. A private method is not accessible outside the class in which it is defined; therefore, a subclass cannot override it.

A subclass must use the ‘super’ keyword in order to invoke an overridden method in the superclass. A subclass cannot override fields of the superclass, but it can hide them. Code in the subclass can use the keyword super to access members, including hidden fields.

The following distinction between invoking instance methods on an object and accessing fields of an object must be noted. When an instance method is invoked on an object using a reference, it is the class of the current object denoted by the reference, not the type of the reference, that determines which method implementation will be executed. When a field of an object is accessed using a reference, it is the type of the reference, not the class of the current object denoted by the reference, that determines which field will actually be accessed. This is demonstrated in the above program.
Posted by at No comments:

Object typecasting

Object Reference Type Casting

In java object typecasting one object reference can be type cast into another object reference. The cast can be to its own class type or to one of its subclass or superclass types or interfaces. There are compile-time rules and runtime rules for casting in java.

How to Typecast Objects with a dynamically loaded Class ? - The casting of object references depends on the relationship of the classes involved in the same hierarchy. Any object reference can be assigned to a reference variable of the type Object, because the Object class is a superclass of every Java class.
There can be 2 casting java scenarios

· Upcasting
· Downcasting

When we cast a reference along the class hierarchy in a direction from the root class towards the children or subclasses, it is a downcast. When we cast a reference along the class hierarchy in a direction from the sub classes towards the root, it is an upcast. We need not use a cast operator in this case.

The compile-time rules are there to catch attempted casts in cases that are simply not possible. This happens when we try to attempt casts on objects that are totally unrelated (that is not subclass super class relationship or a class-interface relationship) At runtime a ClassCastException is thrown if the object being cast is not compatible with the new type it is being cast to.

Below is an example showing when a ClassCastException can occur during object casting

//X is a supper class of Y and Z which are sibblings.
public class RunTimeCastDemo {

 public static void main(String args[]) {
  X x = new X();
  Y y = new Y();
  Z z = new Z();
  X xy = new Y(); // compiles ok (up the hierarchy)
  X xz = new Z(); // compiles ok (up the hierarchy)
Want to earn money online, click here
  //  Y yz = new Z();   incompatible type (siblings)
  //  Y y1 = new X();   X is not a Y
  //  Z z1 = new X();   X is not a Z
  X x1 = y; // compiles ok (y is subclass of X)
  X x2 = z; // compiles ok (z is subclass of X)
  Y y1 = (Y) x; // compiles ok but produces runtime error
  Z z1 = (Z) x; // compiles ok but produces runtime error
  Y y2 = (Y) x1; // compiles and runs ok (x1 is type Y)
  Z z2 = (Z) x2; // compiles and runs ok (x2 is type Z)
  //  Y y3 = (Y) z;     inconvertible types (siblings)
  //  Z z3 = (Z) y;     inconvertible types (siblings)
  Object o = z;
  Object o1 = (Y) o; // compiles ok but produces runtime error
 }
}


Casting Object References: Implicit Casting using a Compiler

In general an implicit cast is done when an Object reference is assigned (cast) to:

* A reference variable whose type is the same as the class from which the object was instantiated.
An Object as Object is a super class of every Class.
* A reference variable whose type is a super class of the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by the class from which the object was instantiated.
* A reference variable whose type is an interface that is implemented by a super class of the class from which the object was instantiated.

Consider an interface Vehicle, a super class Car and its subclass Ford. The following example shows the automatic conversion of object references handled by the compiler

interface Vehicle {
}
class Car implements Vehicle {
} Want to earn money online, click here

class Ford extends Car {
}

Let c be a variable of type Car class and f be of class Ford and v be an vehicle interface reference. We can assign the Ford reference to the Car variable:
I.e. we can do the following

Example 1
c = f; //Ok Compiles fine

Where c = new Car();
And, f = new Ford();
The compiler automatically handles the conversion (assignment) since the types are compatible (sub class - super class relationship), i.e., the type Car can hold the type Ford since a Ford is a Car.

Example 2
v = c; //Ok Compiles fine
c = v; // illegal conversion from interface type to class type results in compilation error

Where c = new Car();
And v is a Vehicle interface reference (Vehicle v)

The compiler automatically handles the conversion (assignment) since the types are compatible (class – interface relationship), i.e., the type Car can be cast to Vehicle interface type since Car implements Vehicle Interface. (Car is a Vehicle).

Casting Object References: Explicit Casting

Sometimes we do an explicit cast in java when implicit casts don’t work or are not helpful for a particular scenario. The explicit cast is nothing but the name of the new “type” inside a pair of matched parentheses. As before, we consider the same Car and Ford Class

class Car {
void carMethod(){
}
} Want to earn money online, click here

class Ford extends Car {
void fordMethod () {
}
}

We also have a breakingSystem() function which takes Car reference (Superclass reference) as an input parameter.
The method will invoke carMethod() regardless of the type of object (Car or Ford Reference) and if it is a Ford object, it will also invoke fordMethod(). We use the instanceof operator to determine the type of object at run time.

public void breakingSystem (Car obj) {
obj.carMethod();
if (obj instanceof Ford)
Want to earn money online, click here

((Ford)obj).fordMethod ();
}

To invoke the fordMethod(), the operation (Ford)obj tells the compiler to treat the Car object referenced by obj as if it is a Ford object. Without the cast, the compiler will give an error message indicating that fordMethod() cannot be found in the Car definition.


The following program shown illustrates the use of the cast operator with references.

Note: Classes Honda and Ford are Siblings in the class Hierarchy. Both these classes are subclasses of Class Car. Both Car and HeavyVehicle Class extend Object Class. Any class that does not explicitly extend some other class will automatically extends the Object by default. This code instantiates an object of the class Ford and assigns the object’s reference to a reference variable of type Car. This assignment is allowed as Car is a superclass of Ford. In order to use a reference of a class type to invoke a method, the method must be defined at or above that class in the class hierarchy. Hence an object of Class Car cannot invoke a method present in Class Ford, since the method fordMethod is not present in Class Car or any of its superclasses. Hence this problem can be colved by a simple downcast by casting the Car object reference to the Ford Class Object reference as done in the program. Also an attempt to cast an object reference to its Sibling Object reference produces a ClassCastException at runtime, although compilation happens without any error.


class Car extends Object {

 void carMethod() {
 }
}

class HeavyVehicle extends Object {
}

class Ford extends Car {
Want to earn money online, click here

 void fordMethod() {
  System.out.println(”I am fordMethod defined in Class Ford”);
 }
}

class Honda extends Car {

 void fordMethod() {
  System.out.println(”I am fordMethod defined in Class Ford”);
 }
}

public class ObjectCastingEx {

 public static void main(String[] args) {
  Car obj = new Ford();
  //    Following will result in compilation error
  //    obj.fordMethod(); //As the method fordMethod is undefined for the Car Type
  //  Following will result in compilation error
  // ((HeavyVehicle)obj).fordMethod();
Want to earn money online, click here
     //fordMethod is undefined in the HeavyVehicle Type
  //  Following will result in compilation error
  ((Ford) obj).fordMethod();
  //Following will compile and run
  // Honda hondaObj = (Ford)obj; Cannot convert as they are sibblings
 }
}

One common casting that is performed when dealing with collections is, you can cast an object reference into a String.

import java.util.Vector;

public class StringCastDemo {

 public static void main(String args[]) {
  String username = “asdf”;
  String password = “qwer”;
  Vector v = new Vector();
  v.add(username);
  v.add(password);
  //               String u = v.elementAt(0); Cannot convert from object to String
  Object u = v.elementAt(0); //Cast not done
Want to earn money online, click here
  System.out.println(”Username : ” + u);
  String uname = (String) v.elementAt(0); // cast allowed
  String pass = (String) v.elementAt(1); // cast allowed
  System.out.println();
  System.out.println(”Username : ” + uname);
  System.out.println(”Password : ” + pass);
 }
}



Output

Username : asdf
Username : asdf
Password : qwer

instanceof Operator

The instanceof operator is called the type comparison operator, lets you determine if an object belongs to a specific class, or implements a specific interface. It returns true if an object is an instance of the class or if the object implements the interface, otherwise it returns false.

Below is an example showing the use of instanceof operator

class Vehicle {

 String name;
 Vehicle() {
  name = "Vehicle";
 }
}

class HeavyVehicle extends Vehicle {

 HeavyVehicle() {
  name = "HeavyVehicle";
 }
}

class Truck extends HeavyVehicle {

 Truck() {
Want to earn money online, click here
  name = "Truck";
 }
}

class LightVehicle extends Vehicle {

 LightVehicle() {
  name = "LightVehicle";
 }
}

public class InstanceOfExample {

 static boolean result;
 static HeavyVehicle hV = new HeavyVehicle();
 static Truck T = new Truck();
 static HeavyVehicle hv2 = null;
 public static void main(String[] args) {
  result = hV instanceof HeavyVehicle;
  System.out.print(”hV is an HeavyVehicle: ” + result + “\n”);
  result = T instanceof HeavyVehicle;
  System.out.print(”T is an HeavyVehicle: ” + result + “\n”);
  result = hV instanceof Truck;

Want to earn money online, click here

  System.out.print(”hV is a Truck: ” + result + “\n”);
  result = hv2 instanceof HeavyVehicle;
  System.out.print(”hv2 is an HeavyVehicle: ” + result + “\n”);
  hV = T; //Sucessful Cast form child to parent
  T = (Truck) hV; //Sucessful Explicit Cast form parent to child
 }
}

Output

hV is an HeavyVehicle: true
T is an HeavyVehicle: true
hV is a Truck: false
hv2 is an HeavyVehicle: false

Posted by at No comments:

Interfaces

Java Interface

In Java, this multiple inheritance problem is solved with a powerful construct called interfaces. Interface can be used to define a generic template and then one or more abstract classes to define partial implementations of the interface. Interfaces just specify the method declaration (implicitly public and abstract) and can only contain fields (which are implicitly public static final). Interface definition begins with a keyword interface. An interface like that of an abstract class cannot be instantiated.

Multiple Inheritance is allowed when extending interfaces i.e. one interface can extend none, one or more interfaces. Java does not support multiple inheritance, but it allows you to extend one class and implement many interfaces.

If a class that implements an interface does not define all the methods of the interface, then it must be declared abstract and the method definitions must be provided by the subclass that extends the abstract class.

Example 1: Below is an example of a Shape interface

interface Shape {

 public double area();
 public double volume();
}

Below is a Point class that implements the Shape interface.

public class Point implements Shape {

 static int x, y;
 public Point() {
  x = 0;
  y = 0;
 }
 public double area() {
  return 0;
 }
 public double volume() {
  return 0;
 }

want to earn money online, click

 public static void print() {
  System.out.println(”point: ” + x + “,” + y);
 }
 public static void main(String args[]) {
  Point p = new Point();
  p.print();
 }
}

Similarly, other shape objects can be created by interface programming by implementing generic Shape Interface.

Example 2: Below is a java interfaces program showing the power of interface programming in java

Listing below shows 2 interfaces and 4 classes one being an abstract class.
Note: The method toString in class A1 is an overridden version of the method defined in the class named Object. The classes B1 and C1 satisfy the interface contract. But since the class D1 does not define all the methods of the implemented interface I2, the class D1 is declared abstract.
Also,
i1.methodI2() produces a compilation error as the method is not declared in I1 or any of its super interfaces if present. Hence a downcast of interface reference I1 solves the problem as shown in the program. The same problem applies to i1.methodA1(), which is again resolved by a downcast.

When we invoke the toString() method which is a method of an Object, there does not seem to be any problem as every interface or class extends Object and any class can override the default toString() to suit your application needs. ((C1)o1).methodI1() compiles successfully, but produces a ClassCastException at runtime. This is because B1 does not have any relationship with C1 except they are “siblings”. You can’t cast siblings into one another.

When a given interface method is invoked on a given reference, the behavior that results will be appropriate to the class from which that particular object was instantiated. This is runtime polymorphism based on interfaces and overridden methods.

interface I1 {

 void methodI1(); // public static by default
}

interface I2 extends I1 {

 void methodI2(); // public static by default
}

class A1 {

want to earn money online, click

 public String methodA1() {
  String strA1 = "I am in methodC1 of class A1";
  return strA1;
 }
 public String toString() {
  return "toString() method of class A1";
 }
}

class B1 extends A1 implements I2 {

 public void methodI1() {
  System.out.println("I am in methodI1 of class B1");
 }
 public void methodI2() {
  System.out.println("I am in methodI2 of class B1");
 }
}

class C1 implements I2 {

 public void methodI1() {
  System.out.println("I am in methodI1 of class C1");
 }
 public void methodI2() {
  System.out.println("I am in methodI2 of class C1");
 }
}

// Note that the class is declared as abstract as it does not
// satisfy the interface contract
abstract class D1 implements I2 {

 public void methodI1() {
 }
 // This class does not implement methodI2() hence declared abstract.
}

public class InterFaceEx {

 public static void main(String[] args) {
  I1 i1 = new B1();
  i1.methodI1(); // OK as methodI1 is present in B1
  // i1.methodI2(); Compilation error as methodI2 not present in I1
want to earn money online, click
  // Casting to convert the type of the reference from type I1 to type I2
  ((I2) i1).methodI2();
  I2 i2 = new B1();
  i2.methodI1(); // OK
  i2.methodI2(); // OK
  // Does not Compile as methodA1() not present in interface reference I1
  // String var = i1.methodA1();
  // Hence I1 requires a cast to invoke methodA1
  String var2 = ((A1) i1).methodA1();
  System.out.println(”var2 : ” + var2);
  String var3 = ((B1) i1).methodA1();
  System.out.println(”var3 : ” + var3);
  String var4 = i1.toString();
  System.out.println(”var4 : ” + var4);
  String var5 = i2.toString();
  System.out.println(”var5 : ” + var5);
  I1 i3 = new C1();
  String var6 = i3.toString();
  System.out.println(”var6 : ” + var6); // It prints the Object toString() method
  Object o1 = new B1();
  // o1.methodI1(); does not compile as Object class does not define
  // methodI1()
  // To solve the probelm we need to downcast o1 reference. We can do it
  // in the following 4 ways
  ((I1) o1).methodI1(); // 1
  ((I2) o1).methodI1(); // 2
  ((B1) o1).methodI1(); // 3
  /*
   *
   * B1 does not have any relationship with C1 except they are “siblings”.
   *
   * Well, you can’t cast siblings into one another.
   *
   */
  // ((C1)o1).methodI1(); Produces a ClassCastException
 }
}

Output

I am in methodI1 of class B1
I am in methodI2 of class B1
I am in methodI1 of class B1
I am in methodI2 of class B1
var2 : I am in methodC1 of class A1
var3 : I am in methodC1 of class A1
var4 : toString() method of class A1
var5 : toString() method of class A1
var6 : C1@190d11
I am in methodI1 of class B1
I am in methodI1 of class B1
I am in methodI1 of class B1


Polymorphism

Polymorphism means one name, many forms. There are 3 distinct forms of Java Polymorphism;

  • Method overloading (Compile time polymorphism)
  • Method overriding through inheritance (Run time polymorphism)
  • Method overriding through the Java interface (Run time polymorphism)

    Polymorphism allows a reference to denote objects of different types at different times during execution. A super type reference exhibits polymorphic behavior, since it can denote objects of its subtypes.

interface Shape {

 public double area();
 public double volume();
}

class Cube implements Shape {

 int x = 10;
 public double area( ) {

     return (6 * x * x);
 } 

 public double volume() {
  return (x * x * x);
 }

}

class Circle implements Shape {

 int radius = 10;
 public double area() {
  return (Math.PI * radius * radius);
want to earn money online, click
 }
 public double volume() {
  return 0;
 }
}

public class PolymorphismTest {

 public static void main(String args[]) {
  Shape[] s = { new Cube(), new Circle() };
  for (int i = 0; i < s.length; i++) {
   System.out.println(”The area and volume of ” + s[i].getClass()
     + ” is ” + s[i].area() + ” , ” + s[i].volume());
  }
 }
}

Output

The area and volume of class Cube is 600.0 , 1000.0
The area and volume of class Circle is 314.1592653589793 , 0.0

The methods area() and volume() are overridden in the implementing classes. The invocation of the both methods area and volume is determined based on run time polymorphism of the current object as shown in the output.

Interface vs Abstract Class

Interface vs Abstract Class

1. Abstract class is a class which contain one or more abstract methods, which has to be implemented by sub classes. An abstract class can contain no abstract methods also i.e. abstract class may contain concrete methods. A Java Interface can contain only method declarations and public static final constants and doesn’t contain their implementation. The classes which implement the Interface must provide the method definition for all the methods present.

2. Abstract class definition begins with the keyword “abstract” keyword followed by Class definition. An Interface definition begins with the keyword “interface”.

3. Abstract classes are useful in a situation when some general methods should be implemented and specialization behavior should be implemented by subclasses. Interfaces are useful in a situation when all its properties need to be implemented by subclasses

4. All variables in an Interface are by default - public static final while an abstract class can have instance variables.

5. An interface is also used in situations when a class needs to extend an other class apart from the abstract class. In such situations its not possible to have multiple inheritance of classes. An interface on the other hand can be used when it is required to implement one or more interfaces. Abstract class does not support Multiple Inheritance whereas an Interface supports multiple Inheritance.

6. An Interface can only have public members whereas an abstract class can contain private as well as protected members.

7. A class implementing an interface must implement all of the methods defined in the interface, while a class extending an abstract class need not implement any of the methods defined in the abstract class.

8. The problem with an interface is, if you want to add a new feature (method) in its contract, then you MUST implement those method in all of the classes which implement that interface. However, in the case of an abstract class, the method can be simply implemented in the abstract class and the same can be called by its subclass

9. Interfaces are slow as it requires extra indirection to to find corresponding method in in the actual class. Abstract classes are fast

10.Interfaces are often used to describe the peripheral abilities of a class, and not its central identity, E.g. an Automobile class might
implement the Recyclable interface, which could apply to many otherwise totally unrelated objects.

Note: There is no difference between a fully abstract class (all methods declared as abstract and all fields are public static final) and an interface.

Note: If the various objects are all of-a-kind, and share a common state and behavior, then tend towards a common base class. If all they
share is a set of method signatures, then tend towards an interface.

Similarities:

Neither Abstract classes nor Interface can be instantiated.

Posted by at No comments:
Subscribe to: Posts (Atom)