Návrhové vzory a SOLID principy: Základy dobrého programování

Chceš psát lepší kód, který bude přehledný, udržitelný a připravený na budoucí změny? Pak bys měl znát dva základní pojmy softwarového vývoje: návrhové vzory (design patterns) a SOLID principy. Pojďme si je vysvětlit jednoduše a prakticky.

Co jsou návrhové vzory

Návrhové vzory jsou obecně uznávaná řešení typických problémů při návrhu softwaru. Pomáhají ti psát kód, který je opakovatelný, snadno pochopitelný a udržovatelný. Nejde o konkrétní kód, ale o šablony, jak organizovat třídy a objekty.

Příklad 1: Singleton

Umožňuje vytvořit jen jednu instanci třídy v celé aplikaci – např. pro připojení k databázi.

class Database {
    private static ?Database $instance = null;

    private function __construct() {}

    public static function getInstance(): Database {
        if (self::$instance === null) {
            self::$instance = new Database();
        }
        return self::$instance;
    }
}

Příklad 2: Strategy

Umožňuje dynamicky měnit chování objektu – např. různé způsoby výpočtu slevy.

interface DiscountStrategy {
    public function calculate(float $price): float;
}

class NoDiscount implements DiscountStrategy {
    public function calculate(float $price): float {
        return $price;
    }
}

class TenPercentDiscount implements DiscountStrategy {
    public function calculate(float $price): float {
        return $price * 0.9;
    }
}

class Cart {
    public function __construct(private DiscountStrategy $strategy) {}

    public function getFinalPrice(float $price): float {
        return $this->strategy->calculate($price);
    }
}

Co jsou SOLID principy

SOLID je zkratka pro pět základních principů objektově orientovaného návrhu, které zajišťují, že tvůj kód bude dobře strukturovaný a snadno rozšiřitelný.

1. S – Single Responsibility Principle (SRP)

Každá třída by měla mít pouze jednu odpovědnost.

// Špatně: třída dělá vše – ukládá data a tiskne je
class Report {
    public function saveToFile() {}
    public function printReport() {}
}

// Dobře: rozdělíme zodpovědnosti
class ReportSaver {
    public function save(Report $report) {}
}

2. O – Open/Closed Principle (OCP)

Kód by měl být otevřený pro rozšíření, ale uzavřený pro úpravy.

interface Shape {
    public function getArea(): float;
}

class Rectangle implements Shape {
    public function getArea(): float {
        return 10 * 5;
    }
}

class Circle implements Shape {
    public function getArea(): float {
        return pi() * 3 * 3;
    }
}

3. L – Liskov Substitution Principle (LSP)

Potomek by měl být plnohodnotnou náhradou za rodiče.

class Bird {
    public function fly() {}
}

class Ostrich extends Bird {
    public function fly() {
        throw new Exception("Ostrich can't fly!");
    }
}
// Porušuje LSP – Ostrich by neměl dědit fly()

4. I – Interface Segregation Principle (ISP)

Rozhraní by měla být malá a specifická, ne obří a všeobjímající.

interface Printer {
    public function print();
}

interface Scanner {
    public function scan();
}

// Lepší než jedno velké "MultifunctionDevice" rozhraní

5. D – Dependency Inversion Principle (DIP)

Závislost na abstrakcích, ne na konkrétních třídách.

interface Mailer {
    public function send(string $message);
}

class SmtpMailer implements Mailer {
    public function send(string $message) { /* ... */ }
}

class Notification {
    public function __construct(private Mailer $mailer) {}

    public function notify(string $text) {
        $this->mailer->send($text);
    }
}

Proč to všechno používat?

• Lepší udržovatelnost a rozšiřitelnost aplikace
• Snadnější testování a refaktoring
• Větší přehlednost při práci v týmu

Závěr

Návrhové vzory i SOLID principy nejsou dogmata, ale osvědčené přístupy, které ti pomohou psát kvalitní, elegantní a robustní kód. Ať už jsi začátečník nebo pokročilý vývojář, určitě stojí za to je znát a používat.

Poslední aktualizace článku proběhla 10.4.2025.