Kategorie: Swift

Swift Introduction

– modernere Version von C-objektive
– keine Strichpunkte
– wenig Sonderzeichen (vgl. import)

// datei.swift
// inhalt (schlagwort)
//
// created by Katrin Bächli 19.10.15
// Linzenz
import Metal
var lenght:Int    
var doubleMatrix:[Double]   
var matrix:[Int16]
for n in 0...3 {
.               var1 = (matrix[n]);
.            }
if  var1 < 12 {
.            return 0
.        }
while value2 > value1 * 1.5 {
.            volume = value2 * 2
.        }
class ProjectComponentSubject {   
        
.     init(<variables>){

.       // Klasseneigenschaften setzen
.       self.var1 = var1

.       // Instanzeigenschaften setzen
        var2 = var3 * var4
.    }

.   // Funktionen
.   func inverse() -> a_Buffer {
.       // Code
.    }

Vererbte Klasse

class ProjectComponentSubject : Parent, Interface { 
}  
class SwisscomRTSTCPConnect : NSObject, ADTCPSocketDelegate {
. 
}

Nach dem Doppelpunkt kommen die Eltern und deren Schnittstelle.

swift introduction

Implizite Typzuweisung
Der Datentyp muss nicht angegeben werden. Vor dem Variablenname definiert man nur, ob es sich um eine Konstante let  oder eine Variable var  handelt.

let length_box = 5                 // wird zu int
let hight_box = 3.5                // wird zu float
let projectname = "ImageRecover"   // wird zu string 
var number = 2
var isPressed = true               // bool

Konstanten sind Variablen vorzuziehen. let area = Squar(length:5)

Explizite Typzuweisung
Nach dem Variablenname kann über : den Datentyp definiert werden.

var number: Int16 = 2        // Integer definieren                  
let matrix:[Int16]


Nullpointer 

var device: MTLDevice!;        //Typ ist MTLDevice mit Nullpointer


Ausführen nur bei Objekten mit Inhalt
Sind Variablen, Funktionen oder Klassen mit ?  definiert, wird der Code nur ausgeführt (bzw. ein Wert zugewiesen), wenn das Objekt einen Wert enthält.

var answer: String?         // answer erhält Wert nur, wenn String Inhalt hat
var error: NSError? 
var age: Int?               // variable hat initalwert.
if answer {                //answer ! nil
.    // do
}

if age {                  // nur wenn age einen Wert hat
.   // do
}

 

swift Vererbung über Delegierte

Zwei Dateien
Proj_Bauteil_Funktion.swift
Proj_Bauteil_FunktionDelegate.swift

Inhalt DateiDelegate.swift

import Bibliothek

protocol Proj_Bauteil_FunktionDelegate {
.    func name(<var>:<Type>!)
}

Ähnlich zum Header gibt sie das an, was importiert wird.

Bezug auf Vererbung in der Hauptdatei

class xy {
.          // Deklarationen
.         var delegate: Proj_Bauteil_FunktionDelegate?
.
.        // Funktionen
.       func tcpSocket( <argument>) {
.                // Code
.                delegate?.receiveAck(data)
}

Die vererbte Variable wird mit einem ?  definiert und immer mit einem ?  aufgerufen.
Was bedeutet das !  ?
Vermutung: Die Eltern erhalten dieses Zeichen.

 

Swift: Vererbung

  • Alle Swift Objekte sind Subklassen der Klasse NSObjekt oder einer ihrer Subklassen. Die Superklasse wird mit : in der Definition angegeben
    class A: Superklasse.
  • Das Init muss alle Paramter der Superklasse enthalten und weist dieser mit super.init(variable1 = variable1) einen Wert zu
  • Variablen der Superklasse können (ohne super) im init überschrieben werden.  variable2 = 5;
  • Funktionen werden ausserhalb des init() überschrieben und brauchend das keyword override.Bsp der iOS Developper Site
    class NamedShape {
        var numberOfSides = 0
        var name: String
        
        init(name: String) {
            self.name = name     // self für eigene Klassenvariable
        }
        
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }


    class Square: NamedShape {
        var sideLength: Double
        
        init(sideLength: Double, name: String) {
            self.sideLength = sideLength   // eigene Klassenvariable
            super.init(name: name)    // Variable der Superklasse
            numberOfSides = 4 // Überschreibt Variable der Superklasse
        }
        
        func area() ->  Double {
            return sideLength * sideLength
        }
        
        override func simpleDescription() -> String {
            return "A square with sides of length \(sideLength)."
        }
    }
    let testSquare = Square(sideLength: 5.2, name: "my test square")
    testSquare.area()
    testSquare.simpleDescription()

..

Swift: Constructor

Implizite Variablendeklaration gilt beim Konstruktor nicht

Swift kennt die implizite Variablendeklatration: let a = 5.  So ist die Variable a implizit ein Integer.

class Shape {
  var numberOfSides = 0

  init(numberOfSides:Int){
     self.numberOfSides = numberOfSides
}

 

Instanzierung bedingt Wertzuweisung
Bei der Instanzierung muss dem Argument ein Wert  zugewiesen werden.

var s1 = Shape(numberOfSides: 4);  // numberOfSides = 4

 

Konstruktor einer vererbten Klasse

Der Konstruktor muss mindestens die Argumente der Superklasse enthalten. Kann auch eigene Klassenvariablen zusätzlich auflisten

init(numberOfSides:Int, name:String){
    super.init(numberOfSides = numberOfSides)  // Zuweisung Superklasse
    self.name = name     // Zuweisung zu eigener Klassenvariable
}

Mehr Details zur Vererbung in anderem Beitrag.

 

..