Swift 基础学习(构造方法初印象)

/*
 构造方法
(1)构造方法初步
(2)缺省构造方法
(3)结构体的构造方法
(4)可选值属性与构造方法
(5)常量属性和构造方法
(6)代理构造器
*/

/*
(1)构造方法初步
构造方法的主要作用:实例对象的内容的初始化
Swift要求类或者结构体中的存储属性在对象构造完毕后要有初
始值.
构造方法的语法:
init(参数列表) {初始化代码}
*/
class MyPoint {
    var x: Int = 0 //存储属性
    var y: Int = 0
    func description() -> String {
        return "x = \(x),y = \(y)"
    }
//    //构造方法的语法
//    init() {
//        
//    }
}
//构造一个对象:(1)给对象分配内存(2)初始化这块内存(构造方法)
var p0 = MyPoint()
p0.description()//显示调用

/*
(2)带有缺省值得构造方法
   构造一个对象之后,要求对象中的所有非lazy的存储属性必须
有初始值
*/

class MyPoint1 {
    var x: Int  //存储属性
    var y: Int = 0
    func description() -> String {
        return "x = \(x),y = \(y)"
    }
        //构造方法的语法
    init() {
       x = 0
    }
}

/*
(3)带有参数的构造方法
*/
class MyPoint2 {
    var x: Int  //存储属性
    var y: Int
    func description() -> String {
        return "x = \(x),y = \(y)"
    }
    //构造方法的内部参数默认也作为外部参数
    init(_ x: Int, y: Int) {
        self.x = 0
        self.y = 0
    }
}
var p2 = MyPoint2(4, y: 2)
p2.description()

/*
(4)常量存数属性与构造方法
常量存储属性只能在构造方法中被修改,其他任何时候都不可以修改
*/
class Human {
    let name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}
var person = Human(name: "zhangsan", age: 32)
person.age = 34

/*
(5)可选属性与构造方法
*/
class CreditCard {
    let cardNumber: UInt32
    init(number: UInt32){
        self.cardNumber = number
    }
}
//可选值存储属性可以在构造方法中不进行初始化, 默认为nil
class Human1 {
    let name: String
    var age: Int
    var card: CreditCard?
    init(name: String, age: Int) {
        self.name = name
        self.age = age
//        self.card = CreditCard(number: 3243534)
    }
}

/*
(6)结构体的构造方法总结
*/
struct Rect {
    var width: Double
    var height: Double
    //如果我们自定义相应的构造方法,那么系统提供的结构体逐一成员构造方法将会失效
//    init() {
//        width = 0.0
//        height = 0.0
//    }
}
//针对结构体,系统会提供一个成员逐一构造器
var rect = Rect(width: 0.0, height: 0.0)

/*
(7)值类型的构造器原理
  直观一点儿就是"构造方法之间的相互调用"
  构造方法可以调用其他构造方法来完成实例的构造,称之为构造
器代理
   好处:减少构造方法之间的代码重复
*/
struct Segment {
    var origin: Double
    var end: Double
    init(origin: Double, end: Double) {
        self.origin = origin
        self.end = end
    }
    init(){
//        origin = 0.0
//        end = 0.0
        self.init(origin: 0.0, end: 0.0)
    }
    init(origin: Double, length: Double){
//        self.origin = origin
//        self.end = length + origin
        self.init(origin: origin, end: length+origin)
    }
    func description() -> String {
        return "(\(origin),\(end))"
    }
}
var seg0 = Segment(origin: 0.0, end: 0.0)
var seg1 = Segment()
var seg2 = Segment(origin: 0.0, length: 10.0)

/*
(8)闭包或者全局函数设置存储属性的缺省值
*/
func getValue() -> Int {
    print("get value")
    return 10
}
class TestClass {
    //x是存储属性
    //通过闭包设置初始值,()执行闭包
    var x: Int = {
        print("初始化开始")
        sleep(5)
//        () -> Int in
        return 10
    }()
    //y是计算属性
    var y: Int {
        return x < 100 ? x:100
    }
    //通过全局函数来设置缺省值
//    var z: Int = getValue()
    //或者通过类方法类设置缺省值
    var z: Int = TestClass.classGetValue()

    init(){
        //没有进行初始化时
//        x = 9
        print("初始化完毕")
    }
    class func classGetValue() -> Int {
        print("class get Value")
        return 10
    }
}
var obj = TestClass()
//print(obj.x)