• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Swift-9-类和结构体

原作者: [db:作者] 来自: [db:来源] 收藏 邀请
// Playground - noun: a place where people can play

import UIKit

// 几个重要的概念Properties/Methods/Subscripts/Initialization/Extensions/Protocols/Inheritance/Type Casting/Deinitialization/Automatic Reference Counting
// 定义语法
class someClass {
    // 定义其它内容,如属性,方法,下标,初始化方法等等
}

// 属性 Properties
// 存储属性
class Person {
    var name : String = "Anna"
    var age : Int = 20
}

// 延迟存储属性[第一次使用时才进行初始化的属性,只能是var]
class Dog {}
class PersonContainsDog {
    lazy var dog : Dog = Dog()
}
var pcd = PersonContainsDog()
//pcd.dog 调用此行代码时才会去初始化dog属性

// 计算属性
class Square {
    var width : Double = 0.0
    var girth : Double {
        get {
            return width * 4
        }
        
        set {
            width = newValue / 4 // 和OC类似,这里set有个默认参数newValue表示即将设置的值
        }
    }
}

var s = Square()
s.girth = 20
println("s width is \(s.width)")

// 只读属性。对于只读计算属性,可以简写,直接return,不用写set,get关键字
class Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume : Double {
        return width * height * depth
    }
}

// 属性监听器
class PropertyObserver {
    var count : Int {
        willSet {
            println("willSet:\(newValue)")
        }
        
        didSet {
            println("didSet:\(oldValue)")
        }
    }
    
    init() {
        count = 1
    }
}

class PropertyObserverSubclass: PropertyObserver {
    override var count : Int {
        willSet {
            println("willSet:\(newValue)-sub")
        }
    }
}

var p = PropertyObserverSubclass()
p.count = 2

// 注意:1.提供了set方法时,无法再提供willSet,因为在set方法里便可以监听属性改变 2.willSet和didSet在属性初始化的过程中不会调用,只有当属性的值在初始化之外的地方被设置时才调用

// 类属性 使用class声明的
class SomeClass {
    class var someClassProperty : Int {
        return 20
    }
}

// 方法
// 实例方法:只能用对象实例调用的方法,也成为“对象方法” 对应OC中 “-” 开头的方法
class Counter {
    var count = 0
    func increment() {
        count++
    }
}

var counter = Counter()
counter.increment() // 通过实例变量调用

// 方法的局部和外部参数 默认方法内的局部参数名也是外部参数名,相当于默认加 #
class CounterBy {
    var count = 0
    func incrmentBy(amount: Int, numbersOfTimes: Int) {
        count += amount * numbersOfTimes
    }
    // 下面的写法与上面一致
//    func incrmentBy(amount: Int, #numbersOfTimes: Int) {
//        count += amount * numbersOfTimes
//    }
    // 下面的写法为第一个参数生成外部变量名, 同时取消第二个参数的默认外部参数名 因为参数是方法的一部分,所以下面的方法与第一个方法是不同的,写在一起不会报错
    func incrmentBy(#amount: Int, _ numbersOfTimes: Int) {
        count += amount * numbersOfTimes
    }
    
    // 参数名作为方法的一部分,参数不同,方法不同. 所以此方法可以与第一个共存
    func incrmentBy(amount: Int, someTimes: Int) {
        count += amount * someTimes
    }
}

var counterBy = CounterBy()
counterBy.incrmentBy(3, numbersOfTimes: 4)
counterBy.incrmentBy(amount: 3, 4)
counterBy.incrmentBy(3, someTimes: 4)

// 类型方法 使用class关键字修饰,可以直接通过类型调用
class Calculator {
    class func sum(num1: Int, num2: Int, num3: Int) -> Int {
        return num1 + num2 + num3
    }
}

Calculator.sum(1, num2: 2, num3: 3)

// self 同OC中self一样. 在方法内部,self表示方法调用者本身,可以是实例,也可以是类

// 附属脚本subscript
// 基本用法 基本用法同方法,可以重载
class someList {
    var name = "someList"
    subscript(index: Int) -> String{
        return name + "\(index)"
    }
    
    subscript(prefix: String) ->String{
        return prefix + name
    }
    
    subscript(num1: Int, num2: Int) -> Int {
        return num1 + num2
    }
}

var somelist = someList()
somelist[10]
somelist["hello, "]
somelist[2, 6]

// 继承 inheritance 与OC基本一致
// 重写方法, 对重写的方法加override关键字
class Animal {
    var age = 3
    func run() {
        println("animal-->func run")
    }
}

class Cat: Animal {
    override func run() {
        println("Dog-->override func run");
        super.run()
    }
}
// 重写属性 1、可以将存储属性重写为计算属性 2、可以将只读属性重写为读写属性 3、不可以将读写属性重写为只读属性
class CatForAge : Animal {
    override var age: Int {
        set {
            super.age = newValue * 2 // 注意不能使用self.age,会导致死循环。应调用super的set方法
        }
        
        get {
            return super.age * 10 // 注意不能使用self.age 会导致死循环。应调用super的get方法
        }
    }
}
var cat = CatForAge()
cat.age = 5
cat.age

// 重写属性观察 property observer 重写之后,仍会调用父类的willSet和didSet
class CatForPropertyOberver :Animal {
    override var age: Int {
        willSet {
            println("CatForPropertyOberver-WillSet")
        }
        
        didSet {
            println("CatForPropertyOberver-DidSet")
        }
    }
}
var catFPO = CatForPropertyOberver()
catFPO.age = 4

// 防止重写 final 使用final修饰的属性,方法,脚本无法被重写
class CatForFinal : Animal {
    final var name = "final" // 子类重写该属性时会报错。方法和脚本类似
}

// 构造 initialization 原则,保证所有的属性初始化完成
// 1、没有默认值的存储属性,要在初始化过程中赋值 2、初始化过程中为属性赋值不会触发属性观察器 3、便利构造方法相当于对指定构造方法的封装 4、子类的指定构造方法默认会调用父类的无参指定构造方法
class Color {
    let red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red = red
        self.green = green
        self.blue = blue
    }
    
    convenience init(black: UIColor) {
        self.init(red: 255.0, green: 255.0, blue: 255.0)
    }
}
var c = Color(red: 255, green: 255, blue: 255)
var anotherC = Color(black: UIColor.blackColor())

// 析构 和dealloc一样. 主要用来释放资源,且不可主动调用
class SomeObj {
    deinit {
        println("someobj dealloc or deinit")
    }
}

 


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap