class SuperClass
{
public static void main(String a[])
{
<code>;
try
{
<code>;
try
{
<code>;
}
catch( <var>)
{
<code>;
}
}
catch( <var>)
{
<code>;
}
}
}

• 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:

Exception-Handling related Tutorial Article

1. Java Tutorial : Exception Handling
2. Java Tutorial : Exception Classes
3. Java Tutorial : Built-in Exceptions
4. Java Tutorial : Implementing Exception Handling
5. Java Tutorial : Implementing Exception Handling – Part 2
6. Java Tutorial : Throwing An Exception – Part 1
7. Java Tutorial : Throwing An Exception – Part 2
8. Implementing User Defined Exceptions
9. Java Tutorial : Assertion In Java