Swif基本语法以及与OC比较三

     （未 经 博 主 同 意，不 得 转 载 ！）

 

------------------------华丽分割线-----------------------

 

 

//
//  main.swift
//  SwiftDemo3
//
//  Created by lanouhn on 15/11/11.
//  Copyright © 2015年 刘勇虎. All rights reserved.
//

import Foundation


//MARK:   ---属性---
//MARK:从功能分为两种
//1.存储属性： 2.计算属性
//MARK:从调用对象分两种：
//1.类属性    2.实例属性



//1.存储属性：类似于OC中的实例变量.用来接受我们设置的属性值
class Animal {
    //    <#properties and methods#>
    //    定义一个存储属性
    var animalName :String = "****"
    //    定义可选类型
    var isFly :Bool?
    //    lazyLoad，只有用的时候才会执行
    lazy var isSpeak :Bool = true ;// lazy var isSpeak  = true;  类型在赋值时可省略
    
}


//实例化一个对象
let animal = Animal()//相当于OC中默认init  ，也可以在类中重写init，调用时一般存在参数

//设置属性
animal.animalName = "跳跳虎"

animal.isFly = false

animal.isSpeak = true

//访问属性
//print("\(animal.animalName) 说话\(animal.isSpeak)  飞\(animal.isFly)")
//print("\(animal.animalName) 说话\(animal.isSpeak)  飞\(animal.isFly!)")

//MARK:2.计算属性：类似OC中的属性。（与实例变量最大区别：有set和get方法，直接访问方法 （KVC间接访问））

class Animals {
    //    存储属性
    var animalName :String = "拍拍*"
    //    计算属性
    var aName :String{
        get{
            
            print("get")
            
            return "喜欢\(animalName)的人都有一个不同的心"//如果直接写return，而没有写set方法即代表这个属性是只读属性，在后边调用中set方法会报红
        }set{
            print("set")
            animalName = newValue//newValue 就是我们在外边等号后想要赋上的值，
            //                    MARK:注意   定义属性最好不要使用newXXX容易和系统重名
            
        }
        
    }
}


//实例化调用
let animal2 = Animals()

animal2.animalName = "安妮*"
//调用计算属性的get方法
//print(animal2.aName)

//调用计算属性的set方法

//animal2.aName = "金克斯"



//MARK:--属性观察器--
class iPhone{
    //定义一个存储属性
    var iPhoneType = "6sPlus"
    var iPhoneColor = "RoseColor"
    //    属性观察器 ,观察属性变化
    var iPhonePrice :Int = 6000 {
        willSet{
            print("newValue = \(newValue)")
        }didSet{
            print("oldValue = \(oldValue)")
            
        }
        
    }
    
}


//实例化一个对象，调用set

let tempiPone = iPhone()

//tempiPone.iPhonePrice = 666//会调用willSet 和 didSet



//（1）类 的   类属性
class Animal3 {
    //  类属性只能是计算属性
    class var animal3Name : String {
        return "哆啦A梦"
    }
    
}

//调用类属性 （直接用类调用，类似OC中类方法）
//print(Animal3.animal3Name)
//Animal3.animal3Name = "九尾"//只有return，属性为只读，不管是var、还是let修饰


//（2）结构体的类属性  关键字 static
struct Animal4 {
    
    //    类属性 计算属性
    static var animal4Name :String {
        return "米老鼠---米奇"
    }
    
    
    //    类属性 存储属性
    static var animal4Friend = "唐老鸭 -- 唐纳德"
}

//MARK:注意-结构体的类属性不仅可以是计算属性，也可以是存储属性（类中的类属性不能是存储属性）

//调用属性，直接用结构体调用

//print(Animal4.animal4Name)

//Animal4.animal4Name = "唐老鸭"//只有return，属性为只读，不管是var、还是let修饰

//print(Animal4.animal4Friend)


//MARK:   ---属性 方法  函数 ---

// 1.类方法（+）
//2.实例方法（-）

class CityInfo {
    var cityName = ""
    var citytravelPoint = ""
    
    //    实例方法
    func printCityTravelPoint(){
        
        print("\(cityName)的景点有\(citytravelPoint)")
    }
    
    //    类方法
    class func printCityTravelPoint2(cityName:String,citytravelPoint:String) {
        print("\(cityName)的景点有\(citytravelPoint)")
    }
}


//调用

let beiJing = CityInfo()

beiJing.cityName = "北京"
beiJing.citytravelPoint = "天安门"
//用实例化的方法去调用实例方法
//beiJing.printCityTravelPoint()
//调用类方法（直接用类调用）
//CityInfo.printCityTravelPoint2("中关村", citytravelPoint: "Lenvo")

//注意事项
struct CityInfo2 {
    var cityName = "北京"
    var citytravelPoint = "故宫"
    //    实例方法
    mutating func printCityTravelPoint(){
        //MARK:注意-        结构体的方法中修改属性  ，需要在func 前用   mutating  标记   ，而类中的方法中修改属性，不需标记
        self.citytravelPoint = "天坛"
        
        print("北京有\(citytravelPoint)")//    print("北京有\(self.citytravelPoint)")
    }
    
    //
}


//调用:修改属性需要将实例变量设为var
var cityInfo2 = CityInfo2()


cityInfo2.citytravelPoint = "颐和园"

//cityInfo2.printCityTravelPoint()





//MARK:   ---类的继承---
//继承：可以使用父类属性并且实现、重写父类方法
//只有类可以，结构体是不能继承的
//如果没有明显的继承关系，那么就是继承于基类
/*MARK:注意事项---防止重写---
1.在属性或者方法名前加final关键字，那么子类能继承，不能重写
2.如果在类前加final这个类不能被继承
*/

