Interfaces in Other Languages

Interfaces in C++ are implemented using abstract classes with pure virtual functions, while languages like Java provide a dedicated interface keyword.

Here are some key differences between C++ and Java interfaces:

C++ Interfaces (Abstract Classes)

Syntax: In C++, interfaces are created using abstract classes with pure virtual functions.

1class IShape {
2public:
3  virtual void Draw() = 0; 
4};

Multiple Inheritance: C++ allows a class to implement multiple interfaces using multiple inheritance.

1class Circle
2: public IShape, public IOtherInterface {
3public:
4  void Draw() override {
5    // Implementation
6  }
7};

Implementation: C++ interfaces can include non-pure virtual functions with implementations, providing default behavior.

1class IShape {
2public:
3  virtual void Draw() = 0;
4  virtual void Print() {
5    std::cout << "Shape\n"; 
6  }
7};

No Interface Keyword: C++ does not have a specific keyword for interfaces; abstract classes serve this purpose.

Java Interfaces

Syntax: Java provides a specific interface keyword to define interfaces.

1public interface Shape {
2  void draw(); 
3}

Single Inheritance with Implements: Java uses the implements keyword to indicate that a class implements an interface. Java supports single inheritance for classes but allows multiple interface implementations.

1public class Circle
2implements Shape, OtherInterface {
3  public void draw() {
4    // Implementation
5  }
6}

Default Methods: Java interfaces can include default methods with implementations, providing common functionality that can be overridden.

1public interface Shape {
2  void draw();
3  default void print() {
4    System.out.println("Shape"); 
5  }
6}

Specific Keyword: Java explicitly distinguishes interfaces from classes with the interface keyword, making it clear that the type is intended to be used as a contract.

Key Differences

• Keyword Usage: Java uses a specific interface keyword, whereas C++ uses abstract classes with pure virtual functions.
• Inheritance Model: C++ supports multiple inheritance directly, which allows a class to inherit from multiple abstract classes. Java restricts classes to single inheritance but allows multiple interfaces to be implemented.
• Default Implementations: Both languages now support default method implementations in interfaces. However, the approach and syntax differ.
• Abstract Classes vs Interfaces: In C++, abstract classes can have both pure virtual functions (acting like interface methods) and regular member functions, providing more flexibility in design. Java distinguishes between abstract classes (which can have member variables and concrete methods) and interfaces (which are meant to provide a strict contract with no state).

Example Comparison

Using an abstract IShape class in C++ looks like this:

1#include <iostream>
2
3class IShape {
4public:
5  virtual void Draw() = 0;
6  virtual void Print() {
7    std::cout << "Shape\n";
8  }
9};
10
11class Circle : public IShape {
12public:
13  void Draw() override {
14    std::cout << "Drawing Circle\n";
15  }
16};

Using a Shape interface in Java looks like this:

1public interface Shape {
2  void draw();
3  default void print() {
4    System.out.println("Shape");
5  }
6}
7
8public class Circle implements Shape {
9  public void draw() {
10    System.out.println("Drawing Circle");
11  }
12}

Both examples achieve similar outcomes but use different syntax and concepts based on the language's design principles.