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"]

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

猜你喜欢