// 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")
}
}
