swift的类和对象

1、类的关键字 是class。类里面可以有常量，变量，和函数。(成员变量)每个变量都要赋初值

class Shape {
    var numberOfSides = 0
    let defultDiscription =  "这是一个形状"
    func simpleDiscription() ->String{
        return "the shape has \(numberOfSides) sides"
      }
}

生成一个Shape类的对象 相当于我们OC 中的 Shape *s =[[Shape alloc ]init] 可以通过”.”去点到他们的实例变量和方法。

var  s = Shape()
print("s的边数为 \(s.numberOfSides),s 的简单描述\(s.simpleDiscription()),s的默认描述为\(s.defultDiscription)")

2、每个变量都要赋初值 , 1. 直接赋初值。 2. init方法。

class NamedShape{
    var numberOfSides:Int
    var name :String
   //在这里self是区分是否是成员变量。 init 方法他会自动给你检测你是否给你的成员变量全部都赋初值了。
    init (){
        name = "xingZhuang"
        numberOfSides = 0
    }
    init(name:String, numberOfSides :Int ){
        self.name = name
        self.numberOfSides = numberOfSides
     }
    deinit{
//    叫做析构函数，和我们OC中的dealloc用法差不多。析构函数不能带参数的，每个类最多只有一个析构函数。作用是自动销毁不用的实例变量,里面写需要销毁的对象。
    }
    func simpleDiscription() ->String{
        return "\(name) has \(numberOfSides) sides"
    }
}

声称对象时，类（初始化的参数）

var ss = NamedShape(name: "有名字的形状",numberOfSides: 10)
print(ss.name)
print(ss.simpleDiscription())
print(ss.numberOfSides)

3、类的继承与重载,函数在类的外边是函数，在类的里面就是方法。

class Square:NamedShape{
    var  sideLenght :Double
    init(name : String, sideLenght:Double){
        self.sideLenght = sideLenght
//        如果调用父类的成员变量，就要调用super.init()
        super.init()
            self.numberOfSides = 4
            self.name = "正方形"
    }
    func area()->Double{
        return sideLenght * sideLenght
    }
//    重载父类的方法。必须要有override这个关键字
    override func simpleDiscription() -> String {
        return "\(super.simpleDiscription()) the sideLenght is \(sideLenght)   area is \(area())"
    }
}

var square = Square(name: "正方形", sideLenght: 10)
print(square.simpleDiscription())

4、定义一个圆类。继承自NamedShape 有自己的成员变量半径radius 。写一个计算面积的方法，重载父类的simpleDiscription（）将面积描述出来

class Circle:NamedShape
{
    var radius:Double
    init(name: String,radius: Double)
    {
        self.radius = radius
        super.init()
        numberOfSides = 1
    }
    func area() -> Double
    {
        return M_PI * radius * radius
    }
    override func simpleDiscription()-> String
    {
        return "\(super.simpleDiscription()),radius is \(radius)"
    }
}
var c = Circle(name:"圆", radius: 40.2)
print(c.area())
print(c.simpleDiscription())

5、计算属性。OC setter和getter. 用在哪里呢 。需要进行计算才能得到某些值的时候使用

class EquliaterTriangle:NamedShape {
    var sideLength = 0.0
    init(name : String ,sideLength : Double) {
        self.sideLength = sideLength
        super.init()
        self.name = name
    }

//计算等边的三角形的周长
    var perimeter:Double{
        get{
//            通过给边长赋值，就可以得到周长。
            return sideLength * 3
        }
        set{
//            通过周长去计算边长
            sideLength = newValue/3
        }
    }
}
var equliaterTriangle = EquliaterTriangle(name: "等边三角形", sideLength: 10)
print(equliaterTriangle.perimeter)
equliaterTriangle.perimeter = 60
print(equliaterTriangle.sideLength)

6、让三角形边长改变的时候正方形边长也在改变

class TriangleAndSquare {

    var triangle:EquliaterTriangle{
        willSet{
            print("willSet\(square.sideLenght)")
            square.sideLenght = newValue.sideLength
        }
        didSet{
            print("didSet\(square.sideLenght)")
        }
    }
    var square :Square{
        willSet{
            triangle.sideLength = newValue.sideLenght
        }
}
    init(name : String ,sideLength :Double){
        triangle = EquliaterTriangle(name: name, sideLength: sideLength )
        square = Square(name: name, sideLenght: sideLength)
    }
}
var tAndS = TriangleAndSquare(name: "三角形和正方形", sideLength:20.0)
var tringle1 = EquliaterTriangle(name: "三角形", sideLength: 10.0)
tAndS.triangle =  tringle1
print(tAndS.square.sideLenght)

7、定义一个类Counter。 类中有一个增量函数，实现功能：传入一个参数amount 和一个 times。将类中的属性count 加上 amount * times

class Counter {
    var count  = 0
    func incrementBy (amount : Int ,times :Int){
         count += amount * times
    }
}
var c1 = Counter()
c1.incrementBy(10, times: 20)
print(c1.count)