Evan Emran's Blog | Official

Real-World Examples of OOP in Android Projects

Real-World Examples of OOP in Android Projects

Emran Khandaker Evan's photo
Emran Khandaker Evan
·

10 min read

Table of contents

Object-Oriented Programming (OOP) is a fundamental paradigm in modern software development, offering a structured approach to designing and implementing complex applications. In Android development, OOP principles help create modular, maintainable, and scalable code. This blog will analyze real-world Android projects to demonstrate how OOP principles are effectively applied to solve common development challenges and create robust applications.

Why OOP Matters in Android Development

OOP principles provide several key benefits in Android development:

  • Modularity: Breaking down complex applications into smaller, manageable components.

  • Reusability: Promoting code reuse through inheritance and composition.

  • Maintainability: Simplifying code maintenance and updates by encapsulating logic.

  • Scalability: Enabling the addition of new features without significant rework.

By exploring real-world examples, we can see how these principles are applied to create efficient and maintainable Android applications.

1. Example: E-Commerce Application

Project Overview: This e-commerce application allows users to browse products, add items to a cart, and make purchases. The application uses OOP principles to manage UI components, business logic, and data access.

Encapsulation

Encapsulation involves bundling data and methods that operate on that data within a single class. In the e-commerce application, encapsulation is used to manage product data and cart operations.

Example: Encapsulating Cart Logic

CartManager Class:

public class CartManager {
    private List<Product> cartItems;

    public CartManager() {
        cartItems = new ArrayList<>();
    }

    public void addItem(Product product) {
        cartItems.add(product);
    }

    public void removeItem(Product product) {
        cartItems.remove(product);
    }

    public double getTotalPrice() {
        double total = 0;
        for (Product product : cartItems) {
            total += product.getPrice();
        }
        return total;
    }

    public List<Product> getCartItems() {
        return cartItems;
    }
}

Usage in Activity:

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;

public class CartActivity extends AppCompatActivity {
    private CartManager cartManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cart);

        cartManager = new CartManager();
        // Add sample items to cart
        cartManager.addItem(new Product("Laptop", 1200.00));
        cartManager.addItem(new Product("Smartphone", 800.00));

        double totalPrice = cartManager.getTotalPrice();
        List<Product> cartItems = cartManager.getCartItems();

        // Display total price and cart items
    }
}

In this example:

  • The CartManager class encapsulates the logic for managing the cart, including adding and removing items and calculating the total price. The CartActivity interacts with the CartManager to manage and display cart items.

Inheritance

Inheritance allows new classes to inherit properties and methods from existing classes, promoting code reuse and extensibility. In the e-commerce application, inheritance is used to create different types of product listings.

Example: Extending BaseProduct Class

BaseProduct Class:

public abstract class BaseProduct {
    private String name;
    private double price;

    public BaseProduct(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public abstract void displayProductDetails();
}

DigitalProduct Class:

public class DigitalProduct extends BaseProduct {
    private double fileSize;

    public DigitalProduct(String name, double price, double fileSize) {
        super(name, price);
        this.fileSize = fileSize;
    }

    @Override
    public void displayProductDetails() {
        System.out.println("Digital Product: " + getName() + " - " + getPrice() + " USD");
        System.out.println("File Size: " + fileSize + " MB");
    }
}

PhysicalProduct Class:

public class PhysicalProduct extends BaseProduct {
    private double weight;

    public PhysicalProduct(String name, double price, double weight) {
        super(name, price);
        this.weight = weight;
    }

    @Override
    public void displayProductDetails() {
        System.out.println("Physical Product: " + getName() + " - " + getPrice() + " USD");
        System.out.println("Weight: " + weight + " kg");
    }
}

In this example:

  • The BaseProduct class provides a common structure for products. The DigitalProduct and PhysicalProduct classes extend BaseProduct to create specific types of products, each with additional attributes and methods.

Polymorphism

Polymorphism allows objects of different classes to be treated as instances of a common superclass, enabling flexible and interchangeable code. In the e-commerce application, polymorphism is used to handle different payment methods.

Example: Implementing Payment Method Polymorphism

PaymentMethod Interface:

public interface PaymentMethod {
    void processPayment(double amount);
}

CreditCardPayment Class:

public class CreditCardPayment implements PaymentMethod {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment of " + amount + " USD");
        // Implement credit card payment logic
    }
}

PayPalPayment Class:

public class PayPalPayment implements PaymentMethod {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment of " + amount + " USD");
        // Implement PayPal payment logic
    }
}

PaymentProcessor Class:

public class PaymentProcessor {
    public void processPayment(PaymentMethod paymentMethod, double amount) {
        paymentMethod.processPayment(amount);
    }
}

// Usage example
PaymentProcessor processor = new PaymentProcessor();
PaymentMethod creditCard = new CreditCardPayment("1234-5678-9012-3456");
PaymentMethod payPal = new PayPalPayment("user@example.com");

