Swift Academy · Lekcja

Protokoły jako kontrakty

Definiowanie kontraktów zachowania niezależnie od typów.

Lekcja 1 z 413 kroki

Protokoły jako kontrakty to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Czym jest protokół?

Protokół definiuje wzorzec metod, właściwości i innych wymagań, które musi implementować zgodny z nim typ. Jest to kontrakt: każdy typ, który go przyjmuje, zobowiązuje się zapewnić wszystko, co deklaruje protokół.

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

Zgodność z protokołem

Typ uzyskuje zgodność, przyjmując protokół i spełniając wszystkie jego wymagania. W tym przykładzie typ struct spełnia wymagania dotyczące zarówno właściwości name, jak i metody greet().

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

struct Person: Greetable {
    let name: String
    func greet() -> String { "Hello, I am " + name }
}

let p = Person(name: "Ada")
print(p.greet())

Wymagania dotyczące właściwości

Protokoły określają, czy właściwość musi być dostępna do odczytu ({ get }), czy zarówno do odczytu, jak i zapisu ({ get set }). Wymaganie tylko do odczytu może spełnić właściwość przechowywana lub obliczana.

protocol Identifiable {
    var id: String { get }
}

struct User: Identifiable {
    let id: String
}

print(User(id: "u-1").id)

Wymagania dotyczące metod

Wymagania dotyczące metod określają nazwę, parametry i typ zwracany, ale nie zawierają ciała metody. Typy zgodne z protokołem dostarczają implementację.

protocol Shape {
    func area() -> Double
}

struct Square: Shape {
    let side: Double
    func area() -> Double { side * side }
}

print(Square(side: 3).area())

Wymagania mutating

W przypadku typów wartości metody zmieniające self muszą być oznaczone jako mutating. Zadeklarujcie wymaganie za pomocą mutating, aby typy struct mogły je spełnić.

protocol Toggleable {
    mutating func toggle()
}

struct Switch: Toggleable {
    var isOn = false
    mutating func toggle() { isOn.toggle() }
}

var s = Switch()
s.toggle()
print(s.isOn)

Protokoły jako typy

Protokół jest pełnoprawnym typem. Możecie używać go dla zmiennych, parametrów i wartości zwracanych, akceptując dowolną wartość zgodną z protokołem.

protocol Animal { func sound() -> String }
struct Dog: Animal { func sound() -> String { "Woof" } }
struct Cat: Animal { func sound() -> String { "Meow" } }

let animals: [Animal] = [Dog(), Cat()]
for a in animals { print(a.sound()) }

Polimorfizm za pomocą protokołów

Wywołanie metody protokołu przekazuje wykonanie do konkretnego typu ukrytego za daną wartością. Dzięki temu możecie pisać kod działający z wieloma typami za pośrednictwem jednego kontraktu.

protocol Describable { func describe() -> String }
struct Book: Describable { let t: String; func describe() -> String { "Book: " + t } }
struct Film: Describable { let t: String; func describe() -> String { "Film: " + t } }

func show(_ d: Describable) { print(d.describe()) }
show(Book(t: "Swift"))
show(Film(t: "Inception"))

Wymagania dotyczące inicjalizatorów

Protokoły mogą wymagać inicjalizatorów. Klasy muszą oznaczyć implementację jako required, aby podklasy również ją dostarczały.

protocol FromInt {
    init(value: Int)
}

struct Wrapper: FromInt {
    let value: Int
    init(value: Int) { self.value = value }
}

print(Wrapper(value: 42).value)

Dziedziczenie protokołów

Protokół może dziedziczyć po jednym lub kilku innych protokołach, dodając kolejne wymagania do odziedziczonych.

protocol Named { var name: String { get } }
protocol Aged: Named { var age: Int { get } }

struct Member: Aged {
    let name: String
    let age: Int
}

let m = Member(name: "Lin", age: 30)
print(m.name, m.age)

Protokoły tylko dla klas

Oznaczcie protokół za pomocą AnyObject, aby ograniczyć zgodność z nim do klas. Jest to przydatne w przypadku wymagań związanych z semantyką referencji, takich jak delegowanie.

protocol Counter: AnyObject {
    var count: Int { get set }
}

class Box: Counter {
    var count = 0
}

let b = Box()
b.count = 5
print(b.count)

Sprawdzanie zgodności

Używajcie is i as?, aby w czasie wykonywania sprawdzić, czy wartość jest zgodna z protokołem.

protocol Flyer { func fly() }
struct Bird: Flyer { func fly() { print("flap") } }
struct Rock {}

let things: [Any] = [Bird(), Rock()]
for t in things {
    if let f = t as? Flyer { f.fly() } else { print("grounded") }
}

Szybkie sprawdzenie

Sprawdźcie swoją znajomość wymagań protokołów.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Dowiedzieliście się, że protokół jest kontraktem: deklaruje wymagania dotyczące właściwości, metod, mutowania i inicjalizatorów, ale nie zawiera ich implementacji. Typy są zgodne z protokołem, gdy spełniają wszystkie wymagania. Protokołów można używać jako typów na potrzeby polimorfizmu, mogą dziedziczyć po innych protokołach i mogą być ograniczone do klas za pomocą AnyObject.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Protokoły jako kontrakty” jest bezpłatna?

Tak — pełny tekst „Protokoły jako kontrakty” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Protokoły jako kontrakty”?

Definiowanie kontraktów zachowania niezależnie od typów. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Protokoły jako kontrakty”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy