Ako môže použitie vzoru Singleton narušiť princípy polymorfizmu?

Singleton obmedzuje vytváranie inštancií triedy na jeden objekt. Polymorfizmus však predpokladá možnosť práce s objektmi rôznych tried cez spoločné rozhranie alebo základnú triedu.

Porušenie nastáva, keď klientsky kód pevne viaže na konkrétnu triedu Singleton, namiesto toho, aby pracoval s abstrakciou (protokolom alebo základnou triedou). V takom prípade nie je možné nahradiť iný, alternatívny objekt, ktorý implementuje rovnakú funkcionalitu, pretože klient očakáva práve inštanciu Singleton.

// Zlé použitie - klient priamo závisí od ConcreteSingleton
class ConcreteSingleton {
    static let shared = ConcreteSingleton()
    private init() {}

    func performAction() {
        print("Vykonávam akciu z ConcreteSingleton")
    }
}

// Klient
func clientFunction() {
    // Pevné viazanie na ConcreteSingleton
    ConcreteSingleton.shared.performAction()
}

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

class RealService: Service {
    func performAction() {
        print("Vykonávam akciu z RealService")
    }
}

class MockService: Service {
    func performAction() {
        print("Vykonávam akciu z MockService")
    }
}

// Singleton na poskytovanie implementácie cez protokol (voliteľné, možno použiť 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áca cez abstrakciu (protokol)
    let service = ServiceProvider.shared.getService()
    service.performAction()
}

// Príklady polymorfizmu s flexibilným klientom
// ServiceProvider.shared.setService(MockService())
// flexibleClientFunction() bude používať MockService

Takto priame používanie statického vlastnosti shared Singleton v klientskom kóde znižuje flexibilitu a bráni výmene implementácií, čo je kľúčový aspekt polymorfizmu pri práci s rôznymi typmi objektov cez spoločné rozhranie. Riešením je práca s inštanciou Singleton cez protokol alebo základnú triedu.