Swift与Objective-C区别简析(二)

函数重载和另一种 for 循环

///重载: 函数名相同, 函数类型不同(参数/返回值不同), 构成重载, 调用的时候,
    根据参数确定调用哪个函数
func helloworld(a:Int)->Int{
    return a * 100
}
print(helloworld(5))

func helloworld(a:NSString)->Int{
    return 100
}
print(helloworld("123"))


//区间, 0...10 = [0 10]    0..<10 = [0 10)
for i  in 0..<10{
    print("i = \(i)")
}

枚举

//OC中的枚举值 是int类型, 也就是 0,1,2,3.. swift中的枚举值, 不再是int类型了, 就是枚举值
enum Direction : String{
    case East = "东"
    case west = "西"
    case south = "南"
    case North = "北"
}

var dir = Direction.East;
print(dir)
//swift中的快捷语法, 如果给一个变量赋值过一次枚举值, 下次进行赋值就直接使用 . 语法进行赋值
dir = .south
print(dir)


//枚举值的原始值
enum Season : Int {
    case Spring = 100
    case Summer
    case Autumn
    case Winter
}
var se = Season.Spring

//rawValue, 原始值
print(se.rawValue)

//通过枚举值的原始值找到枚举值
let sea = Season(rawValue: 100)
print(sea)


//隐士解析
if let s = sea {
    print("s = \(s)")
} else {
    print("无法找到枚举值")
}

类和结构体

//A = B

值类型 : 赋值完成以后, B修改, A 不变. 枚举值和结构体就是值类型, 类似copy 的过程

引用类型 : 赋值完成以后, B 修改, A随着B修改. 类就是引用类型, 类似 retain 的过程

结构体值类型

struct Person{
    var height = 1.8
    var weight = 75
    var age = 25
}
//实例化结构体: ()是结构体的一个初始化方法
var p = Person()
p.weight = 90
print("他的体重是 \(p.weight) Kg")

//逐一构造器：swift 中 构造 = alloc..init ，析构 = 释放 = dealloc
var p1 = Person(height: 1.6, weight: 60, age: 18)
print("她的身高为\(p1.height), 体重为\(p1.weight), 年龄为\(p1.age)")


var p2 = p1
p1.height = 180
print("p2的.height= \(p2.height)")  //1.6

类引用类型

class Student{
    var num = 78945
    var name = "路飞"
    var goodF = "东海"
}
//系统没有给类自动添加逐一构造器
var p = Student()
p.goodF = "北海"
print(p.goodF)

var p1 = p
p.goodF = "西海"
print("p1的.height= \(p1.goodF)")  //西海。跟struct不一样




//属性
//类名属性: static 修饰，（用类名调用）
//存储属性: 用来 存值 和 取值
//计算属性: 计算属性的值。 通过get方法, 用于获取其他元素。 set方法一般用来处理事务。
    只写get , 这个属性是只读的; 不能只写set
class Animal{

    //类名属性：是否有腿 
    static var hasLeg = true

    //存储属性
    var type = "Elephant"
    var weight = 1000

    //计算属性
    var leg  : Int{
        get{ //get 方法
            if type == "Elephant"{
                return 4
            } else if type == "人" {
                return 2
            } else {
                return 3
            }
        }
        
        //set 方法需要一个 新值  参数
        set(newValue){
            if(newValue >= 4){
                print("不是人")
            } else{
                print("有可能是人")
            }

        }
    }
}

var per = Animal()
per.type = "人"
print("人的腿的个数是\(per.leg)")

per.leg = 10
print("人的腿的个数是\(per.leg)")

print("人是否有腿: \(Animal.hasLeg)")

例子：计算中心点（结构体）

struct Rect {

    var x = 100.0
    var y = 100.0
    var width = 100.0
    var height = 100.0

    //属性在类内部使用的时候, 可以省略self.
        只有设计到参数名字和属性相同的时候, 建议加上 self.以示区分
    var centerX :Double {
        get {
            return x + width / 2
        }
        set{
            width = (newValue - x) * 2
        }

        }
        var centerY:Double {
        get {
            return y + height / 2
        }
        set {
            height = (newValue - y)*2
        }
    }
}

var rect  = Rect()
print("centerX = \(rect.centerX)")

属性观察器

//属性观察器
class Plant{
    //类型
    var type = "绿色植物"{
        willSet(newType){
            print("新值为 = \(newType), 当前值 = \(type)")
        }didSet(oldType){
            print("旧值 = \(oldType)")
        }
    }
    //是否开花
    var hasFlower : Bool = false {
        willSet{
            print("新值为\(newValue), 当前值为\(hasFlower)")
        } didSet {
            print("旧值为\(oldValue)")
        }
    }
}

var appleTree = Plant();
appleTree.type = "苹果树"
appleTree.hasFlower = true;

方法

//结构体方法
struct Apple {
    var brand = "apple"
    var price = 14000
    func action(name:String){
        print("\(name)抽奖中了一个\(brand)的, 价值¥\(price)")
    }
}
var app = Apple()
app.action("王❀")

//方法
class Computer {
    var brand = "大船"
    var price = 6888
    func des(name:String){
        print("\(name)造了\(brand), 花了￥\(price)")
    }
}

var compu = Computer()
compu.des("路飞")


