• superclass constructors
• superclass methods and variables

Consider a Java application, which consists of multiple classes. The subclass in the application needs to reuse the constructor of the superclass. In this application, super keyword is used as a method and invokes the constructor of its immediate superclass. The syntax to invoke the constructor of a superclass using the super() method is:

super (<parameter1>, <parameter 2>,..,<parameterN>);

In the above syntax, <parameter1>, <parameter 2>,..,<parameterN> refer to the list of parameters that you need to pass to the constructor of the superclass.

If no parameters are passed to the super() method, it invokes the default constructor of the superclass. If the superclass contains the overloaded constructor, you can pass parameters to the super() method to invoke a particular constructor. When you use the super() method in the constructor of the subclass, it should be the first executable statement in the constructor.

Consider a Java application, in which both, superclass and subclass, have member variables with the same name. In this application, the super keyword is used to access the member variables of the superclass. The syntax to access the member variable of a superclass is:

super.<variable>;

The subclass can also access the member methods of the superclass using the super keyword. The following code snippet shows the Literature subclass accessing the member variable of the Book superclass:

class Book
{
int categoryCode;
}
class Literature extends Book
{
int categoryCode;
public void input(int c1, int c2)
{
super.categoryCode=c1;
categoryCode=c2;
}
}

In the above code snippet, the Book class contains the categoryCode variable to store the category of a book, such as literature, science, fiction, suspense, and history. The Literature class also contains the categoryCode variable to store the subcategory of a book. For example for literature category, the subcategories are English, French, Hindi, and Russian. The input() method accepts two values for c1 and c2 variables. The value that you pass for c1 variable is assigned to the superclass variable whereas the value of the c2 variable is assigned to the subclass variable. The this keyword is used to refer to the current object. You can use the this keyword when a method defined in a Java class needs to refer to the object used to invoke that method, as shown in the following code snippet:

Book(int bcode, double bprice)
{
this.bookCode=bcode;
this.bookPrice=bprice;
}

In the above code snippet, the this keyword refers to the object that invokes the Book() constructor.

Another situation where you can use the this keyword is when the local and instance variables have the same name. For example, the Book class has two member variables, bookCode and bookPrice. The constructor of the Book class is used to initialize its member. If the formal parameters passed to the constructor have the same name as instance variables, you need to use the this keyword to refer to the
instance variables. The following code snippet shows how to use the this keyword when instance and formal parameters have the same name:

Book(int bcode, double bprice)
{
this.bcode=bcode;
this.bprice=bprice;
}

In the above code snippet, this keyword refers to the instance variables, bcode and bprice. The values of the formal parameters, bcode and bprice of the Book() constructor are assigned to the instance variables.

In addition, you can use the this keyword in a constructor of a class to invoke another constructor of the class. Unlike the super keyword, the this keyword can invoke the constructor of the same class. The following code snippet shows how to invoke a constructor using the this keyword:

class Book
{
public Book(String bname)
{
this(bname, 1001);
}
public Book(String bname, int bcode)
{
bookName=bname;
bookCode=bcode;
}
}

The application consists of an interface, ItemCount that includes the declaration of methods to be used in the superclass and subclass. The application includes the SoftwareProducts class that accepts the number of software items and calculates the
number.

The HardwareProducts class is included to accept the number of hardware items and to calculate the number. The Products class is included to create objects for the SoftwareProducts and HardwareProducts classes.
You can use the following code to create the ItemCount interface in Java:

interface ItemCount //Defining the interface.
{
//Defining abstract methods in the Billing interface.
public void noOfItems();
}

In the preceding code, the ItemCount interface contains the noOfItems() abstract method that needs to be implemented in the classes that implement the ItemCount interface.
You can use the following code to create the SoftwareProducts superclass:

class SoftwareProducts implements ItemCount
{
// Defining the data members.
int os= 60;
int oracle = 20;
int jav = 15;
int tot;
//Defining the methods.
public void calculate()
{
tot = os + oracle + jav;
}
public void noOfItems() // Method declared publicly in the interface.
{
System.out.println();
System.out.println(” “+”Total number of software products purchased is :
“+ tot);}
}

In the preceding code, the SoftwareProducts superclass defines the data members, os, oracle, and jav and the methods, calculate() and noOfItems(). These data members store the number of software products, Operating System, Oracle, and Java. The noOfItems() method displays the total number of the software items purchased by David.
You can use the following code to create the HardwareProducts class:

class HardwareProducts implements ItemCount
{
// Defining the data members.
int printer = 20;
int speaker = 12;
int harddisk = 25;
int htot;
public void calculate1()
{
htot = printer + speaker + harddisk;
}
public void noOfItems()// The method is declared publicly in the
interface, Billing.
{
System.out.println();
System.out.println(” “+”Total number of hardware items purchased is : ”
+htot);
}}
class Products
{
public static void main(String args[])
{
//Creating an object of the class, Hardware.
SoftwareProducts s = new SoftwareProducts();
HardwareProducts h = new HardwareProducts();
s.calculate();
h.calculate1();
s.noOfItems();
h.noOfItems();
}}

