iOS中 Swift初级入门学习(三)-阿里云开发者社区

版权声明：本文为博主原创文章，未经博主允许不得转载。

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

每日更新关注:http://weibo.com/hanjunqiang 新浪微博

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

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景