iOS中 Swift初级入门学习(三)

//
//  main.swift
//  LessonSwift-03
//

//  Copyright (c) 2015年 韩俊强. All rights reserved.
//

import Foundation

// 声明一个类, 我们用class关键字修饰
// 类可以被继承, 它是引用类型
class Student {
    var name = "小米"
    var gender = "男"
    var age = 18
}
// 创建一个student实例
let studnet = Student()
let student2 = studnet
// 如何判断两个实例是否一样
if studnet === student2{
    println("两个实例一样, 都操作的同一块内存")
}else{
    println("两个实力不一样")
}

// 在类中,判断两个实力是否相等, 用 === ,不相等用 !==
let student3 = Student()
if student3 !== studnet {
    println("不一样")
}else{
    println("一样")
}

// 声明结构体我们用struct关键字
struct Person {
    var name : String
    var age : Int
}
var person = Person(name: "小妹妹", age: 19)
var person2 = person
// 结构体中,不能判断两个实例是否相等
//if person === person2 {
//
//}

// 属性
// 根据调用对象的不同, 属性可以分为类属性, 还有实例类型属性
// 根据功能的不同, 属性可以分为存储属性 和 计算属性
struct Animal {
    // 这两个属性是对象来调用的, 是实例属性
    // 这两个属性是用来存储值的, 是存储属性
    var typeName : String
    var isFly : Bool
}
// 创建一个实例
var dog = Animal(typeName: "泰迪", isFly: false)
// 该属性的作用是存储值, 调用的对象是实例
dog.typeName = "藏獒"
println(dog.isFly)


class Human {
    var name : String!
    var age : Int!
    
    // 延迟存储属性
    // 延迟存储属性用lazy修饰, 而且必须是可变的, 也就是说要用var 来修饰变量, 还要给初值, 什么时候创建, 就和我们oc中的懒加载一样
    lazy var cat : Animal = Animal(typeName: "波斯猫", isFly: true)
    
}
let aHumen = Human()
// 调用该属性的时候, 才会被创建
aHumen.cat.typeName = "加菲猫"
println(aHumen.cat.typeName)

// 计算属性
class CoolPerson {
    var name : String!
    var age : Int!
    
    // 有set get方法, 或者只有get方法的属性叫做计算属性, 计算属性不能给属性赋值, 只能给其他属性赋值
    var countProperty : String{
        set {
            // newValue 就是系统在set方法中为我们提供的一个新值, 也就是我们给该属性赋的值
            println(newValue)
            name = newValue

        }
        get {
            // 把值给我们的计算属性
            return "\(name)" + "好帅"
        }
    }
}
let 小妹妹 = CoolPerson()
小妹妹.countProperty = "朱丽叶"
println(小妹妹.name)
println(小妹妹.countProperty)



class Teacher {
    var name = "小花"
    var age = 19
    // 只有get方法的属性就叫只读属性, 不能给该属性赋值
    var gender : String {
//        get {
//            return "男"
//        }
        // 简洁写法
        return "男"
    }
}
// 创建一个实例
let 小花 = Teacher()
//小花.gender = "女"

// 属性观察器
class Bird {
    var isFly : Bool!
    var age : Int! {
    
    willSet {
    // 属性将要被赋值的时候会走的方法
    // newValue 是新值
    println("newValue = \(newValue)")
    
    }
    didSet {
    // 属性已经被赋值的时候会走该方法
    println("oldValue = \(oldValue)")
    
       }
   }
}
let aBird = Bird()
aBird.age = 19


// 类属性
struct Desk {
    // 结构体中的属性我们用static修饰
    // 结构体中的类属性, 我们要给它赋初始值
    static var price : Float = 2
    static var numbers : Int = 1
    static var totalPrice : Float {
        set {
        // newValue 的类型和 totalPrice一致
            numbers = Int(newValue)
        }
        get {
            return Float(numbers) * price
            
        }
    }
}
// 类属性通过类名调用
Desk.numbers = 10
println("总价格 == \(Desk.totalPrice) 元")


