Swift. Obiekty

W Swift dostępne są następujące obiekty typu: wyliczenia (enum), struktury (struct) i klasy (class).

Obiekty typu mogą zawierać następujące elementy:

• Metody inicjalizacyjne
• Właściwości
• Metody
• Indeksy
• Deklaracje obiektu typu

Metody inicjalizacyjne

Metoda inicjalizacyjna (init) jest funkcją, która jest wywoływana, aby utworzyć nowy obiekt.

class Figure
{
    var name = ""
    var id = 0
   
    init()
    {
    }
 
    init(name:String)
    {
        self.name = name
    }
    
    init(id:Int)
    {
        self.id = id
    }
    init(name:String, id:Int)
    {
        self.name = name
        self.id = id
    }
    /*
    init(name:String = "", id:Int = 0)
    {
        self.name = name
        self.id = id
    }
    */
}

var a = Figure()
var b = Figure(name: "kwadrat")
var c = Figure(id: 1)
var d = Figure(name: "kwadrat", id: 2)

Powyższy kod można uprościć, tworząc funkcję inicjalizacyjną z wykorzystaniem domyślnych parametrów:

class Figure
{
    var name = ""
    var id = 0
   
    init(name:String = "", id:Int = 0)
    {
        self.name = name
        self.id = id
    }
}

W powyższych przykładach wlasciwosci maja określone wartości domyślne w oparciu o które kompilator określa typ danych. Można jawnie określić typ danych, ale w tej sytuacji należy w funkcji inicjalizacyjnej ustawić wszystkie wartości.

class Figure
{
    var name : String
    var id : Int
   
    init(name:String = "", id:Int = 0)
    {
        self.name = name
        // self.id = id // odkomentuj - błąd kompilacji: Return from
        // initializer without initializing all stored properties
    }
}

Jeżeli zakładamy, że utworzenie obiektu dla pewnych parametrów nie ma sensu, możemy zwrócić z inicjalizatora wartość nil.

class Figure
{
    var name : String
    var id : Int

    init?(name:String = "", id:Int = 0)
    {
        if name.isEmpty
        {
            return nil
        }
        
        if id <= 0
        {
            return nil
        }

        self.name = name
        self.id = id
    }
}

var a = Figure()
if a == nil
{
    print("Nieokreślona figura")
}
// Wynik wykonania programu:
// Nieokreślona figura

Właściwości

Właściwość to zmienna zadeklarowana w typie obiektu. Przy założeniu, że mamy obiektu typu Figure i chcemy uzyskać dane z dlasciwosci name, robimy to jak poniżej:

var f = Figure("kwadrat", 1)
let n = f.name

Własciwość może być statyczna, dzięki czemu dostęp do niej jest globalny.

class Counter
{
    static var counter : Int = 0

    init()
    {
        Counter.counter += 1
    }
}

var c = Counter()
var count = Counter.counter
print(count)

// Wynik wykonania programu:
// 1

Metoda

Metoda jest funkcją zadeklarowaną na poziomie deklaracji obiektu typu. Dostęp do niej odbywa się za pomocą obiektu danego typu. Funkcja deklarowana jest analogicznie do funkcji w przestrzeni globalnej.

Metoda, która w deklaracji ma słowo kluczowe static jest metodą statyczną, do której można się odwołać za pomocą typu.

Indeks

Umożliwia zbudowanie dostępu do elementów obiektu typu za pomocą nawiasów kwadratowych przy egzemplarzu obiektu. Przydatne jest jeżeli obiekt zawiera elementy, do których przydatny będzie dostęp za pomocą klucza lub indeksu liczbowego.

class MyContainer
{
    var container : Array<Int>
    
    init?(max : Int)
    {
        if max <= 0
        {
            return nil
        }
        
        self.container = Array(repeating: 0, count: max)
        
        var n : Int = 0
        while n < max
        {
            self.container[n] = n + 1
            n += 1
        }
    }
    
    subscript(index:Int) -> Int
    {
        get
        {
            if index < container.count
            {
                return container[index]
            }
            return -1
        }
        set
        {
            if index >= 0 &amp;&amp; index < container.count
            {
                container[index] = newValue
            }
        }
    }
}

var container = MyContainer(max : 10)    
var item = container?[5]
container?[5] = 100

Słowo kluczowe subscript deklaruje indeks, po którym następuje określenie zmiennej i jej typu za pomocą którego nastąpi odwołanie do elementów obiektu.

W powyższym przykładzie został użyty inicjalizator, który nie tworzy obiektu, jeżeli liczba elementów jest mniejsza od 0, stąd odwołanie do elementów przez dodanie znaku zapytania przed nawiasem kwadratowym. Takie odwołanie nazywamy rozpakowaniem wartości.

W przypadku inicjalizatora, który nie zwraca wartości nil, znak zapytania nie jest wymagany.

Typ wyliczeniowy

enum definiuje zbiór elementów, który zawiera predefiniowane wartości.

enum Action
{
    case create
    case read
    case update
    case delete
}

let action = Action.create
let a : Action = .create