In the preceding code, the HardwareProducts subclass implements the ItemCount interface. The HardwareProducts class defines the data members, such as printer, speaker, and hard disk. These data members store the number of printer, speaker, and hard disk. The HardwareProducts class defines the calculate1() method to calculate the total number of hardware items. The noOfItems() method displays the total number of hardware items purchased by David.
The following figure shows the output of the preceding code:

Using Interface to Display the Number of Items Purchased

Interfaces also enable you to declare constants that can be imported into multiple classes. The constant values declared in an interface can be implemented in any class. The constants defined in an interface are declared using the final keyword. You can use the following code to create the TBooks interface in Java:

interface TBooks
{
//Defining constants in an interface.
final int cd =10;
final int book =5;
}

In the preceding code, the TBooks interface declares a set of constants that stores the number of books and Compact Discs (CD) purchased.
You can use the following code to create the Dcd class:

class Dcd implements TBooks
{
void display()
{
System.out.println(” “);
System.out.println(“\t The number of purchased CD’s are :” + cd);
System.out.println(” “);
}
}
In the preceding code, the Dcd class implements the TBooks interface to display the
number of purchased CDs.
You can use the following code to create the DBooks class:
class DBooks extends Dcd implements TBooks
{
void display1()
{
System.out.println(“\t The number of purchased books are :” + book);
System.out.println(“\t The number of purchased CD’s are :” + cd);
System.out.println(” “);
}
public static void main (String args[])
{
// Creating an instance of DBooks class.
DBooks db = new DBooks();
TBooks t;
t = db;
db.display1();
}}

In the preceding code, the DBooks subclass extends from the Dcd superclass and implements the TBooks interface. The display1() method displays the number of purchased books and CDs using inheritance.
The following figure shows the output of the preceding code:

Number of Purchased CDs and Books

]]> http://www.rockingteam.com/2010/01/java-tutorial-implementing-interfaces-example/feed/ 1 http://www.rockingteam.com/2009/12/implementing-user-defined-exceptions/ http://www.rockingteam.com/2009/12/implementing-user-defined-exceptions/#comments Thu, 03 Dec 2009 09:03:24 +0000 Alex Jose http://www.rockingteam.com/2009/11/implementing-user-defined-exceptions/ In addition to the built-in exceptions, you can create customized exception as per the application requirements. Each application that you create might have specific constraints.

For example, in case of a train reservation application, a passenger must specify the destination. Also, a ticket has to be bought for a passenger who is above three years of age.

Similarly, in the case of a banking application, if a customer is below 18 years of age, he is allowed to open a joint account only. Error handling becomes a necessity while developing applications that account for such constraints. The Exception class or its subclasses in Java do not address these application specific constraints. You can create your own exception classes to address these constraints and ensure the integrity of application data.

Creating and Handling User-defined Exceptions

The throw, throws, try, catch, and finally keywords are used while implementing userdefined exceptions. The Exception class inherits all the methods provided by the Throwable class. The user-defined Exception class also inherits the methods defined in the Throwable class. The following table lists the methods defined by the Throwable class:

You can use the following code to create a user-defined exception to catch the exception raised when the sum of two numbers exceeds 20:

