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

最新推荐文章于 2018-03-16 15:28:47 发布
泥孩儿0107
最新推荐文章于 2018-03-16 15:28:47 发布
阅读量403
点赞数
分类专栏： iOS中 Swift初级入门学习(三) 文章标签： iOS中 Swift初级入门学习三
iOS中 Swift初级入门学习(三) 专栏收录该内容
0 篇文章 0 订阅
订阅专栏
iOS中 Swift初级入门学习(三)

[plain]view plaincopy 
    
 //  
 //  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,这块空间才会释放 