//继承1防止代码冗余2扩展功能
//1继承的定义
//2继承属性
//3子类不仅可以继承父类的属性,还可以继承在属性中的添加的属性监视器
class StepCounter {
    var totalSteps:Int=0 {  //千万前面不能加lazy
        willSet(newTotalSteps) {
            print("新的值:\(newTotalSteps)")
        }

        didSet(old) {
            if (totalSteps > old) {
                print("与原来比增减了\(totalSteps - old)个值")
            }

        }

    }
}

class stepCounter:StepCounter {

}

let counter=stepCounter()
counter.totalSteps=10
counter.totalSteps=100

//4下标脚本的继承
class Sorce {
    var english:Int=130
    var chinese:Int=50
    var math:Int=90

    subscript(index:Int)->Int {
        get {

            switch index {
            case 0:
                return english
            case 1:
                return chinese
            case 2:
                return math
            default:
                return 0
            }

        }

    }
}

class childSorce: Sorce{

}
let myscore=childSorce()
print(myscore[0])
print(myscore[1])

//5方法的继承

//6继承的特点 在swift 中1>只支持单继承,但一个父类可以多个子类,成树型结构2>不可以删除父类的属性


//7重写
//

class NewClass {

    var value:Int {// ~~1计算属性

    return 100
    }
    class var classValue:Int { //~~~2重写类型属性

     return 200
    }


}

class NewClass1: NewClass {
    override var value:Int {
    return 333
    }

    override class var classValue:Int {
    return 666
    }
}
let cls = NewClass1()
print(cls.value)
print(NewClass1.classValue)


// ~~~~3添加属性监视器


class Car {
    var speed:Double=0.00
}

class AutomicCar: Car {
    var gear = 1
    override var speed:Double {
        didSet {
        gear = Int(speed)
            print(gear)
        }
    }
}

let automic = AutomicCar()
automic.speed=34.00
automic.speed=6886.00

// ~~~~~4重写下标脚本
class childSorce111: Sorce{
    var value=0
    override subscript(index:Int)->Int {
    let count = index-value
        return count
    }
}
//~~~~~5重写方法

//重写的注意事项
//@1不可以省略override
//@方法相同才能重写,父类没有的,怎么重写


//8访问父类的成员
// 1>访问属性 super.属性名
// 2>访问下标脚本 suer[index]
// 3>访问方法 super.方法名(参数名)
// 4>访问类型属性



//9防止重写
// 将所有的属性,下标脚本,方法,类型属性 前面加一个 final (最终) 就可以达到防止子类重写了


//10类型检查
//类型检查是一种检查类实例的方式
// 1> 类型检查 is 
// 用法 实例 is 子类型
// @1,不能总是true
// @2 实例是特定的子类型

class ClassA {

}

class ClassA1:ClassA {
    var movie:String="hello"
}

class ClassA2:ClassA {
    var movie:String="hello"
}
class ClassA3:ClassA {
    var movie:String="hello"
}
class ClassA4:ClassA {
    var movie:String="hello"
}

class ClassB:ClassA {
    var movie:String="hello"
}
class ClassC {

}


let b = ClassB()
if b is ClassB { //总是truse
print("true")
}
else {
print("false")
}

let a = ClassA()
if a is ClassC {  //ClassC是基类
    print("true")
}
else {
    print("false")
}


// 2 as
//开发者希望程序在运行期间进行类型转换,这时就需要强制转化as 或者可选的类型检查符 as?
// 实例 as 类型

// >1强制类型的转换
let bb=ClassB()

let clsbb = bb as ClassB
print("clsbb.movie==\(clsbb.movie)")


//注意 @1相同类型的实例:在一个要检查类型的数组只可以存相同的类型
//
//let library = [ClassB(),ClassB(),ClassC()]
//
//for item in library {
//let cls = item as ClassB
// print(cls)
//}


// @2不可以在条件语句使用


// >2可选类型的转换 as?
// 当不确定转换是否可以成功的时候,可以使用as?


//AnyObject 和Any的检查
//对于一些类型不明确的类型,swift 提供了两种类型别名来检查,分别是AnyObject 和Any
//Any比AnyObject范围更广,除了方法类型


let library1 = [ClassA1(),ClassA2(),ClassA3(),ClassA4()]

for item in library1 {
let cls = item as  ClassA
    print(cls)
}

for item:AnyObject in library1 {
    let cls = item as! ClassA
    print(cls)
}