Question 27 of 28: Java Interface vs. C++ Class, and Simulating Interfaces in C++

Question 27: Java Interface vs. C++ Class, and Simulating Interfaces in C++ (Part V)

Question text not reproduced: the examination questions are © Engineers and Geoscientists BC. Open the official past paper (linked at the top of this page) to read the question, then follow the worked solution below.

Difference. A Java class can hold state (instance fields) and provide concrete method implementations, and a class may extend only ONE superclass. A Java interface declares only METHOD SIGNATURES (historically no fields other than public static final constants, no implementation) that any implementing class must provide, and a single class may implement MULTIPLE interfaces — interfaces exist purely to specify a capability/contract, never to hold shared state or share implementation.

Simulating an interface in C++. C++ has no separate interface keyword, but an interface is simulated by an abstract class containing ONLY pure virtual functions and no data members:

class Drawable {              // plays the role of a Java "interface"
public:
    virtual void draw() = 0;  // pure virtual: no implementation, no state
    virtual ~Drawable() {}
};
class Circle : public Drawable {
public:
    void draw() override { /* render a circle */ }
};

Because Drawable has zero data members and every method is pure virtual, it behaves exactly like a Java interface: it specifies capability with no shared state or implementation to inherit. C++'s support for MULTIPLE inheritance then lets one class implement several such interface-like abstract classes simultaneously (class Icon : public Drawable, public Serializable { ... }), directly mirroring Java's "implements multiple interfaces" — the discipline of keeping such base classes pure-virtual/stateless is what makes multiple inheritance of them safe, since there is no shared state for the classic multiple-inheritance diamond problem to corrupt.