Jak může použití vzoru Singleton narušovat principy polymorfismu?

Singleton omezuje vytváření instancí třídy na jeden objekt. Polymorfismus však předpokládá možnost práce s objekty různých tříd prostřednictvím společného rozhraní nebo základní třídy.

Porušení nastává, když je klientský kód pevně vázán na konkrétní třídu Singleton, místo aby pracoval s abstrakcí (protokolem nebo základní třídou). V takovém případě není možné nahradit jiným, alternativním objektem, který implementuje stejnou funkčnost, protože klient očekává přesně instanci Singleton.

// Špatné použití - klient je přímo závislý na ConcreteSingleton
class ConcreteSingleton {
    static let shared = ConcreteSingleton()
    private init() {}

    func performAction() {
        print("Provedení akce z ConcreteSingleton")
    }
}

// Klient
func clientFunction() {
    // Pevné vázání na ConcreteSingleton
    ConcreteSingleton.shared.performAction()
}

// Dobré použití - klient závisí na protokolu
protocol Service {
    func performAction()
}

class RealService: Service {
    func performAction() {
        print("Provedení akce z RealService")
    }
}

class MockService: Service {
    func performAction() {
        print("Provedení akce z MockService")
    }
}

// Singleton pro poskytování implementace přes protokol (volitelné, lze použít DI)
class ServiceProvider {
    static let shared = ServiceProvider()
    private init() {}

    private var currentService: Service = RealService()

    func setService(_ service: Service) {
        currentService = service
    }

    func getService() -> Service {
        return currentService
    }
}

// Klient
func flexibleClientFunction() {
    // Práce přes abstrakci (protokol)
    let service = ServiceProvider.shared.getService()
    service.performAction()
}

// Příklady polymorfismu s flexibilním klientem
// ServiceProvider.shared.setService(MockService())
// flexibleClientFunction() bude používat MockService

Tímto způsobem, přímé použití statické vlastnosti shared Singletonu v klientském kódu snižuje flexibilitu a ztěžuje nahrazení implementací, což je klíčový aspekt polymorfismu při práci s různými typy objektů přes společné rozhraní. Řešením je pracovat s instancí Singleton přes protokol nebo základní třídu.