class Zombie {
//    存储属性
    var blood :Int = 10;
//    计算属性
    
//   final var name:String {//MARK:-关键字final：保护该属性或方法使得子类无法重写该方法
     var name:String {
//    只读
        return "普通僵尸"
    }
//    实例方法
    func printZombie(){
    print("我是父类僵尸")
    }
}

//    定义僵尸的子类
class PailZombie :Zombie{
//增加属性
    var tool :String = "pail"
//    增加一个新方法
    func printTool(){//(1)
    print("我的工具是\(self.tool)")
    }
//    重写父类方法  关键字：override
    override func printZombie() {//(2)
     print("子类重写父类方法")
    }
//    重写父类的计算属性
    override var name:String{//(3)
    return "我是铁桶僵尸"
    }
}

//实例化一个铁桶僵尸
var pailZombie = PailZombie()
pailZombie.tool = "工具是铁通"
//print(pailZombie.tool)

//设置和访问父类属性
pailZombie.blood = 30

//print("pailZonmbie的血量：\(pailZombie.blood) 名称：\(pailZombie.name)")

//使用自身独有方法
//pailZombie.printTool()//(1)
//使用父类方法
//pailZombie.printZombie()//(2)

//调用重写后的父类只读计算属性
//print(pailZombie.name)//(3)


//MARK:    ---构造方法（构造函数）---
class Food {
    var foodName:String
    var foodType:String
    var foodPrice:Double
//    定制构造方法  set 方法
    init(foodName:String , foodType:String,foodPrice:Double){
//    完成属性赋值
        self.foodName = foodName
        self.foodType = foodType
        self.foodPrice = foodPrice
    }
}

//实例化一个food对象
let food = Food(foodName: "苹果", foodType: "水果", foodPrice: 2.0)

//print("foodName:\(food.foodName)")




//子类要继承父类
class Apple:Food{
//苹果的类型,新增属性
    var appleType:String
//    重写父类构造方法
    init(foodName: String, foodType: String, foodPrice: Double ,appleType:String) {
        
        //   完成属性赋值    首先给自己独有属性赋值，
        self.appleType = appleType
//    直接调用父类构造方法    然后调用父类构造方法
        super.init(foodName: foodName, foodType: foodType, foodPrice: foodPrice)
        
    }
}

//实例化一个对象（实例化一个苹果）
let apple = Apple(foodName: "苹果", foodType:"水果" , foodPrice: 6.6, appleType: "红粉佳人")

print(apple.foodName)


/*总结一下
1.构造方法的安全性：
（1）构造方法完成后，创建出来的实例对象的属性必须有值
（2）当我们继承了父类的构造方法后，需要先对自身独有的属性赋值，然后在调用父类的构造方法


*/


//MARK:   ---内存---
//引用计数
class runSun {
//属性
    var personName:String
//    构造方法
    init(personName:String){
    self.personName = personName
        print("\(personName)变身成功")
    }
    
//    追逐太阳
    func runSunAction (){
    print("\(personName)正在追逐太阳!!!")
    }
//MARK:    析构方法（类似OC中的dealloc）
    deinit {
        print("\(self.personName)扑街！！！")
    }
}


//创建一个追太阳的人，引用计数 + 1 （0 -> 1）
var runSunPerson :runSun? = runSun(personName: "夸父")//? 使可选，以便置为nil

//再创建一个  引用计数 + 1 （1 -> 2）    //MARK:注意 ： --在原基础上，虚拟内存地址引用计数 +1
var runPerson :runSun? = runSunPerson


//调用方法
runSunPerson!.runSunAction()//因为是可选类型需要强制转换

//释放 ：引用计数 - 1 (2->1) ,内存没有释放
runSunPerson = nil //MARK:注意 ： --在原基础上，虚拟内存地址引用计数 -1
//再次调用
runPerson!.runSunAction()
//释放 ：引用计数 - 1 (1->0) ,内存释放
runPerson = nil


//MARK:   --- 总结 ---
/*野指针：指针指向无效空间   内存泄露：空间没有被释放或者没有被及时释放
1.swift使用的是引用计数管理机制。当这个对象不再使用的时候，就会执行deinit方法，销毁该空间
2.swift中当有一个指针指向该空间时，该空间就不会被释放。只有没有指针指向该空间时，这个空间才会被释放（引用计数为0）
*/


//MARK:---循环引用 weak可以破坏引用循环---
//弱引用：使指向引用计数不增加，关键字：weak    如果不写，默认strong，strong是强引用，会使得引用计数 + 1 ，weak是弱引用，引用计数不会增加

class Person {
    var room :Room?
    var personName:String


//    构造方法
    init(personName:String){
    
    self.personName = personName
    }
    
    
    deinit{
    print("该用户扑街 ！！")
    }
    
}

class Room {
//    属性
    var roomNumber :Int
    
//    因为有得房间可以没有人，所以用可选类型
  weak var person:Person?//不赋初值、不是可选类型或者没写初始化方法（init），会报错       弱引用：使指向引用计数不增加，关键字：weak    如果不写，默认strong，strong是强引用，会使得引用计数 + 1 ，weak是弱引用，引用计数不会增加
    deinit{
        print("房子被销毁 ！！")
    }
    
    init(roomNumber:Int){
    self.roomNumber = roomNumber
    }
}

//实例化对象
var personItem :Person? = Person(personName: "王大锤")

var roomItem :Room? = Room(roomNumber: 250)


//给大锤开个房

personItem!.room = roomItem

//给房间设置主人
roomItem!.person = personItem



personItem = nil
roomItem = nil