Comparing Design Patterns: Java vs. Python Approaches

Table of Contents

1. Language Paradigms: Setting the Stage
2. Creational Patterns
   • Singleton
   • Factory Method
3. Structural Patterns
   • Adapter
   • Decorator
4. Behavioral Patterns
   • Observer
   • Strategy
5. Summary: Key Takeaways
6. References

Language Paradigms: Setting the Stage

Before diving into patterns, it’s critical to understand how Java and Python’s core paradigms shape their approach to design:

Java: Strict Object-Oriented, Static Typing

• OOP-Centric: Everything (except primitives) is an object, and classes/interfaces enforce hierarchies and contracts.
• Static Typing: Types are checked at compile time, requiring explicit type declarations.
• Boilerplate: Emphasizes structure (e.g., interfaces, abstract classes) to enforce contracts and enable compile-time validation.

Python: Multi-Paradigm, Dynamic Typing

• Flexibility: Supports OOP, functional programming, and procedural styles.
• Dynamic Typing: Types are resolved at runtime; no explicit declarations needed.
• Conciseness: Prioritizes readability with minimal boilerplate (e.g., no mandatory semicolons, indentation-based blocks).
• First-Class Functions: Functions are objects, enabling patterns like “strategy via functions” instead of classes.

Creational Patterns

Creational patterns focus on object instantiation, controlling how objects are created to enhance flexibility and reuse.

Singleton

Intent: Ensure a class has only one instance and provide a global point of access to it.

Java Implementation

Java enforces singletons through strict encapsulation and thread safety. A common modern approach uses enum, which inherently prevents reflection attacks and ensures thread safety:

// Singleton using Enum (Java)
public enum JavaSingleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("Singleton instance in Java.");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        JavaSingleton singleton = JavaSingleton.INSTANCE;
        singleton.doSomething(); // Output: "Singleton instance in Java."
    }
}

Why it works: Enums in Java are inherently singletons—only one instance is created, and the JVM guarantees thread safety during initialization.

Python Implementation

Python’s dynamic nature simplifies singletons. A common approach uses a module (since Python modules are singletons by default) or a class with a custom __new__ method:

# Singleton using __new__ (Python)
class PythonSingleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# Usage
if __name__ == "__main__":
    singleton1 = PythonSingleton()
    singleton2 = PythonSingleton()
    print(singleton1 is singleton2)  # Output: True (same instance)

Alternatively, Python’s module system implicitly creates singletons. For example, a module singleton.py with:

# singleton.py (Python module-based singleton)
def do_something():
    print("Singleton via Python module.")

Importing singleton elsewhere will reuse the same module instance.

Comparison

Factory Method

Intent: Define an interface for creating an object but let subclasses decide which class to instantiate.

Java Implementation

Java uses interfaces and abstract classes to enforce the factory contract:

// Product Interface
public interface Shape {
    void draw();
}

// Concrete Products
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}

// Factory Interface
public interface ShapeFactory {
    Shape createShape();
}

// Concrete Factories
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

public class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // Output: "Drawing Circle"
    }
}

Why it works: Interfaces (Shape, ShapeFactory) enforce contracts, ensuring concrete factories return valid Shape objects.

Python Implementation

Python’s dynamic typing and duck typing eliminate the need for explicit interfaces. Factories can be simple functions or classes:

# Product Classes (Python)
class Circle:
    def draw(self):
        print("Drawing Circle")

class Square:
    def draw(self):
        print("Drawing Square")

# Factory Function (Python)
def shape_factory(shape_type):
    if shape_type == "circle":
        return Circle()
    elif shape_type == "square":
        return Square()
    else:
        raise ValueError("Unknown shape type")

# Usage
if __name__ == "__main__":
    circle = shape_factory("circle")
    circle.draw()  # Output: "Drawing Circle"

Why it works: Duck typing—any object with a draw() method is a valid “Shape,” so no interface is needed. The factory function directly returns instances based on input.

Comparison

Structural Patterns

Structural patterns compose classes/objects to form larger structures while keeping them flexible and efficient.

Adapter

Intent: Convert the interface of a class into another interface clients expect. Lets incompatible classes work together.

