Composition Over Inheritance: Best Practices in Android

Composition Over Inheritance: Best Practices in Android

In the realm of Object-Oriented Programming (OOP), two of the most prominent design principles are inheritance and composition. While inheritance has traditionally been the go-to approach for code reuse and extension, modern software development increasingly favors composition for its flexibility and modularity. In this blog, we’ll explore why composition is often a better choice than inheritance, and how to implement it effectively in your Android projects to create more maintainable and scalable applications.

Understanding Inheritance and Composition


Inheritance is a mechanism in OOP that allows a class (subclass) to inherit attributes and methods from another class (superclass). It creates a hierarchical relationship between the classes and promotes code reuse.

  • Example: A Dog class inherits from an Animal class, which means Dog automatically acquires the properties and methods of Animal.
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");

// Usage
Dog dog = new Dog();; // Inherited method
dog.bark(); // Specific to Dog


Composition involves creating complex types by combining objects of other types. It allows a class to contain instances of other classes, rather than inheriting from them. This approach promotes code reuse and flexibility without creating rigid class hierarchies.

  • Example: A Car class can be composed of an Engine class and a Wheel class, instead of inheriting from a general Vehicle class.
public class Engine {
    public void start() {
        System.out.println("Engine is starting");

public class Wheel {
    public void rotate() {
        System.out.println("Wheel is rotating");

public class Car {
    private Engine engine;
    private Wheel[] wheels;

    public Car() {
        engine = new Engine();
        wheels = new Wheel[]{new Wheel(), new Wheel(), new Wheel(), new Wheel()};

    public void drive() {
        for (Wheel wheel : wheels) {
        System.out.println("Car is driving");

// Usage
Car car = new Car();; // Output: Engine is starting, Wheel is rotating, Car is driving

Why Prefer Composition Over Inheritance?

1. Flexibility and Reusability

  • Inheritance: Creates a tight coupling between classes. Changes in the superclass can have unintended effects on subclasses, making it difficult to modify and extend the hierarchy.

  • Composition: Promotes loose coupling. You can easily replace or modify components without affecting other parts of the system, enhancing flexibility and reusability.

2. Avoiding Hierarchical Pitfalls

  • Inheritance: Forces a rigid hierarchy. As the class hierarchy grows, it can become difficult to manage and understand, leading to complex and brittle systems.

  • Composition: Allows for more flexible and modular designs. You can compose classes in different ways to achieve desired functionality without the constraints of a fixed hierarchy.

3. Enhanced Testability and Maintainability

  • Inheritance: Makes unit testing challenging. Subclasses often inherit more than they need, leading to tightly coupled and harder-to-test code.

  • Composition: Facilitates easier testing. Components can be tested in isolation, improving maintainability and allowing for more granular unit tests.

4. Single Responsibility Principle

  • Inheritance: Tends to violate the single responsibility principle by bundling multiple responsibilities into one class.

  • Composition: Adheres to the single responsibility principle by delegating specific responsibilities to individual components, making the code more modular and maintainable.

Implementing Composition in Android Development

In Android development, composition can be particularly beneficial for creating reusable and flexible components. Here are some practical examples and strategies for using composition in your projects.

Example 1: Using Composition for Reusable UI Components

Suppose you need a custom button with additional functionality, such as showing a loading indicator. Instead of extending the Button class, you can create a LoadingButton that composes a Button and a ProgressBar.

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ProgressBar;

public class LoadingButton extends LinearLayout {
    private Button button;
    private ProgressBar progressBar;

    public LoadingButton(Context context, AttributeSet attrs) {
        super(context, attrs);

    private void init(Context context) {
        button = new Button(context);
        progressBar = new ProgressBar(context);



    public void setButtonText(String text) {

    public void showLoading() {

    public void hideLoading() {

// Usage in an Activity or Fragment
LoadingButton loadingButton = findViewById(;

In this example:

  • The LoadingButton class composes a Button and a ProgressBar, allowing for a flexible design without extending the Button class.

Example 2: Using Composition for Delegating Tasks

Composition can be used to delegate tasks to different components. For example, you can create a NetworkManager class that delegates network operations to a HttpClient class.

public class HttpClient {
    public void sendRequest(String url) {
        System.out.println("Sending request to " + url);

public class NetworkManager {
    private HttpClient httpClient;

    public NetworkManager() {
        httpClient = new HttpClient();

    public void fetchData(String url) {

// Usage
NetworkManager networkManager = new NetworkManager();

In this example:

  • The NetworkManager class uses composition to delegate the task of sending a request to the HttpClient class, promoting separation of concerns and enhancing testability.

Best Practices for Using Composition in Android Development

To effectively use composition in your Android projects, consider the following best practices:

1. Identify Reusable Components

  • Break down your application into smaller, reusable components. Identify common functionality that can be encapsulated into standalone classes.

2. Favor Composition Over Inheritance

  • When designing new classes, prioritize composition over inheritance. Use inheritance sparingly, mainly for defining truly hierarchical relationships.

3. Use Interfaces to Define Contracts

  • Define clear interfaces for your components to establish contracts for their behavior. This promotes flexibility and allows for easy swapping or updating of components.

4. Delegate Responsibilities

  • Delegate responsibilities to composed objects rather than trying to handle everything within a single class. This makes your code more modular and easier to maintain.

5. Promote Loose Coupling

  • Aim for loose coupling between components by using interfaces and dependency injection. This enhances flexibility and makes it easier to test and update your code.

6. Avoid Deep Inheritance Hierarchies

  • Keep inheritance hierarchies shallow to avoid complexity and maintainability issues. Deep hierarchies can be difficult to manage and understand.


Choosing composition over inheritance is a best practice in modern software development that can greatly enhance the flexibility, maintainability, and scalability of your Android applications. By favoring composition, you create more modular and reusable code, promote loose coupling, and adhere to the single responsibility principle. Understanding when and how to use composition effectively is a key skill that will help you build robust and adaptable Android applications that are easier to develop, extend, and maintain over time.