In Swift, perché metodo della sottoclasse non può ignorare l'uno, fornito da protocollo di estensione in superclasse

Question

So che il titolo di questa interrogazione è confusa ma il comportamento bizzarro è spiegato nel seguente esempio:

protocol Protocol { 
    func method() -> String 
} 

extension Protocol { 
    func method() -> String { 
     return "From Base" 
    } 
} 

class SuperClass: Protocol { 
} 

class SubClass: SuperClass { 
    func method() -> String { 
     return "From Class2" 
    } 
} 

let c1: Protocol = SuperClass() 
c1.method() // "From Base" 
let c2: Protocol = SubClass() 
c2.method() // "From Base" 

Come mai c1.method() e c2.method() restituiscono lo stesso? Come mai il method() in SubClass non funziona?

È interessante notare che, senza dichiarare il tipo di c2, questo sta andando a lavorare:

let c2 = SubClass() 
c2.method() // "From Class2" 

Answer 1

io non sono molto sicuro del meccanismo sottostante, ma deve essere qualcosa a che fare con il fatto che i protocolli don' t consentono necessariamente l'ereditarietà.

Un modo per risolvere questo problema è aggiungendo anche il metodo per SuperClass

import Foundation 
protocol Protocol: class { 
    func method() -> String 
} 

extension Protocol { 
    func method() -> String { 
     return "From Base" 
    } 
} 

class SuperClass: Protocol { 
    func method() -> String { 
     return "From Super" 
     } 
} 

class SubClass: SuperClass { 
    override func method() -> String { 
     return "From Class2" 
    } 
} 

let c1: Protocol = SuperClass() 
c1.method() // "From Super" 
let c2: Protocol = SubClass() 
c2.method() // "From Class2" 

Answer 2

Fondamentalmente sì, se v'è una superclasse conforme al protocollo, ma non fornisce un'implementazione per esso, la l'implementazione dell'estensione del protocollo sarà disponibile in sottoclassi, anche se le sottoclassi hanno un'implementazione (tuttavia devono essere castate alla superclasse o al tipo del protocollo).

Tuttavia, se la superclasse ha un'implementazione del metodo del protocollo, l'implementazione del protocollo non sarà disponibile né dalla superclasse né dalle sottoclassi.

Answer 3

Il problema è che c1 e c2 sono di tipo Protocol, come hai definito esplicitamente il loro tipo in questo modo (ricorda: i protocolli sono tipi completi). Ciò significa che quando chiama il numero method(), Swift chiama il numero Protocol.method.

---

Se si definisce qualcosa come:

let c3 = SuperClass() 

... c3 è di tipo SuperClass. Poiché SuperClass non ha una dichiarazione più specifica method(), è ancora utilizzato, Protocol.method(), quando si chiama c3.method().

---

Se si definisce qualcosa come:

let c4 = SubClass() 

... c4 è di tipo SubClass. Poiché SubClass ha una dichiarazione più specifica method(), viene utilizzato SubClass.method() quando si chiama c4.method().

---

Si potrebbe anche ottenere c2 chiamare SubClass.method(), da down-fusione a `SubClass:

(c2 as! SubClass).method() // returns "From Class2" 

---

Ecco una dimostrazione su SwiftStub.