// 类的类属性
class Fruit {
    // 类的类属性用class关键字来修饰, 并且只能修饰计算属性
    class var name : String {
    get {
    return "hello"
    }
   
   }
}
println(Fruit.name)

// 方法
// 按照调用对象的不同, 方法可以分为类方法和实例方法
class Plane {
    // 实例方法
    func canFly() {
        println("我会飞")
    }
}
let plan = Plane()
plan.canFly()

struct Ship {
    // 实例方法
    func canShip() {
        println("我会在水里跑")
    }
}
let ship = Ship()
ship.canShip()

// 类方法
struct Man {
    // 结构体中的类方法, 我们用static来修饰
    static func playLOL() {
        println("男人喜欢LOL")
    }
}
// 通过 类名.方名 的方式调用类方法
Man.playLOL()
// 类中的类方法我们用class来修饰, 通过 类名.方法名 的方式来调用
class Women {
    class func shopping() {
        println("败家")
    }
}

// 继承
// 没有继承类叫基类, 也叫做超类
class YaPei {
    var name = "亚培"
    var age = 23
    var description : String {
        println("\(name) 年龄 \(age) 喜欢逛淘宝")
        return "\(name) 年龄 \(age) 喜欢逛淘宝"
    }
    // 如果一个类的属性或者方法不想被继承, 我们可以在方法或者属性前面加关键字 final , 如果整个类都不想被继承 就在 class前面加 关键字 final
   final func infoOfYaPei(){
        println("这是个基类的方法");
    }
}
class SonOfYaPei: YaPei {
    
    // 不能重写存储属性
//    override var name = "小花"
    // 我们只能重写计算属性, 用override来修饰
    override var description : String {
        return "\(name) 的子类"
    }
//    override func infoOfYaPei() {
//        println("重写了父类的方法,这是子类的方法")
//    }
    
}
let pei = YaPei()
println(pei.description)
pei.infoOfYaPei()


// 构造方法
class Monkey {
    var name : String
    var gender : String
    var age : Int
    // 构造方法, 通过构造方法我们要保证每一个没有值的属性被赋值
    init(name : String,age : Int,gender : String) {
        // 如果属性名和参数名一样, 这个时候我们的属性名前面一定要加self
        // 我们要确保调用过构造方法以后, 该实例的每一个属性都有值
        self.name = name
        self.gender = gender
        self.age = age
    }
}
let 孙悟空 = Monkey(name: "悟空", age: 8, gender: "未知")
println((孙悟空.name,孙悟空.age,孙悟空.gender))

class 金刚 : Monkey {
    var hobby : String
    // 必须在调用父类的构造方法前, 先给子类的没有赋值的属性赋值
    init(name: String, age: Int, gender: String,hobby : String) {
    self.hobby = hobby
    super.init(name: name, age: age, gender: gender)
      
    }
}

let AC = 金刚 (name: "猴子`", age: 12, gender: "nan", hobby: "玩耍")

// 析构
class BadEgg {
    var shape : String!
    var color : String!
    // 析构方法类似于OC里面的dealloc 方法, 当实例的引用计数器为0的时候会走的方法
    deinit {
        println("egg --- dead")
    }
    
}
// 创建一个实例
var anEgg : BadEgg? = BadEgg()
var anotherEgg : BadEgg? = BadEgg()
anEgg = nil
anotherEgg = nil

// 自动引用计数机制
// 在Swift当中也是使用自动引用计数机制来管理内存(ARC)
// 引用技术机制仅仅应用于类的实例, 而结构体是值类型, 有不同的方式来存储和传递值, 结构体没有引用计数机制
// Swift直接使用ARC, 会在类的实例不再使用的时候走deinit(析构)方法
// Swift中的ARC机制: 这块空间如果只是一个指针指向, 那么我们把这个指针置为nil, 这块空间就会释放掉, 如果有多个指针指向, 那么我们需要把所有的真想这块空间的指针置为nil,这块空间才会释放