Swift-继承、构造器、类型转换(嵌套)、类扩展、泛型、协议

一、 继承

//类才有继承属性，结构体和枚举是没有的

//override 重写父类属性/方法/下标

//父类 如果父类不想被继承，可以加上Final 关键字
class Transport {
    var scope = ""
    //final 子类无法重写此方法
    final func run() {
        
    }
    func move() {
        print("交通工具在移动")
    }
}
class Car: Transport {
    override func move() {
        print("汽车在移动")//获取到交通工具类的属性 并重写父类的方法
    }
    //会报错
    //override func run() {
    //}
}

调用：

let myCar = Car()
myCar.scope = "陆地" //调用父类的属性
myCar.move()

二、 构造器(析构)

一旦子类中创建了自己的指定构造器后,将不能再使用父类的构造器 , 并且子类中的指定构造器的声明中必须要调用父类的某个构造器

struct Example {
    var str = "Hello"
//    init(str:String) {//系统会自动生成一个构造器 并且这个构造器是隐藏的
//    }
}
class Transport {
    var scope:String = ""
    init () {}//无参数的指定构造器
    init(scope:String) {
        //可以在构造器中 重置默认值
        self.scope = scope//带一个参数的构造器
    }
}
class Car: Transport {
    //子类不实现自己的指定构造器
    //一旦子类中创建了自己的指定构造器后,将不能再使用父类的构造器 , 并且子类中的指定构造器的声明中必须要调用父类的某个构造器
    var wheel = "大白"
   init(scope: String,wheel:String) {
        super.init()
        self.wheel = wheel
        self.scope = scope
    }
    
}
var showTransport = Transport.init(scope: "陆地") //用构造器初始化类
print(showTransport.scope) //陆地
// var myCar = Car()//使用父类的无参构造器
// var myNewCar = Car.init(scope: "天空")//调用父类的另一个构造器
var myCar = Car(scope: "陆地", wheel: "米其林")
 print("(myCar.wheel)(myCar.scope)")
let image = UIImage(named: "test")

 

//可以初始化失败

三、 类型转换、类型嵌套

//类型转换

let d:Double = 12.3
let i = Int(d)
print(i) //结果为：12
let dd = d as?Int
print(dd) //结果为：nil

//类型嵌套

struct SchoolUniform {
    enum Style:String {
        case Sport = "运动服" ,Suit = "中山装"
    }
    enum Grade:String {
        case One = "一年级",two = "二年级" ,three = "三年级"
    }
    let myStyle:Style
    let myGrade:Grade
    func customize() -> Void {
        print("我的年级:(myGrade)==我的款:(myStyle)")
    }
}
//调用嵌套类型
let uniform = SchoolUniform(myStyle: .Suit, myGrade: .three)//使用默认的构造器
uniform.customize()//输出结果：我的年级:three==我的款:Suit

四、 类扩展

 

//扩展

//添加构造方法1.只能添加便利构造方法,不能添加指定构造方法2.只有类才有便利构造与指定构造方法

①类型扩展

//类型扩展
extension String {
    func sayHello() {
        print("SayHello")
    }
}
extension Int {
    var squard: Int {
        return self * self
    }
    
}
var hello = "Hi~"
 hello.sayHello() // 输出结果：SayHello
 var newInt = 30
print(newInt.squard) //输出结果：900
999.squard //swift可以自动推导

②类的扩展 

//类的扩展
class Lisa {
    var lisa = "lisa is an angle"
}
extension Lisa {
    func describleYourSelf() -> String {
        return "My name is Lisa and i always say (lisa) ~"
    }
}
var whoIsLisa = Lisa()
print(whoIsLisa.lisa) //lisa is an angle
var whoIsLisa2 = Lisa()
print(whoIsLisa2.describleYourSelf())//My name is Lisa and i always say lisa is an angle ~

五、泛型<T>

    var stringArr = ["hi","hello","bye"]
    var intArr = [1,2,3]
    var doubleArr = [1.1,2.2,3.3]
    
    func prinStringArr(a:[String]) {
        for s in a {
            print(s)
        }
    }
    func prinIntArr(a:[String]) {
        for i in a {
            print(i)
        }
    }
    //泛型的方法 T 代表任意类型
    func printElementFromArr<T>(a:[T]) {
        for element in a {
            print(element)
        }
    }
    func doNothing<T>(x:T) -> T{
        return x
    }
        printElementFromArr(a: stringArr)
        printElementFromArr(a: intArr)
        printElementFromArr(a: doubleArr)
        /*
         输出结果
         hi
         hello
         bye
         1
         2
         3
         1.1
         2.2
         3.3
         */
        doNothing(x: 123)
        doNothing(x: "123")
        doNothing(x: false)

//泛型结构体：mutating 突变

struct GenericArr<T> {
    var items = [T]() //创建数组
    mutating func push(item:T) {//mutating 突变
        items.append(item)
    }
}
let myPhone = ["iPhon5","iPhon6","iPhon7"]
var LisaArr = GenericArr(items: myPhone)
LisaArr.push(item: "iPhone7 plus")
print(LisaArr.items)//输出结果["iPhon5", "iPhon6", "iPhon7", "iPhone7 plus"]

 六、协议

①协议简介：

 

//声明一个协议
protocol People {
    var name:String {get set}
    var race:String {get set}
    func sayHi()
    
}
//一旦遵循了协议就要实现里面的方法和变量
struct Lisa:People{
    var name: String = "Lisa"
    var race: String = "Asian"
    func sayHi() {
        print("Hi~ I am (name) ~")
    }
}
class Lili: People {
    var name: String = "LiLi"
    var race: String = "Asian"
    func sayHi() {
        print("Hi~ I am (name) ~")
    }
}

②协议的继承：

 

//协议的继承
protocol superman :People {
    var canFly:Bool {get set}
    func punch()
}
//一个继承子协议，那么它不仅要实现父级协议的方法和属性还要实现子协议里面的方法和属性
struct AngelLisa:superman {
    var name: String = "Lisa"
    var race: String = "Asian"
    func sayHi() {
        print("Hi~ I am (name) ~")
    }
    var canFly: Bool = true
    func punch() {
        print("哈哈哈")
    }
}
//协议 属性 get 和 set 的区别
protocol Breathable {
    var isBreathing:Bool {get set}
    var isLiving:Bool {get}
}
struct human:Breathable {
//    var isBreathing: Bool = true
//    var isLiving: Bool = true
    var isBreathing: Bool {
        get {return true}
        set {}
    }
    var isLiving: Bool {
        get {return true}
//        set {} //此方法可以不写
    }
}

 

③协议的扩展：

//如果类的扩展中实现了这个协议的方法，那么其他遵循这个协议的类可以不要实现这个协议的方法，也不会报错
protocol iOSGenius {
    func point()
}
struct iOSLisa:iOSGenius {
    func point() {
        print("Lisa iOS")
    }
}
struct iOSDev:iOSGenius {
    
}
extension iOSGenius {
    func point() {
        print("Lisa is an iOS Engineer !")
    }
}

let dev = iOSDev()
dev.point()