Java Implementation

Java uses either class adapters (inheritance) or object adapters (composition). Here’s an object adapter:

// Target Interface (what the client expects)
public interface MediaPlayer {
    void play(String audioType, String fileName);
}

// Adaptee (existing class with incompatible interface)
public class AdvancedMediaPlayer {
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file: " + fileName);
    }

    public void playVlc(String fileName) {
        System.out.println("Playing vlc file: " + fileName);
    }
}

// Adapter (wraps Adaptee to implement Target)
public class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedPlayer = new AdvancedMediaPlayer();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedPlayer.playMp4(fileName);
        }
    }
}

// Client (uses Target interface)
public class AudioPlayer implements MediaPlayer {
    private MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        AudioPlayer player = new AudioPlayer();
        player.play("mp3", "song.mp3");  // Output: "Playing mp3 file: song.mp3"
        player.play("mp4", "video.mp4");  // Output: "Playing mp4 file: video.mp4"
    }
}

Python Implementation

Python’s duck typing simplifies adapters—no need for explicit target interfaces. Here’s a concise object adapter:

# Adaptee (existing class)
class AdvancedMediaPlayer:
    def play_mp4(self, filename):
        print(f"Playing mp4 file: {filename}")

    def play_vlc(self, filename):
        print(f"Playing vlc file: {filename}")

# Adapter (implements the client's expected interface)
class MediaAdapter:
    def __init__(self, audio_type):
        self.advanced_player = AdvancedMediaPlayer()
        self.audio_type = audio_type

    def play(self, audio_type, filename):
        if audio_type == "mp4":
            self.advanced_player.play_mp4(filename)
        elif audio_type == "vlc":
            self.advanced_player.play_vlc(filename)

# Client
class AudioPlayer:
    def play(self, audio_type, filename):
        if audio_type == "mp3":
            print(f"Playing mp3 file: {filename}")
        else:
            adapter = MediaAdapter(audio_type)
            adapter.play(audio_type, filename)

# Usage
if __name__ == "__main__":
    player = AudioPlayer()
    player.play("mp3", "song.mp3")  # Output: "Playing mp3 file: song.mp3"
    player.play("mp4", "video.mp4")  # Output: "Playing mp4 file: video.mp4"

Comparison

Decorator

Intent: Attach additional responsibilities to an object dynamically. Provides a flexible alternative to subclassing for extending functionality.

Java Implementation

Java uses composition and interfaces to wrap objects:

// Component Interface
public interface Beverage {
    String getDescription();
    double cost();
}

// Concrete Component (base object)
public class Espresso implements Beverage {
    @Override
    public String getDescription() {
        return "Espresso";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

// Decorator (wraps Component)
public abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;

    public CondimentDecorator(Beverage beverage) {
        this.beverage = beverage;
    }

    public abstract String getDescription();
}

// Concrete Decorators
public class Milk extends CondimentDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.50;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Beverage espresso = new Espresso();
        espresso = new Milk(espresso); // Decorate with Milk
        System.out.println(espresso.getDescription() + " $" + espresso.cost());
        // Output: "Espresso, Milk $2.49"
    }
}

Python Implementation

Python uses built-in decorator syntax (syntactic sugar for wrapping functions/classes). For class-based decorators:

# Component (base class)
class Beverage:
    def get_description(self):
        return self.__class__.__name__

    def cost(self):
        raise NotImplementedError

# Concrete Component
class Espresso(Beverage):
    def cost(self):
        return 1.99

# Decorator (uses composition)
class CondimentDecorator(Beverage):
    def __init__(self, beverage):
        self.beverage = beverage

    def get_description(self):
        return f"{self.beverage.get_description()}, {self.__class__.__name__}"

    def cost(self):
        return self.beverage.cost() + self.extra_cost()

    def extra_cost(self):
        raise NotImplementedError

# Concrete Decorators
class Milk(CondimentDecorator):
    def extra_cost(self):
        return 0.50

# Usage
if __name__ == "__main__":
    espresso = Espresso()
    espresso_with_milk = Milk(espresso)
    print(f"{espresso_with_milk.get_description()} ${espresso_with_milk.cost()}")
    # Output: "Espresso, Milk $2.49"