//类方法
class Car {
    static func speed(){
        print("速度是71迈")
    }
}
Car.speed()

构造方法

//除了可选类型, 在构造的过程中, 必须给各个各个属性赋初始值
class Hero{
    var age : Int?
    var name = "孙悟空"
    var equipment = "金箍棒"
    var saddleHorse :String
    
    init(){
        saddleHorse = "筋斗云"
    }
    
    //自定义一个构造器
    init(name:String, equipment:String, saddleHorse:String){
        self.name = name
        self.equipment = equipment
        self.saddleHorse = saddleHorse;
    }
}

let 孙悟空 = Hero()
print("孙悟空的坐骑是\(孙悟空.saddleHorse)")

let 大禹 = Hero(name: "大禹", equipment: 孙悟空.equipment, saddleHorse: "11路公交车")
print(大禹.name, 大禹.equipment, 大禹.saddleHorse)

便利构造器：必须调用自身的指定的构造器

//定义属性以及构造器的方法
class Film {
    var name = "大闹天空"
    var type = "myth"
    var time = "12.31"
    var price = 20
    //自定义构造器
    init(name:String, type:String, time:String, price:Int){
        self.name = name
        self.type = type
        self.time = time
        self.price = price
    }

    func description(){
        print("电影名: \(self.name), 类型: \(self.type),
            上映时间: \(self.time), 票价: \(self.price)")
    }

    //便利构造器：和 OC 的便利构造器不是一类, OC的是类方法
    //convenience: 在构造器方法前添加convenience代表当前的构造器是便利构造器
    convenience init(){
        self.init(name:"恶棍", type:"傲笑", time:"12.28", price:30)
    }
}


let film = Film(name: "挪吒脑海", type: "神话", time: "12.30", price: 11)
film.description()

let 恶棍天使 = Film()
恶棍天使.description()

继承与重写

//定义一个父类
class Teacher {
    var academic = "教授"
    var offer = 8888
    var num :Int{
        get{
            return 100
        } set{

        }
    }

    func teacher (){
        print("某\(academic)的薪资是\(offer)")
    }
    
    //final 方法禁止被重写
    final func study(bookName:String){
        print("某\(academic), 刻苦钻研\(bookName)")
    }
}

//定义一个子类 ： 讲师
class Lecturer : Teacher{
    var industry = "iOS"
    //override, 重写父类的方法
    override func teacher() {
        super.teacher()
        print("从事行业是教授\(industry)")
    }

}

let lec = Lecturer()
lec.academic = "两院院士"
lec.offer = 10000
lec.teacher()
lec.study("论持久战")

//重写属性：把存储属性重写为计算属性，不能把计算属性改为存储属性
class ChildrenTeacher:Teacher {
    override var offer:Int{
        get{
            return 9999
        } set {

        }
    }
}
let child = ChildrenTeacher()
child.teacher()

写个小例子吧

class Perosn {
    var name :String
    var age : Int
    var gender : Bool

    init(){
        age = 18
        name = "路飞"
        gender = true
    }

    //指定构造器
    init(name:String, age:Int, gender:Bool){
        self.name = name
        self.age = age
        self.gender = gender
    }

    //便利构造器
    convenience init(name:String){
        self.init()
        self.name = name
    }

    //实例方法
    func description(){
        print("名字是\(name), 年龄是\(age), 性别是\(gender)")
    }
    
    //类方法
    static func helloWorld(){
        print("hello, World!")
    }

    //OC的便利构造器, swift版本
    //这只是一个类方法, 完成创建对象的功能，其实这不是构造器
    static func person(name:String, age:Int, gender: Bool)->(Perosn){
        
        return Perosn(name: name, age: age, gender: gender)
    }

}

//初始化
let p1 = Perosn()
let p2 = Perosn(name: "xxx")
let p3 = Perosn(name: "李阳", age: 20, gender: true)

//调用-号方法（对象方法）
p1.description()
p2.description()
p3.description()

//调用+号方法（类方法）
Perosn.helloWorld()

再一个

class Student {
    var score:Float?
    var id:Int

    init(){
        self.id = 12345
    }
}

//继承于Student
class Pupil : Student{
    var games:String
    //指定构造器：自动调用父类的 init() 方法
    init(games:String) {
        //给自身的属性赋值
        self.games = games

    }
}

let pu = Pupil(games: "LOL")
print(pu.games, pu.id)


//继承于 Pupil
class Kindergarten:Pupil{
    var fight:String

    init(fight:String) {
        self.fight = fight
        super.init(games: "CF")
    }

    //deinit, 析构, 相当于OC中的dealloc
    deinit{
        //移除观察值
        //取消代理, 地图应用
    }

}


let kind = Kindergarten(fight: "打架")
print(kind.id, kind.fight, kind.games)

//下划线是为了区分数字位数, 没有实际意义
kind.score = 59_9_1  
if let s = kind.score
print("分数是\(s)")

iOS (16)

函数重载 和 另一种 for 循环

枚举

类 和 结构体

结构体 值类型

类 引用类型

例子： 计算中心点（结构体）

属性观察器

方法

构造方法

便利构造器：必须调用自身的指定的构造器

继承 与 重写

写个小例子吧

再一个

函数重载和另一种 for 循环

类和结构体

结构体值类型

类引用类型

例子：计算中心点（结构体）

继承与重写