class UserException extends Exception
{
int num1,num2,sum;
UserException(int a,int b)
{
num1 = a; num2 = b; sum = a + b;}
public String toString()
{
return "UserException Caught: The sum of the numbers Exceeds
20.."; }
}
class UserExceptionDemo
{
static void calculate(int a,int b) throws UserException
{
int sum;
System.out.println("Calculate Method(" + a + "," + b +
")");
sum=a+b;
if(sum>20)
throw new UserException(a,b);
System.out.println("The Value of the sum of two numbers
is:" + sum);
}
public static void main(String args[])
{
try
{
calculate(12,1);
calculate(15,7);
}
catch (UserException Obja)
1B.42 Programming in Java
{
System.out.println("Caught:" + Obja);
}
}
}

In the preceding code, the UserException subclass of the Exception class is created. The UserException class has one constructor, UserException() and the toString() method that returns a string containing the description of the exception. The UserExceptionDemo class defines the calculate() method that throws an object of the user-defined exception, UserException. The exception is thrown when the sum of two numbers passed as parameters to the calculate() method exceeds 20.

The output of the preceding code is:

• Java Tutorial : Throwing An Exception – Part 1

Printing a Stack Trace

When an exception is caught, you can find out the method or the line of the code where the exception is raised by using the printStackTrace() method. You can call the printStackTrace() method for printing the stack trace. The objects of the Throwable class inherit the stack trace. You can use the following code to print the stack trace for the ArithmeticException exception:

class PrintStack
{
public static void main(String args[])
{
int Num1= 30 , Num2 = 0;
try
{
int Num3=Num1/Num2;
}
catch(ArithmeticException obj)
{
obj.printStackTrace();
}
}
}

In the preceding code, printStackTrace() method is used to print the stack trace to check the line in the code where the exception is raised.

Using the printStackTrace Statement

The output of the preceding code is:

Rethrowing an Exception

A catch block can rethrow an exception without handling it by using the throw statement. Exceptions are rethrown if a method causing the error wants to pass the error handling responsibilities to the exception-handlers in some other methods. You can use the following code snippet to rethrow an exception:

catch(Exception e)
{
System.out.println(“Exception Raised”);
throw e;
}

The exception goes to the catch block of the next higher context ignoring the catch blocks of the same try block.

You can use the following code to catch the NullPointerException and rethrow the exception to the outer handler:

class RethrowException
{
static void throwDemo()
{
try
{
throw new NullPointerException (“My Exception”);
}
catch(NullPointerException e)
{
System.out.println(“Exception caught in throwDemo()
method”);
throw e; // Rethrow the Exception.
}
}
public static void main(String args[])
{
try
{
throwDemo();
}
catch(NullPointerException e)
{
System.out.println(“Exception caught:” + e);
}
}
}

In the preceding code, the catch block in the throwDemo() method rethrows the NullPointer exception to the catch block defined in the main() method. The output of the preceding code is:

Rethrowing an Exception

Using the throws Statement

The throws statement is used by a method to specify the types of exceptions the method throws. If a method is capable of raising an exception that it does not handle, the method must specify that the exception have to be handled by the calling method. This is done using the throws statement. The throws clause lists the types of exceptions that a method might throw. The following syntax shows how to declare a method that specifies a throws clause:
[<access_specifier>] [<modifier>] <return_type> <method_name>
[<arg_list>] [throws <exception_list>]
You can use the following code to throw the ClassNotFoundException exception:

class NoClassexception
{
static void throwMethod()
{
System.out.println(“In throwMethod”);
throw new ClassNotFoundException();
}
public static void main(String args[])
{
throwMethod();
// no try and catch statements to handle the exception
}
}

In the preceding code, the code does not compile because the caller method throws an exception but does not catch the exception. You can compile the code by first declaring that the throwMethod() throws the ClassNotFoundException exception. In addition, the main() method must define the try-catch statements to catch the exception. You can use the following code to use the throws statement:

class ThrowsClass
{
static void throwMethod() throws ClassNotFoundException
{
System.out.println(“In throwMethod”);
throw new ClassNotFoundException();
}
public static void main(String args[])
{
try
{
throwMethod();
}
catch(ClassNotFoundException Obja)
{
System.out.println(“throwMethod has thrown an
Exception:” + Obja);
}
}
}

The output of the preceding code is:

Using the Throws Statement

Using the throw Statement

The throw statement causes termination of the normal flow of control of the Java code and stops the execution of the subsequent statements if an exception is thrown when the throw statement is executed. The throw clause transfers the control to the nearest catch block handling the type of exception object throws. If no such catch block exists, the program terminates. The throw statement accepts a single argument, which is an object of the Exception class.

The following syntax shows how to declare the throw statement:

throw ThrowableObj

In the preceding syntax, ThrowableObj is an object of the Throwable class or a subclass of the Throwable class, such as Exception class. The ThrowableObj object is created using the new operator. The Java compiler gives an error if the ThrowableObj object does not belong to a valid Exception class. You can use the following code to throw the IllegalStateException exception:

class ThrowStatement
{
static void throwDemo()
{
try
{
throw new IllegalStateException();
// creating and throwing an object of the
IllegalStateException class.
}
catch(NullPointerException objA)
{
System.out.println(“Not caught by catch block inside
throwDemo().”);
}
}
public static void main(String args[])
{
try
{
throwDemo();
}
catch(IllegalStateException objB)
{
// catching an object of the
IllegalStateException class.
System.out.println(” Exception Caught in :” + objB);
}
}
}

In the preceding code, the new operator is used to construct an object of IllegalStateException. In the throwDemo() method , an exception of the type IllegalStateException is thrown.

The output of the preceding code is:

Using the Throw Statement

Displaying the Description of an Exception

The built-in exception classes in Java have two types of constructors: one with no parameter and another with a String parameter that defines the exception. The String parameter that you pass to the constructor of an exception can be displayed when exception object is passed as an argument to the System.out.println() statement. The following code shows the use of constructor of the IlegalStateException with String parameter:

class ThrowClass
{
static void throwDemo()
{
try
{
throw new IllegalStateException(“MyException”);
}
catch(IllegalStateException objA)
{
System.out.println(“Caught:” + objA);
}
} // End of throwDemo() method.
public static void main(String args[])
{
throwDemo();
}
}// End of the ThrowClass.

In the preceding code, description added to the constructor of the IllegalStateException exception is displayed as MyException.

The output of the preceding code is:

Displaying the Description of an Exception