Converting C++ Abstract Classes into Java Interfaces

By: Baski Emailed: 1768 times Printed: 2516 times    

Latest comments
By: rohit kumar - how this program is work
By: Kirti - Hi..thx for the hadoop in
By: Spijker - I have altered the code a
By: ali mohammed - why we use the java in ne
By: ali mohammed - why we use the java in ne
By: mizhelle - when I exported the data
By: raul - no output as well, i'm ge
By: Rajesh - thanx very much...
By: Suindu De - Suppose we are executing

One of the most innovative aspects of Java is the interface. An interface specifies the form of its various methods without specifying any implementation details. Each class that implements an interface does so by creating the actual methods declared by the interface. Thus, in Java an interface is the means by which you can define the general form of a class while ensuring that all specific versions of the class conform to the same set of rules. The interface is one of the ways that Java provides support for polymorphism.

In C++, there is no direct parallel to the interface. Instead, in C++, if you wish to define the form of a class without defining implementation details, you must do so by using an abstract class. Abstract classes in C++ are similar to abstract classes in Java: they do not contain a full set of implementation details. In C++, an abstract class contains at least one pure virtual function. A pure virtual function defines no implementation; it only defines the function prototype. Thus, a pure virtual function in C++ is essentially the same as an abstract method in Java. In C++, abstract classes serve a function similar to interfaces in Java. For this reason, they are one of the items that you will want to watch for when converting code to Java. While not all C++ abstract classes can be converted into Java interfaces, many can. Let's look at two examples.

Here is a short C++ program that uses an abstract class called IntList to define the form of an integer list. An implementation of this class is created by IntArray, which uses an array to implement a list of integers.

// A C++-style abstract class and its implementation.
#include <iostream>
#include <cstdlib>
using namespace std;
// An abstract class that defines the form of an integer list.
class IntList {
public:
virtual int getNext() = 0; // pure virtual functions
virtual void putOnList(int i) = 0;
};
// Create an implementation of an integer list.
class IntArray : public IntList {
int storage[100];
int putIndex, getIndex;
public:
IntArray() {
putIndex = 0;
getIndex = 0;
}
// Return next integer in list.
int getNext() {
if(getIndex >= 100) {
cout << "List Underflow";
exit(1);
}
getIndex++;
return storage[getIndex-1];
}
// Put an integer on the list.
void putOnList(int i) {
if(putIndex < 100) {
storage[putIndex] = i;
putIndex++;
}
else {
cout << "List Overflow";
exit(1);
}
}
};
int main()
{
IntArray nums;
int i;
for(i=0; i<10; i++) nums.putOnList(i);
for(i=0; i<10; i++)
cout << nums.getNext() << endl;
return 0;
}

In this program, the abstract class IntList defines only the form of an integer list. It contains only pure virtual functions and does not declare any data. For these reasons, it can be made into an interface when the program is converted into Java, as shown here:

// Here, IntList is made into an interface which IntArray
implements.
// Define interface for an integer list.
interface IntListIF {
int getNext();
void putOnList(int i);
}
// Create an implementation of an integer list.
class IntArray implements IntListIF {
private int storage[];
private int putIndex, getIndex;
IntArray() {
storage = new int[100];
putIndex = 0;
getIndex = 0;
}
// Create an implementation of an integer list.
public int getNext() {
if(getIndex >= 100) {
System.out.println("List Underflow");
System.exit(1);
}
getIndex++;
return storage[getIndex-1];
}
// Put an integer on the list.
public void putOnList(int i) {
if(putIndex < 100) {
storage[putIndex] = i;
putIndex++;
}
else {
System.out.println("List Overflow");
System.exit(1);
}
}
}
class ListDemo {
public static void main(String args[]) {
IntArray nums = new IntArray();
int i;
for(i=0; i<10; i++) nums.putOnList(i);
for(i=0; i<10; i++)
System.out.println(nums.getNext());
}
}

As you can see, there is nearly a one-to-one correspondence between the C++ abstract class IntList and the Java interface IntListIF. It is possible to convert IntList into IntListIF because it contained only pure virtual functions. This is the key. If IntList had contained any data or function implementations, then it would not have qualified for conversion into an interface.

