Factory-Muster

Teil des Abschnitts Objektorientierte Programmierung der Python-Journey von Coddy. Lektion 46 von 64.

Das Factory Pattern erstellt Objekte, ohne ihre genaue Klasse anzugeben. Anstatt Konstruktoren direkt aufzurufen, verwendest du eine Factory-Methode, die entscheidet, welche Klasse instanziiert werden soll.

Hier sind einfache Produktklassen:

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.type = "Car"
    
    def info(self):
        return f"{self.type}: {self.brand}"

class Bike:
    def __init__(self, brand):
        self.brand = brand
        self.type = "Bike"
    
    def info(self):
        return f"{self.type}: {self.brand}"

Erstelle eine Factory-Klasse, um diese Objekte zu erzeugen:

class VehicleFactory:
    def create_vehicle(self, vehicle_type, brand):
        if vehicle_type == "car":
            return Car(brand)
        elif vehicle_type == "bike":
            return Bike(brand)
        else:
            raise ValueError(f"Unknown type: {vehicle_type}")

Verwende die Factory, anstatt Konstruktoren direkt aufzurufen:

factory = VehicleFactory()
my_car = factory.create_vehicle("car", "Toyota")
my_bike = factory.create_vehicle("bike", "Honda")

print(my_car.info())   # Auto: Toyota
print(my_bike.info())  # Fahrrad: Honda

Mach die Fabrik mit *args flexibler:

class FlexibleFactory:
    def create_vehicle(self, vehicle_type, *args):
        if vehicle_type == "car":
            return Car(args[0])  # Nur Marke
        elif vehicle_type == "truck":
            return Truck(args[0], args[1])  # Marke und Kapazität
        else:
            raise ValueError(f"Unknown type: {vehicle_type}")

class Truck:
    def __init__(self, brand, capacity):
        self.brand = brand
        self.capacity = capacity
        self.type = "Truck"
    
    def info(self):
        return f"{self.type}: {self.brand} ({self.capacity}t)"

Verwende die flexible Fabrik:

flexible = FlexibleFactory()
car = flexible.create_vehicle("car", "Ford")
truck = flexible.create_vehicle("truck", "Volvo", "20")

print(car.info())    # Auto: Ford
print(truck.info())  # LKW: Volvo (20t)

Ausgabe:

Car: Toyota
Bike: Honda
Car: Ford
Truck: Volvo (20t)

Wichtiger Punkt: Das Factory Pattern ermöglicht es dir, Objekte zu erstellen, ohne ihre genaue Klasse zu kennen. Die Factory-Methode entscheidet anhand von Parametern, welche Klasse instanziiert werden soll. Verwende *args, um Produkte mit unterschiedlichen Konstruktorparametern zu verarbeiten. Dadurch wird dein Code flexibler und lässt sich leichter um neue Produkttypen erweitern.

Aufgabe

Mittel

In dieser Herausforderung implementierst du ein Shape-Factoriesystem unter Verwendung eines angemessenen objektorientierten Designs mit Vererbung und Polymorphie.

Vervollständige die Implementierung in den folgenden Dateien:

shape.py – Basisklasse Shape
circle.py – Circle-Implementierung
rectangle.py – Rectangle-Implementierung
triangle.py – Triangle-Implementierung
shapefactory.py – Factory-Klasse zum Erstellen von Shapes

Jede Datei enthält ausführliche TODO-Kommentare, die dich bei der Implementierung unterstützen. Befolge diese Kommentare sorgfältig, damit dein Code alle Anforderungen erfüllt.

Probier es selbst

from shapefactory import ShapeFactory
from shape import Shape
from circle import Circle
from rectangle import Rectangle
from triangle import Triangle
import sys

# Testfall-Executor
test_case = input()

factory = ShapeFactory()

if test_case == "circle_area":
    circle = factory.create_shape("circle", 5)
    print(f"{circle.area():.2f}")

elif test_case == "rectangle_perimeter":
    rectangle = factory.create_shape("rectangle", 4, 6)
    print(f"{rectangle.perimeter()}")

elif test_case == "triangle_perimeter":
    triangle = factory.create_shape("triangle", 3, 4, 5)
    print(f"{triangle.perimeter()}")

elif test_case == "invalid_shape":
    try:
        factory.create_shape("hexagon", 6)
        print("No exception raised")
    except ValueError as e:
        print(str(e))

elif test_case == "case_insensitive":
    circle = factory.create_shape("CiRcLe", 3)
    print(f"{circle.area():.2f}")

elif test_case == "shape_inheritance":
    shapes = [
        factory.create_shape("circle", 2),
        factory.create_shape("rectangle", 2, 3),
        factory.create_shape("triangle", 3, 4, 5)
    ]
    all_shapes = all(isinstance(shape, Shape) for shape in shapes)
    print(all_shapes)

elif test_case == "zero_radius_circle":
    circle = factory.create_shape("circle", 0)
    print(f"{circle.area():.2f} {circle.perimeter():.2f}")

elif test_case == "negative_dimensions":
    rectangle = factory.create_shape("rectangle", -2, -3)
    print(f"{rectangle.area()}")

elif test_case == "large_values":
    circle = factory.create_shape("circle", 1000000)
    print(f"{circle.area():.2e}")

elif test_case == "polymorphism_test":
    shapes = [
        factory.create_shape("circle", 2),
        factory.create_shape("rectangle", 3, 4),
        factory.create_shape("triangle", 3, 4, 5)
    ]
    area_sum = sum(shape.area() for shape in shapes)
    perimeter_sum = sum(shape.perimeter() for shape in shapes)
    print(f"Area sum: {area_sum:.2f}, Perimeter sum: {perimeter_sum:.2f}")

elif test_case == "triangle_area":
    triangle = factory.create_shape("triangle", 3, 4, 5)
    print(f"{triangle.area():.2f}")

elif test_case == "method_override":
    circle = factory.create_shape("circle", 2)
    rectangle = factory.create_shape("rectangle", 3, 4)
    triangle = factory.create_shape("triangle", 3, 4, 5)
    
    # Methoden-Objekte abrufen, um Implementierungen zu vergleichen
    circle_area = Circle.area
    rectangle_area = Rectangle.area
    triangle_area = Triangle.area
    
    circle_perimeter = Circle.perimeter
    rectangle_perimeter = Rectangle.perimeter
    triangle_perimeter = Triangle.perimeter
    
    # Prüfen, ob alle Implementierungen eindeutig sind
    unique_areas = len({circle_area, rectangle_area, triangle_area}) == 3
    unique_perimeters = len({circle_perimeter, rectangle_perimeter, triangle_perimeter}) == 3
    
    if unique_areas and unique_perimeters:
        print("All shapes correctly override methods")
    else:
        print("Some shapes share method implementations")