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("不一样")  

    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 {  

    // 有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 {  

        // newvalue 的类型和 totalprice一致  

            numbers = int(newvalue)  

            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 gender : string  

    // 构造方法, 通过构造方法我们要保证每一个没有值的属性被赋值  

    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,这块空间才会释放  

原文地址：http://blog.csdn.net/qq_31810357/article/details/50081507