学习 swift (1)

https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/Lesson1.html#//apple_ref/doc/uid/TP40015214-CH3-SW1

这个链接里面介绍的 swift 的语法大部分都很容易理解。对于部分特别的地方做下记录

Structures support many of the same behaviors as classes, including methods and initializers. One of the most important differences between structures and classes is that structures are always copied when they are passed around in your code, but classes are passed by reference. Structures are great for defining lightweight data types that don’t need to have capabilities like inheritance and type casting.

这里对 struct 和 class 做了比较

    struct 和 class 都有自己的 methods 和 initializers

    struct 和 class 最重要的区别在于：变量传递(赋值/传参)时，struct 是值传递(也就是拷贝，C++ 也是如此)，而 class 是传引用(类似 Java)

    如果不需要考虑 继承和类型转换，那么用 struct 比较合适

A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. The protocol doesn’t actually provide an implementation for any of these requirements—it only describes what an implementation will look like. The protocol can then be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements. Any type that satisfies the requirements of a protocol is said to conform to that protocol.

protocol ExampleProtocal {
    var simpleDescription: String { get }
    func adjust()
}

简单说，protocol 就是定义了一组 methods, properties balabala的类，不过 protocol 是用来被继承的，被 class, structure, enumeration 继承。实现了 protocal 里的那些东西，就符合这个 protocol。大概可以看成是一种接口吧。

{get} 表示 read-only

不带花括号的函数 adjust 就是声明来让继承 ExampleProtocol 的 class/struct/enumeration 实现的。

delegate 和 protocol 相关链接 http://haoxiang.org/2011/08/ios-delegate-and-protocol/

附上练习代码

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
var optionalHello: String? = "Hello"

if let hello = optionalHello where hello.hasPrefix("H"), let name = optionalName {
    greeting = "(hello), (name)"
}
print(greeting)

let vegetable = "red pepper"
var vegetableComment: String?
switch vegetable {
    case "celery":
        vegetableComment = "Add some raisins and make ants on a log."
    case "cucumber", "watercress":
        vegetableComment = "That would make a good tea sandwich."
    case let x where x.hasSuffix("pepper"):
        vegetableComment = "Is it a spicy (x)?"
    default:
        vegetableComment = "Everything tastes good in soup."
}
print(vegetableComment)

var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

var secondForLoop = 0
for _ in 0...4 {
    secondForLoop += 1
}
print(secondForLoop)


func greet(name: String, day: String) -> String {
    return "Hello (name), today is (day)."
}
print(greet("hangj", day: "Thursday"))

let exampleString = "hello"
if exampleString.hasSuffix("lo") {
    print("ends in lo")
}

var array = ["apple", "banana", "dragonfruit"]
array.insert("cherry", atIndex: 2)
print(array)

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with (numberOfSides) sides."
    }
}
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
print(shapeDescription)

class NamedShape {
    var numberOfSides = 0
    var name: String

    init(name: String) {
        self.name = name
    }

    func simpleDescription() -> String {
        return "A shape with (numberOfSides) sides."
    }
}
let namedShape = NamedShape(name: "my named shape")
print(namedShape.simpleDescription())

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String){
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {
        return "A suqare with sides of length (sideLength)."
    }
}
let testSquare = Square(sideLength: 5.2, name: "my test square")
print(testSquare.area())
print(testSquare.simpleDescription())

class Circle: NamedShape {
    var radius: Double

    init?(radius: Double, name: String) {
        self.radius = radius
        super.init(name: name)
        numberOfSides = 1
        if radius <= 0 {
            return nil
        }
    }

    override func simpleDescription() -> String {
        return "A circle with a radius of (radius)."
    }
}
if let successfulCircle = Circle(radius: 4.2, name: "successful circle") {
    print(successfulCircle.simpleDescription())
}
let failedCircle = Circle(radius: -7, name: "failed circle")

class Triangle: NamedShape {
    init(sideLength: Double, name: String) {
        super.init(name: name)
        numberOfSides = 3
    }
}
let shapesArray = [Triangle(sideLength: 1.5, name: "triangle1"),
    Triangle(sideLength: 4.2, name: "triangle2"), Square(sideLength: 3.2, name: "square1"),
    Square(sideLength: 2.7, name: "square2")]
var squares = 0
var triangles = 0
for shape in shapesArray {
    if let square = shape as? Square {
        ++squares
    } else if let triangle = shape as? Triangle {
        ++triangles
    }
}
print("(squares) squares and (triangles) triangles.")

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
            case .Ace:
                return "ace"
            case .Jack:
                return "jack"
            case .Queen:
                return "queen"
            case .King:
                return "king"
            default:
                return String(self.rawValue)
        }
    }
}
let ace = Rank.Ace
print(ace.simpleDescription())

enum Suit {
    case Spades, Hearts, Diamonds, Clubs
    func simpleDescription() -> String {
        switch self {
            case .Spades:
                return "Spades"
            case .Hearts:
                return "hearts"
            case .Diamonds:
                return "diamonds"
            case .Clubs:
                return "clubs"
        }
    }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()
print(heartsDescription)

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The (rank.simpleDescription()) of (suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
print(threeOfSpadesDescription)

protocol ExampleProtocal {
    var simpleDescription: String { get }
    func adjust()
}
class SimpleClass: ExampleProtocal {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.simpleDescription = "fuck"
a.adjust()
print(a.simpleDescription)

class SimpleClass2: ExampleProtocal {
    var simpleDescription: String = "Another very simple class."
    func adjust() {
        simpleDescription += "  Adjusted."
    }
}
var protocolArray: [ExampleProtocal] = [SimpleClass(), SimpleClass(), SimpleClass2()]
for instanse in protocolArray {
    instanse.adjust()
    print(instanse.simpleDescription)
}