When you convert or adapt C++ code into Java, look for examples of abstract classes that contain only pure virtual functions. These are prime candidates for conversion to Java interfaces. But don't overlook abstract C++ classes that contain a small number of implemented functions or data. It is possible that these items don't really belong in the abstract class to begin with and should be defined by individual implementations. Since C++ does not define an interface construct, there was no reason for C++ programmers to think in terms of one.

Sometimes a concrete member is contained in an otherwise abstract class simply for expedience—not because it is the most logical place for it. For example, consider the following abstract C++ class:

// An abstract C++ class.
class SomeClass {
bool isOK;
public:
virtual int f1() = 0;
virtual void f2(int i) = 0;
virtual double f3() = 0;
virtual int f4(int a, char ch) = 0;
};

The only reason that this class cannot be made into a Java interface is the existence of isOK. Presumably, isOK is used to indicate some status associated with the class. However, if you think about it, there really is no reason for isOK to be defined as a variable. Instead, you could specify a method called isOK( ) that returns the status. In this approach, isOK( ) will be defined, along with the other methods, by any implementing class. Thus, you could convert the preceding C++ abstract class into the following Java interface:

interface SomeClass {
int f1();
void f2(int i);
double f3();
int f4(int a, char ch);
boolean isOK();
}

Many abstract classes in C++ can—and should—be converted into interfaces when you move code to Java. In doing so, you will probably find that it clarifies the structure of the class hierarchy.


C++ Home | All C++ Tutorials | Latest C++ Tutorials

Sponsored Links

If this tutorial doesn't answer your question, or you have a specific question, just ask an expert here. Post your question to get a direct answer.



Bookmark and Share

Comments(0)


Be the first one to add a comment

Your name (required):


Your email(required, will not be shown to the public):


Your sites URL (optional):


Your comments:



More Tutorials by Baski
Compiling multiple source files and specifying classpath using javac
The equals() Method example in Java
Default Values for Data Types in Java
JSP Example to connect to MS SQL database using Tomcat Connection Pool
<convertNumber> and <convertDateTime> in JSF
Enable/Disable Scripting Elements in JSP
Using calloc() Function in C
lseek() sample program in C
Arrays of Structures example program in C
The Basic Syntax Expression Language in JSP
Initialization of Pointer Arrays in C
Functions returning non-integer values in C
Increment and Decrement Operators in C
Getting Started with C
What is JSF (JavaServer Faces)?

More Tutorials in C++
Two-Dimensional Array Manipulation in C++
Calculate average using Two-Dimensional Array in C++
Compute the square root of the sum of the squares of an array in C++
Matrix using nested for loops in C++
Sorting an array of Strings in C++
Calculating total based on the given quantity and price in C++
Compiling and Linking Multiple Source Files in C++
Enumerations in C++
Program to add two numbers in C++
Comments in C++
while loop in C++
for loop in C++
Programming errors a compiler will detect in C++
if in C++
Using the Built-in Arithmetic Types in C++

More Latest News
Most Viewed Articles (in C++ )
The Stack and the Free Store in C++
Getting User Input Using cin in C++
Calculating total based on the given quantity and price in C++
Using Comments in a C++ Program
do...while Loops in C++
for Loops in C++
Using switch Statements in C++
The indirection operator (*) - dereference operator.
Dot (.) vs Arrow (->) to access data members in C++
Converting Pointer Parameters in C++ to Java
Converting C++ Abstract Classes into Java Interfaces
Converting C++ Multiple-Inheritance Hierarchies to Java
C++ Destructors Versus Java Finalization
Operator Precedence in C++
atoi(), itoa() in C++
Most Emailed Articles (in C++)
Demonstrating global and local variables in C++
C++ and Object-Oriented Programming
Using cout in C++
Use of Conditional (Ternary) Operator in C++
const Member Functions in C++
Classes with Other Classes as Member Data in C++
What Is a Pointer in C++?
Manipulating Data by Using Pointers
Stray or Dangling Pointers in C++
C++ Destructors Versus Java Finalization
atoi(), itoa() in C++
strcat() and strncat() sample program in C++
Using #define, The Preprocessor and the Compiler in C++
Getting User Input Using cin in C++
Pass by Reference in C++ functions