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

//父类 如果父类不想被继承，可以加上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

//类型扩展
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 "@H_914_40@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())//@H_500_32@my name is Lisa and i always say lisa is an angle ~

    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)

struct GenericArr<T> {
    var items = [T]() //创建数组
    mutaTing func push(item:T) {//@H_500_32@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"]