processor.processPayment(creditCard, 100.00); // Output: Processing credit card payment of 100.0 USD
processor.processPayment(payPal, 100.00);     // Output: Processing PayPal payment of 100.0 USD

In this example:

  • The PaymentMethod interface defines a contract for payment processing. The CreditCardPayment and PayPalPayment classes implement this interface to provide specific payment logic. The PaymentProcessor class uses polymorphism to process payments with different methods interchangeably.

2. Example: Social Media Application

Project Overview: This social media application allows users to post updates, follow other users, and interact with posts. OOP principles are used to manage user profiles, post content, and notification handling.

Encapsulation

Example: Encapsulating User Profile Logic

UserProfile Class:

public class UserProfile {
    private String username;
    private String bio;
    private List<String> followers;

    public UserProfile(String username, String bio) {
        this.username = username;
        this.bio = bio;
        this.followers = new ArrayList<>();
    }

    public void addFollower(String follower) {
        followers.add(follower);
    }

    public void removeFollower(String follower) {
        followers.remove(follower);
    }

    public String getUsername() {
        return username;
    }

    public String getBio() {
        return bio;
    }

    public List<String> getFollowers() {
        return followers;
    }
}

Usage in Activity:

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;

public class ProfileActivity extends AppCompatActivity {
    private UserProfile userProfile;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_profile);

        userProfile = new UserProfile("john_doe", "Tech enthusiast and blogger");

        // Add followers
        userProfile.addFollower("alice");
        userProfile.addFollower("bob");

        String username = userProfile.getUsername();
        String bio = userProfile.getBio();
        List<String> followers = userProfile.getFollowers();

        // Display profile information
    }
}

In this example:

  • The UserProfile class encapsulates user-related data and operations, such as adding and removing followers, keeping the user management logic contained within the class.

Inheritance

Example: Creating Post Types with Inheritance

Post Class:

public abstract class Post {
    private String content;
    private String author;

    public Post(String content, String author) {
        this.content = content;
        this.author = author;
    }

    public String getContent() {
        return content;
    }

    public String getAuthor() {
        return author;
    }

    public abstract void displayPost();
}

TextPost Class:

public class TextPost extends Post {
    public TextPost(String content, String author) {
        super(content, author);
    }

    @Override
    public void displayPost() {
        System.out.println("Text Post by " + getAuthor() + ": " + getContent());
    }
}

ImagePost Class:

public class ImagePost extends Post {
    private String imageUrl;

    public ImagePost(String content, String author, String imageUrl) {
        super(content, author);
        this.imageUrl = imageUrl;
    }

    @Override
    public void displayPost() {
        System.out.println("Image Post by " + getAuthor() + ": " + getContent());
        System.out.println("Image URL: " + imageUrl);
    }
}

In this example:

  • The Post class provides a base structure for posts. The TextPost and ImagePost classes extend Post to create specific types of posts with additional attributes and methods.

Polymorphism

Example: Using Polymorphism for Notification Handling

Notification Interface:

public interface Notification {
    void sendNotification();
}

EmailNotification Class:

public class EmailNotification implements Notification {
    private String recipientEmail;
    private String message;

    public EmailNotification(String recipientEmail, String message) {
        this.recipientEmail = recipientEmail;
        this.message = message;
    }

    @Override
    public void sendNotification() {
        System.out.println("Sending email to " + recipientEmail + ": " + message);
    }
}

PushNotification Class:

public class PushNotification implements Notification {
    private String deviceToken;
    private String message;

    public PushNotification(String deviceToken, String message) {
        this.deviceToken = deviceToken;
        this.message = message;
    }

    @Override
    public void sendNotification() {
        System.out.println("Sending push notification to device " + deviceToken + ": " + message);
    }
}

NotificationManager Class:

public class NotificationManager {
    public void notifyUser(Notification notification) {
        notification.sendNotification();
    }
}

// Usage example
NotificationManager manager = new NotificationManager();
Notification emailNotification = new EmailNotification("user@example.com", "You have a new message");
Notification pushNotification = new PushNotification("deviceToken123", "You have a new message");

manager.notifyUser(emailNotification); // Output: Sending email to user@example.com: You have a new message
manager.notifyUser(pushNotification);   // Output: Sending push notification to device deviceToken123: You have a new message

In this example:

  • The Notification interface defines a contract for sending notifications. The EmailNotification and PushNotification classes implement this interface to provide specific notification logic. The NotificationManager uses polymorphism to handle different types of notifications interchangeably.

3. Example: Fitness Tracking Application

Project Overview: This fitness tracking application allows users to monitor their physical activities, set goals, and track their progress. OOP principles are used to manage activity tracking, goal setting, and progress visualization.

Encapsulation

Example: Encapsulating Activity Tracking Logic

ActivityTracker Class:

import java.util.ArrayList;
import java.util.List;

