Swift学习笔记-008 多态（疯狂swift讲义第二版）

1.多态的概念

指编译时和运行时的类型不一致，通常表现为声明时是父类，构造时是子类，导致多台的发生，如：
var parent :Parent=Son()
产生多态

2.多态性

class Base{
    func base(){
        print("父类的普通方法")
    }
    func test(){
        print("父类被覆盖的方法")
    }
}

class  Subclass: Base {
    override func test() {
        print("子类覆盖父类的方法")
    }
    func sub(){
        print("子类的普通方法")
    }

}

let bc:Base = Base()
bc.base()
bc.test()

let sc:Subclass=Subclass()
sc.test()
sc.base()
//以上均不存在多态的问题
let ploymo:Base = Subclass()//声明为父类，构造用子类构造，产生多态
ploymo.base()
ploymo.test()
//ploymo.sub()子类构造但ploymo是编译时申明，只有父类方法，没有子类方法即不存在sub()方法

打印结果
父类的普通方法
父类被覆盖的方法
子类覆盖父类的方法
父类的普通方法
父类的普通方法
子类覆盖父类的方法

3.使用is运算符检查类型

class Parent{
    init(name:String,age:Double) {
        self.name=name
        self.age=age
    }
    var name:String
    var age:Double
}

class Son:Parent{
    
    var grade:Int
    init(name:String,age:Double,grade:Int){
        self.grade=grade

        super.init(name: name, age: age)

    }
    
}

var s1=Son(name:"zhangsan", age:23,grade:23)
var p1=Parent(name: "lisi", age: 34)
print(s1 is Son)
print(p1 is Parent)

打印结果
true
true

4.使用as运算符向下转型

从上例

var s2:Son = p1 as! Son

可以编译，但在运行时报一个thread错误
Could not cast value of type ‘MyEX011.Parent’ (0x100585a38) to ‘MyEX011.Son’ (0x100585b08).

5.Any类型及AnyObject类型

class Parent{
    init(name:String,age:Double) {
        self.name=name
        self.age=age
    }
    var name:String
    var age:Double
}

class Son:Parent{
    
    var grade:Int
    init(name:String,age:Double,grade:Int){
        self.grade=grade

        super.init(name: name, age: age)

    }
    
}

var s1=Son(name:"zhangsan", age:23,grade:23)
var p1=Parent(name: "lisi", age: 34)

var  myvalue:Any
myvalue="hello"
print(myvalue)

var myarray:[Any]=[p1,s1]
for element in myarray {
    
    if let f = element as? Parent{
        print(f.name)

    }
}
var myarray2:[AnyObject]=[p1,s1]
for element in myarray2 {
    
    if let f = element as? Parent{
        print(f.name)
        
    }
}

打印结果

6.嵌套类型（类似java的内部类）

swift的枚举、结构体、类的内部都可以定义嵌套类型，被嵌套的类型也可以是枚举、结构体和类，也支持多级嵌套

class User{
    var holidays:[Weekday]
    var location:Point
    init(holidays:[Weekday],location:Point){
        self.holidays=holidays
        self.location=location
    }
    
    struct Point {
        var latitude:Double
        var longtitude:Double
        var posittion:Orientation
        enum Orientation{
            case up,left,Botton,Right
        }
    }
    enum Weekday {
        case Monday,Tuesday,Sunday
        struct Duration{
            var num:Double
            var unit:String
        }
    }
}

7.类扩展

为现有类添加新的方法，并且不需要创建子类，不需要访问原有类的源代码
扩展类可以扩展添加：
存储属性
实例计算属性和类计算属性
添加实例方法和类型方法
添加新的构造器，新构造器不影响原有构造器
添加下标
定义和使用性的嵌套类型
是一个已有类型符合一个或多个协议（接口）
格式：
[修饰符] extension 已有类型{
//添加新功能
}

添加遵守新协议
[修饰符] extension 已有类型：协议1，协议2…{
//实现新协议的功能
}

8.扩展属性（类存储属性，实例计算属性，类计算属性）、方法、构造器及嵌套类型

class User{
    var name:String
    var age:Int
    var _gender:String
    var _home:String
    init(name:String,age:Int,_gender:String,_home:String) {
        self.name=name
        self.age=age
        self._gender=_gender
        self._home=_home
    }
    var gender:String{
        get{
            return _gender
        }
        set{
            self._gender=newValue
        }
    }
    var _major:String?
   
    
}

extension User{
    static var course:[String:Any]=[:]//字典类型
    var home:String{
        get{
            return _home
        }
        set {
            _home=newValue
        }
        
    }
    var major:String?{
        get{
            if _major==nil {
                return nil
            }else{
                return _major
            }
        }
        set{
            _major=newValue
        }
    }
    func study(book:String,building:String)->String{
        print("we are read \(book) in \(building) ")
        return "good study"
    }
    
    class myexten{
        static func say(){
            print("let me tell you")
        }
        
        func dowork(work:String) -> String {
            print("let's do what i want to do")
            return ""
        }
    }
 
}

struct Mystruct {
    var name:String
    var age:Int
    init(name:String,age:Int){
        self.name=name
        self.age=age
    }
}

extension Mystruct{
    init(name:String){
        self.name="taiji"
        self.age=0
    }
}

var  u1 = User(name: "张三", age: 23,_gender:"female",_home:"beijing")
print(u1.gender)
u1.gender="man"
print("the person \(u1.name)--\(u1.age)--\(u1.gender)")
print(u1.home)
u1.home="jiangxi"
print(u1.home)

print("+++++++++++++++++++++")
print(u1.major)
u1.major="chinese"
print(u1.major!)
User.course=["country":"china","age":25]
print(User.course["country"]!)
u1.study(book: "android development", building: "main building")
print(u1.study(book: "", building: ""))

print("+++++++++++++++++++++")
var s1:Mystruct=Mystruct(name: "zhangsanfeng")
print("name is \(s1.name) and age is \(s1.age)")
s1.age=200;
print("name is \(s1.name) and age is \(s1.age)")

print("+++++++++++++++++++++")
User.myexten.say()

var ex=User.myexten()
ex.dowork(work: "hello moto")

打印结果
female
the person 张三–23–man
beijing
jiangxi
+++++++++++++++++++++
nil
chinese
china
we are read android development in main building
we are read in
good study
+++++++++++++++++++++
name is taiji and age is 0
name is taiji and age is 200
+++++++++++++++++++++
let me tell you
let’s do what i want to do