Extending from two classes

java

interface

composition

inheritance

byAnton Shumikhin·Dec 31, 2024

In Java, multiple inheritance akin to C++'s model is not allowed because of its complexity. However, you are not left totally in the lurch. You can accomplish similar behavior by utilizing interfaces and composition. Create interfaces for defining common behavior and use the power of delegation inside your classes for logical implementation:

interface A {
    void methodA(); // Your ticket to the A-List
}

interface B {
    void methodB(); // Welcome to the B-Team
}

class ImplA implements A {
    public void methodA() { /* logic A - A-OK */ }
}

class ImplB implements B {
    public void methodB() { /* logic B - Plan B is activated */ }
}

class AB implements A, B {
    private A a = new ImplA();
    private B b = new ImplB();
    // Putting A and B together to form a supergroup!

    public void methodA() { a.methodA(); }
    // Delegating methodA to "a" - talk about passing the buck!

    public void methodB() { b.methodB(); }
    // Delegating methodB to "b" - yes, "b" stands for buck!
}

Define duties (A and B) through interfaces, get individual classes (ImplA and ImplB) to carry out these duties, and connect everything in the AB class by delegating to the respective methods.

Interface and composition: Dancing partners

When it comes to extending from two classes, Java prefers you to dance with interfaces and composition. Blend behavior using interfaces and mix in extra functionalities with composition, by using the has-a relationship rather than the is-a one. This union is usually more flexible and prevents you from being hitched down by the constraints of the inheritance hierarchy.

Proxy methods

In our quest to avoid multiple inheritance woes, proxy methods come to our aid as efficient delegates. Proxy methods are essentially facades that channel the real work to the associated classes, providing a clean abstraction layer. However, like any good delegate, they need to ensure all parties (i.e., state) in their care are managed well to prevent inconsistencies.

Inner classes, unifiers of the code world

Housing one class within another using inner classes introduces better encapsulation and code organization. Additionally, this enables better coordination as inner classes can easily access the outer class's members. This is particularly helpful when working with shared data or resources. Plus, they have a VIP pass to be private, keeping implementation details under wraps!

Interfaces: Shield against the diamond problem

Interfaces put up a shield against the notorious Diamond Problem, where a class can inherit the same method from multiple parent classes. This freedom allows classes to provide multiple behaviors without a fuss about the underlying implementations. Carefully crafted interfaces and class composition can serve as a functional multiple inheritance substitute.

Adopting the right design patterns

Take a moment to evaluate procedures and assess the real necessity of some functionalities across classes. Sometimes, viewing the problem from another perspective can lead to simpler and more robust solutions, even making you reconsider the need for "multiple inheritance" workarounds.

Benefits of Java 8 features

Advanced features in Java 8, such as default methods and static methods, have given interfaces a new flavor. Default methods in interfaces, apart from breaking the age-old norms, also provide a choice to classes on how to handle conflicts arising when two interfaces have default methods with the same signature.

Shaving off boilerplate with Project Lombok

Say goodbye to boiler-plate code with Project Lombok, an essential tool to trim down getter and setter method clutter. Using annotations like @Getter, @Setter, and @Delegate, you can drastically reduce the accidental complexity and tackle complexity arising due to inheritance or composition.

Mind your foot (and code)

While interfaces, inner classes, composition, and proxy methods are excellent tools in our developer toolkit, overuse can lead to bloated classes that are hard to reason about and maintain. Also, keep your interfaces clean and purposeful. In essence, just like any other tool, use them with care and judicious thinking.

explain-codes / Java / Extending from two classes

Linked

Why can outer Java classes access inner class private members?



Implements vs extends: When to use? What's the difference?



How to check if an object implements an interface?



How to test if one java class extends another at runtime?



Do subclasses inherit private fields?

