1.  let 关键字是用来定义常量的，任何类型的常量都可以进行定义；例如：定义字符串 let constantValue1 = "this is a string",也可以定义数值：let constantValue2 = 30

但需要注意：.声明时如果不初始化需要加上常量的类型：let constantValue:String

2. var 关键字是用来定义变量的，任何类型的变量也可以定义,如：var variableValue1 = "this is string too" , 数值：var variableValue2 = 30.

注意：和let一样，如果定义时没有初始化需要加上变量的数据类型：var variableValue3 :String

3. 把数值转换成字符插入字符串中：如 let number = 10 

                                 let string = "the value is"

                                 let newstring = string + (string)number

更加便捷的方法是使用\(value)插入字符串中，例如修改上面的：let string = "the value is \(number)"

4. 可选值的定义，在数据类型后面加上？,例如  let string:String? = "this is a string"

可选值的作用是它里面不仅仅含有该类型的值，还有一个nil，这是为了避免程序员在编程的时候也不知道自己使用的变量已经为空，而导致系统崩溃。

而为了得到可选值里面的值你需要使用！进行打开 let otherstring = string!

    如果你想定义一个空的数组：let emptyArray = [String]()

var optionalHello: String? = "Hello"
if let hello = optionalHello where hello.hasPrefix("H"), let name = optionalName {
    greeting = "\(hello), \(name)"
}
解释：if语句执行的是把optionalhello的值赋予常亮hello，如果没有值将为false退出if，而在这个语句里，where执行的是判断可选变量optionalhello的首字母是否为大写'H'，如果为false将退出if。
注意：如果要使用where必须满足以下几点：
1、被赋的值无论你使用的在之前有没有声明过，跟在if后使用的话必须要重新声明(可以不声明类型只声明变量还是常量)。
2、(a)必须是可选类型，并且在赋值的时，必须是声明过可选类型，如果直接使用a = 1或a = "a"，将报错.
4、if里只能用于赋值，不能用于比较大小。

hasPrefix("H")是用来判断字符串是否以H来开头

 7. switch的使用：

1. let vegetable = "red pepper"
2. switch vegetable {
3. case "celery":
4. let vegetableComment = "Add some raisins and make ants on a log."
5. case "cucumber", "watercress":
6. let vegetableComment = "That would make a good tea sandwich."
7. case let x where x.hasSuffix("pepper"):
8. let vegetableComment = "Is it a spicy \(x)?"
9. default:
10. let vegetableComment = "Everything tastes good in soup."
11. }

case 后面比较的值可以是字符串、数值、运算，或者几个值在一个case中； 

hasSuffix（pepper）是用来判断字符串是否以pepper结尾

程序后面需要加上default，不然会发生报错

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

   for可以在规定的区间进行循环使用for i 0..4  

    情况(2)closed range operator ( ...)

    var number = 0

    for _ in 0...4

     {

      number += 1

     }

     print(number)

     _是通配符号，在你不需要知道循环里面具体的执行时，可以使用这个，在这里只是把number  + 1，所以不需要设置变量来执行内部代码

 9. 函数的定义使用func 函数名(参数,.......)->返回类型{}

   例子：

var name = "steven"

var day = "thursday"

func greet(name:String , day:String) -> String {

    return "Hello \(name) , today is \(day)"

}

var result = greet(name, day: day)

print(result)

当不需要返回数据时，后面的-> String可以不需要

 10. 函数的声明，使用class进行声明，格式为：class 函数名{}，

   在函数里面可以声明属性和方法；属性用var、let等来进行声明，方法使用func进行声明

class Shape {

    var number = 0

    func simpleShape() -> String

    {

        return "a shape with \(number) sides"

    }

}

 var shape = Shape()

shape.number = 1

var shapedescription = shape.simpleShape()

print(shapedescription)

但是 ，还有一个地方需要注意的是，在你定义函数的时候需要一个初始化函数，init()，这是为了创建实例的时候方便赋值。如：

class nameShape {

    var numberofside = 0

    var name:String

    init(name:String)

    {

       self.name = name

    }

       func simpledescription() -> String {

        return "a shape with \(numberofside) side"

    }

}

var assas = nameShape(name: "steven")

assas.numberofside

assas.simpledescription()

assas.name

在创建实例的时候需要把初始化函数的参数传递进去，初始化函数里面有多少个属性就需要传递多少个属性进去。

如果在定义的时候就已经初始化，就不需要再传递参数进去，但是没有初始化的必须放进初始化函数里面，并且创建实例的时候需要传进参数。

 11. 子类，格式：类名：父类名{}

class square: nameShape

{

    var sidelength:Double

    init(name:String , sidelength:Double)

    {

       self.sidelength = sidelength

        super.init(name: name)

        numberofside = 4

    } 

    func area() -> Double

    {

        return sidelength * sidelength

    }

    override func simpledescription() -> String {

        return "a square with sides of legth \(sidelength)"

    }

}

let testSquare = square(name:"my text square" , sidelength: 5.2)

testSquare.area()

testSquare.simpledescription()

当想覆盖父类的方法时，需要使用override，不然会出现报错；

想初始化父类的值时，如果父类使用init来初始化，那需要调用super.init()来进行重新赋值

创建实例的时候也可以判断传递进来的值是否符合要求，要是不符合要求就会传递一个nil，初始化函数需要用init?(){}

class Circle: nameShape

{

    var radius:Double

    init?(radius:Double , name:String)

    {

       self.radius = radius

        super.init(name: name)

        numberofside = 20

        if radius < 0

        {

            return nil

        }

    }

    override func simpledescription() -> String {

        return "a circle with a radius of \(radius)"

    }

 }

var circle = Circle(radius: 3.0 , name: "no name")

var failCircle = Circle(radius: -7.0 , name: "stenf")

circle?.simpledescription()

failCircle?.simpledescription()

circle?.name

failCircle?.name

12.枚举的定义：在枚举中不仅仅可以定义数值，还好可以定义方法：

enum Rank: Int {

    case Ace = 1

    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten

    case Jack, Queen, King

    func simpDescription() -> String {

        switch self {

        case .Ace:

            return "ace"

        case .Jack:

            return "jack"

        case .Queen:

            return "queen"

        case .King:

            return "king"

        default:

            return String(self.rawValue)

        }

    }

if let convertedRank = Rank(rawValue: 1)

    let threedescription = convertedRank.simpDescription()

    }

利用rawValue可以间接的调用枚举里面的方法

也可以像调用方法那样调用枚举里面的数值：let Jack = Rank.Jack     let Jackdescription = Jack.simpleDescription()

13.结构体的定义使用struct ：

struct Card

{

    var rank: Rank

    var suit:Suit

    func simpleDescrption() -> String

    {

        return "the \(rank.simpleDescription()) of \(suit.simpleDescription()))"

    }

  }

var  card = Card(rank: .Three , suit: .Clubs)

card.simpleDescrption()

结构体里面不仅可以定义不同的数据类型，还可以使用不同的类进行定义实例，但是定义结构体的实例时就需要传输相应的类的值进去。 

14. 协议的定义：使用protocol 

protocol ExampleProtocol {

    var simpleDescription: String { get }

    func adjust()

}

simpledescription后面跟着的string{get}是设定这个变量只能阅读，无法改写