Alternatively, Python can use function decorators for simpler cases (e.g., adding logging to a function).

Comparison

Behavioral Patterns

Behavioral patterns focus on communication between objects and how they distribute responsibility.

Observer

Intent: Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Java Implementation

Java historically used Observable/Observer (deprecated in Java 9), but modern implementations use interfaces:

// Subject Interface
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// Observer Interface
public interface Observer {
    void update(float temperature);
}

// Concrete Subject
public class WeatherStation implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private float temperature;

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        notifyObservers(); // Notify on state change
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(temperature);
        }
    }
}

// Concrete Observer
public class PhoneDisplay implements Observer {
    @Override
    public void update(float temperature) {
        System.out.println("Phone Display: Temperature is " + temperature);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        PhoneDisplay phone = new PhoneDisplay();
        station.registerObserver(phone);
        station.setTemperature(25.5f); // Output: "Phone Display: Temperature is 25.5"
    }
}

Python Implementation

Python uses dynamic typing and lists to manage observers. No need for explicit interfaces:

# Subject
class WeatherStation:
    def __init__(self):
        self.observers = []
        self.temperature = 0

    def register_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify_observers(self):
        for observer in self.observers:
            observer.update(self.temperature)  # Assume observers have update()

    def set_temperature(self, temperature):
        self.temperature = temperature
        self.notify_observers()

# Observer (no interface; just needs update())
class PhoneDisplay:
    def update(self, temperature):
        print(f"Phone Display: Temperature is {temperature}")

# Usage
if __name__ == "__main__":
    station = WeatherStation()
    phone = PhoneDisplay()
    station.register_observer(phone)
    station.set_temperature(25.5)  # Output: "Phone Display: Temperature is 25.5"

Comparison

Strategy

Intent: Define a family of algorithms, encapsulate each one, and make them interchangeable. Lets the algorithm vary independently from clients that use it.

Java Implementation

Java uses interfaces to encapsulate algorithms:

// Strategy Interface
public interface PaymentStrategy {
    void pay(double amount);
}

// Concrete Strategies
public class CreditCardPayment implements PaymentStrategy {
    private String name;
    private String cardNumber;

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

    @Override
    public void pay(double amount) {
        System.out.println(amount + " paid with credit card (Holder: " + name + ")");
    }
}

public class PayPalPayment implements PaymentStrategy {
    private String email;

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

    @Override
    public void pay(double amount) {
        System.out.println(amount + " paid via PayPal (Email: " + email + ")");
    }
}

// Context (uses a Strategy)
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double amount) {
        paymentStrategy.pay(amount);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.setPaymentStrategy(new CreditCardPayment("John Doe", "1234-5678"));
        cart.checkout(99.99); // Output: "99.99 paid with credit card..."
    }
}

Python Implementation

Python can use classes or functions as strategies (since functions are first-class citizens):

# Strategy Functions (simpler than classes)
def credit_card_pay(amount, name, card_number):
    print(f"{amount} paid with credit card (Holder: {name})")

def paypal_pay(amount, email):
    print(f"{amount} paid via PayPal (Email: {email})")

# Context (accepts strategy functions)
class ShoppingCart:
    def checkout(self, amount, payment_strategy, **kwargs):
        payment_strategy(amount, **kwargs)

# Usage
if __name__ == "__main__":
    cart = ShoppingCart()
    cart.checkout(99.99, credit_card_pay, name="John Doe", card_number="1234-5678")
    # Output: "99.99 paid with credit card (Holder: John Doe)"

Comparison

Summary: Key Takeaways

Java’s static typing and OOP focus make it ideal for large-scale applications where structure and compile-time validation are critical. Python’s dynamic nature and multi-paradigm support excel in rapid development, where flexibility and readability matter most.

Understanding these differences empowers developers to choose idiomatic implementations, leveraging each language’s strengths to write clean, maintainable code.

References

• Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
• Python Design Patterns (Real Python)
• Java Design Patterns (Oracle)
• Python Singleton Patterns (Python Docs)
• Java Enum Singleton (Effective Java, Joshua Bloch)