public class ActivityTracker {
    private List<FitnessActivity> activities;

    public ActivityTracker() {
        activities = new ArrayList<>();
    }

    public void addActivity(FitnessActivity activity) {
        activities.add(activity);
    }

    public List<FitnessActivity> getActivities() {
        return activities;
    }

    public double getTotalDistance() {
        double totalDistance = 0;
        for (FitnessActivity activity : activities) {
            totalDistance += activity.getDistance();
        }
        return totalDistance;
    }
}

Usage in Activity:

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;

public class TrackerActivity extends AppCompatActivity {
    private ActivityTracker activityTracker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_tracker);

        activityTracker = new ActivityTracker();
        activityTracker.addActivity(new FitnessActivity("Running", 5.0));
        activityTracker.addActivity(new FitnessActivity("Cycling", 10.0));

        double totalDistance = activityTracker.getTotalDistance();
        List<FitnessActivity> activities = activityTracker.getActivities();

        // Display total distance and activity details
    }
}

In this example:

  • The ActivityTracker class encapsulates the logic for managing fitness activities, such as adding activities and calculating the total distance.

Inheritance

Example: Extending BaseGoal Class

BaseGoal Class:

public abstract class BaseGoal {
    private String description;
    private double target;

    public BaseGoal(String description, double target) {
        this.description = description;
        this.target = target;
    }

    public String getDescription() {
        return description;
    }

    public double getTarget() {
        return target;
    }

    public abstract boolean isGoalAchieved(double progress);
}

DistanceGoal Class:

public class DistanceGoal extends BaseGoal {
    public DistanceGoal(String description, double target) {
        super(description, target);
    }

    @Override
    public boolean isGoalAchieved(double progress) {
        return progress >= getTarget();
    }
}

CalorieGoal Class:

public class CalorieGoal extends BaseGoal {
    public CalorieGoal(String description, double target) {
        super(description, target);
    }

    @Override
    public boolean isGoalAchieved(double progress) {
        return progress >= getTarget();
    }
}

In this example:

  • The BaseGoal class provides a common structure for fitness goals. The DistanceGoal and CalorieGoal classes extend BaseGoal to create specific types of goals with their own criteria for achievement.

Polymorphism

Example: Using Polymorphism for Progress Visualization

ProgressVisualizer Interface:

public interface ProgressVisualizer {
    void visualizeProgress(double progress);
}

BarChartVisualizer Class:

public class BarChartVisualizer implements ProgressVisualizer {
    @Override
    public void visualizeProgress(double progress) {
        System.out.println("Visualizing progress as a bar chart: " + progress + "% complete");
        // Implement bar chart visualization logic
    }
}

LineChartVisualizer Class:

public class LineChartVisualizer implements ProgressVisualizer {
    @Override
    public void visualizeProgress(double progress) {
        System.out.println("Visualizing progress as a line chart: " + progress + "% complete");
        // Implement line chart visualization logic
    }
}

VisualizationManager Class:

public class VisualizationManager {
    public void displayProgress(ProgressVisualizer visualizer, double progress) {
        visualizer.visualizeProgress(progress);
    }
}

// Usage example
VisualizationManager manager = new VisualizationManager();
ProgressVisualizer barChart = new BarChartVisualizer();
ProgressVisualizer lineChart = new LineChartVisualizer();

manager.displayProgress(barChart, 75.0); // Output: Visualizing progress as a bar chart: 75.0% complete
manager.displayProgress(lineChart, 75.0); // Output: Visualizing progress as a line chart: 75.0% complete

In this example:

  • The ProgressVisualizer interface defines a contract for visualizing progress. The BarChartVisualizer and LineChartVisualizer classes implement this interface to provide specific visualization methods. The VisualizationManager uses polymorphism to visualize progress with different visualizers interchangeably.

Best Practices for Applying OOP in Android Projects

  1. Encapsulate Logic: Encapsulate related logic within classes to promote reusability and maintainability.

  2. Use Inheritance Wisely: Use inheritance to extend functionality and create reusable components, but avoid deep inheritance hierarchies that can complicate maintenance.

  3. Leverage Polymorphism: Use polymorphism to create flexible and interchangeable components, making your code more adaptable to change.

  4. Follow the Single Responsibility Principle: Ensure that each class has a single responsibility, making it easier to manage and test.

  5. Design for Scalability: Use OOP principles to design scalable applications that can easily accommodate new features and requirements.

Conclusion

Applying Object-Oriented Programming principles in real-world Android projects leads to more modular, reusable, and maintainable code. By analyzing how OOP principles are used in e-commerce, social media, and fitness tracking applications, we can see how encapsulation, inheritance, and polymorphism help create robust and scalable applications. Embrace these principles in your own Android projects to build better, more efficient applications that stand the test of time.

Androidandroid app developmentAndroid StudiooopOOPSOOP Design PrinciplesObject Oriented Programming