swif4基础学习（6）- 继承、协议等

import UIKit

var str = "Hello, playground"

//1下标 subscript

struct TestTable{
    
    subscript(index:Int)-> String{
        return "table"
    }
    
    subscript(key:String)->String{
        return "stringkey"
    }
}

var table = TestTable()
print(table[1])
print(table["ss"])

//2 继承
//override 重写父类方法,防止被重写  final var,final func, func class func
class Shap{
    
    func move(){
        print("父类方法")
    }
    
    final func className(){
        print("final修饰的方法不能被重载")
    }
}

class Circle : Shap{
    
    //重载父类方法
    override func move() {
        super.move()
        print("====")
    }
    
    
}

var circle = Circle()
circle.move()


//3.构造函数
var circleInit = Circle.init()

class RectShap{
    
    var name:String?
    var type:String // 存储型属性不能处于未知状态
    let num:Int
    
    init() {
        self.type = "默认值"  // type和num没有值的必须在init中初始化
        self.num = 1
        print("默认构造器")
    }

    
    init(type:String,num:Int) {
        self.type = type
        self.num = num   //构造函数中可以修改常量,但是不能在子类中使用
    }
    
    //便利构造器 convenience
    //便利构造器必须调用同类中的某个构造器
    convenience init(className:String) {
        self.init()
    }
}

var rect = RectShap.init(type:"小米",num: 2)
RectShap.init()

//4重写属性，只能重写get，set (let 不能声明计算属性)


//当指定了一个构造器，默认构造器init()就无法访问了(结构体，对象构造器不能访问)、
//可以显示的声明init()


//可失败的构造器 注意：不要在表明可失败构造器成功的情况下，使用关键字 return
class CanFalure{
    
    var name:String = "falure"
    
    init?(name:String) {
        
        if name.isEmpty {
            return nil
        }
        self.name = name
    }

    init() {
        
    }
}

class ThreeTest: CanFalure{
    
    override init(name: String) {  // 覆盖一个可失败的构造器
        super.init()
        if name.isEmpty {
            self.name = ""
        }else{
            self.name = name
        }
    }
    
}

class Ball {
    
    var name:String?
    
     //子类必须实现该构造器
    required init() {
        //如果子类继承的构造器能够满足必要构造器的需求，无需显示的在子类中提供必要的构造器实现
    }
    
   
     init(name:String) {
        
        
        self.name = name
    }
}

class FootBall:Ball{

    var type:String?

    required init() {
//        self.type = ""
        super.init()
    }

    override init(name: String) {
//        self.type = ""
        super.init()
    }

    deinit {//析构
        print("被释放了")
    }
    
 
}

//5扩展（oc中的分类类似）
//1.不能添加存储属性 ,可以添加计算属性和计算静态属性
//2. 可以添加新的便利构造器，不能添加新的指定构造器或者析构函数
//3. 不能覆盖原有方法
extension FootBall{
    
    convenience init(width:Float) {
        self.init()
        print("扩展")
    }
}

extension Double{
    var km: Double{
        return self / 1000
    }
    
}

var kmeter:Double = 1000.0
print(kmeter.km)


//6协议 protocol
protocol oneProtocol{
    
    func className()
    var fullName:String{get set} //属性，在声明后面加上{get set} 表示可读可写
    static func classMethod()
    
    mutating func changeProperty()
}

protocol twoProtocol{
}

class threeClass{
    var delegate:oneProtocol?
    //这个对象遵循多个协议
    var delegateTwo:(oneProtocol & twoProtocol)?
}

//可选协议
//@objc 来表示协议是可选
@objc protocol ThreeProtocol{
    
    @objc optional func select()
}

//前面写类，后面写协议
class ProtocolClass:threeClass,oneProtocol,twoProtocol{
    
    var fullName: String = "cc"
    
    func className() {
       let clazz = threeClass()
        clazz.delegate = self
        clazz.delegateTwo = self
    }
    
    static func classMethod() {
        
    }
 
    func changeProperty() {
        
    }
}

//可以转协议
let pr:ProtocolClass = ProtocolClass()
(pr as oneProtocol).className()


//7 泛型  T 或者U
//数组只能传Int
var arr:Array<Int> = Array<Int>()


//T表示任意类型
func swapVaule<T>(num1: inout T,num2: inout T){
    let temp = num1
    num1 = num2
    num2 = temp
}

struct Stack<T>{
    var items = [T]()
    
    mutating func push(item:T){
        items.append(item)
    }
}

var a = 1
var b = 4

swapVaule(num1:&a, num2:&b)
print("泛型：\(a) \(b)")

var stackInt = Stack<Int>()
stackInt.push(item: 1)


//8 运算符重载

struct Vector2D{
    var x = 1.0
    var y = 1.0
    
    //+ 重载 ，不是成员方法
    //参数表示 + 的左右
    static func + (left:Vector2D ,right: Vector2D)->Vector2D{
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }
    // ++ prefix
    static prefix func ++ (left: inout Vector2D){
        left.x = left.x + 1
        left.y = left.y + 1
    }
}

let v1 = Vector2D()
let v2 = Vector2D()
print(v1+v2)