Swift-类

class Class1 {  // 类文件名可以与类名不一样

    //properties 属性

    //methods 方法

    //initializers 初始化

}

 

//继承

class Vehicle:NSObject {   //NSObject可以省略

   //

}

 

class bicycle:Vehicle {

   //

}

 

class TestClass2 {

    var properties1=0       //储值属性

    var ComputedPP:String{ //算值属性，通常通过储值属性计算得到

        get{               //读属性

           return "properties1=\(properties1)"

       }

        set{               //写属性，set不一定要有

            //可以通过newValue变量访问新值

       }

    }

}

 

 

 

class TestClass3 {

    var properties2:Int?       //储值属性，同时赋默认值0

    var properties22=0        //必须有初始值，or设置为可能值，如properties2

    var ComputedPP:String{     //如果只有get属性，可以缩写如下：

        return "properti es2=\(properties2)"

    }

}

 

letsomeClass=TestClass3()  //内存空间分配也完成了

 

//访问属性

someClass.properties22

//设置属性

someClass.properties2=3

someClass.properties2

 

//初始化

class TestClass4:TestClass3 {

    override init(){   //只是初始化，无返回值（地址啥的）

        super.init()    //父类初始化，可省

        properties2=2   //父类TestClass3的属性

        properties22=2

       

    }

}

let Class4=TestClass4()

Class4.properties2

Class4.properties22

Class4.ComputedPP

 

//属性覆盖

class Car:TestClass2{

   var speed=0.0

   var TestValue: String?

    override init() {

       super.init()

        properties1=4

    }

   override var ComputedPP:String{

       get{

           return "Test"

       }

       set{

           TestValue = newValue

       }

    }

}

 

let car1=Car()

car1.ComputedPP

car1.ComputedPP="haha"

car1.TestValue

 

//属性观察

class ParentsCar:Car {

   override var speed:Double{

       willSet{

            //在这里通过newValue变量访问新值

            //比如：

           if newValue>10{

               println("xxx")

           }

       }

       didSet{

            //在这里通过oldValue变量访问旧值

       }

    }

}

 

在给观察的属性设置一个新值时，会执行willSet和didSet方法

 

//方法

class Counter{

   var count=0

   func incrementBy(amount:Int){

        count+=amount       //count就是上面的属性count

    }

   func resetToCount(count:Int){

        self.count=count    //如果方法的参数跟类属性名冲突，则self.xx是访问类的属性

    }

}

 

//==================================

//===========下面是例子=============//

//==================================

class NamedShape {

   internal var numberOfSides: Int = 0 //store property

   var name: String                   //store property

    var 边长: Int?                      //store property

    var 周长: Int{                      //computed property

       get{

            return numberOfSides * 边长!  //此处需要强制解析,否则会报错

       }

       set{

            边长 =  newValue / numberOfSides

       }

    }

   init(name: String){

       self.name = name

    }

   func simpleDescription() -> String{

        return "A shape with \(numberOfSides)sides"

    }

}

let newNameShape=NamedShape(name:"ABC")  //注意这里，要连参数名（name）一起写才有效

newNameShape.simpleDescription()

newNameShape.name

newNameShape.边长=10

newNameShape.numberOfSides=6

newNameShape.周长

newNameShape.周长=100

newNameShape.边长

 

 

 

classEquilateralTriangle: NamedShape {

   var sideLength = 0.0

   init(sideLength: Double, name1: String){

       self.sideLength=sideLength

       super.init(name:name1)

        numberOfSides=3

    }

    var perimeter: Double{      //周长

       get{

           return 3.0 * sideLength

       }

       set{

            sideLength = newValue / 3.0 //新值的名字默认是newValue

       }

    }

   override func simpleDescription() -> String {

        return "sideLength = \(sideLength)."

    }

    override var 周长: Int {      //重写算值属性

       get{

           return 3 * Int(sideLength)

       }

       set{

           sideLength = Double(newValue) / Double(numberOfSides)

       }

    }

    

}

 

let newtriangle=EquilateralTriangle(sideLength:1.1,name1: "3A" )

newtriangle.perimeter

newtriangle.perimeter = 6.0

newtriangle.sideLength

newtriangle.simpleDescription()

newtriangle.周长

newtriangle.周长=100

newtriangle.sideLength

 

//属性观察的例子

class TriangleAndSquare {

   var 新值: Double?

   var 旧值: Double?

    var triangle : EquilateralTriangle{

       willSet{

           新值 = newValue.sideLength

           println("新值 =\(新值)")

       }

       didSet{

           旧值 = oldValue.sideLength

           println("旧值 =\(旧值)")

       }

    }

    init(size: Double,nameTandS: String){

       triangle=EquilateralTriangle(sideLength:size, name1: nameTandS)

    }

}

let TandS=TriangleAndSquare(size: 10, nameTandS: "等边三角形1")

TandS.triangle=EquilateralTriangle(sideLength:1.0, name1:"HAHA")

 

//比较两个常量或变量是否引用同一个实例

letTandT = TriangleAndSquare(size: 10, nameTandS: "等边三角形1")

let TandS2 = TandS

TandS === TandT // 返回false

TandS !== TandT // 返回true

TandS === TandS2// 返回true