Swift复习资料【三】

四十、 Swift从入门到放弃实例【二】

Swift从入门到放弃实例【二】

四十一、Any 和AnyObject的区别

在这里插入代码片//Any 和AnyObject的区别
//Any 可以表示任何类型包括类类型、结构体类型
//AnyObject  只能表示类类型
class Person{
    var name: String
    init(name: String) {
        self.name = name
    }
}
struct Data {
    var data:String
    init(data :String) {
        self.data = data
    }
}
var a:Any = 1
print(type(of: a))
var b:Any = true
print(type(of: b))
var c:Any = "Hello"
print(type(of: c))
var d:Any = Person(name: "小张")
print(type(of: d))
var e:Any = Data(data: "小张")
print(type(of: e))
print("------------")
var f:AnyObject = Person(name: "小张")
print(type(of: f))
//var g:AnyObject = Data(data: "小张") //报错了！！，因为AnyObject 不嫩表示结构体类型
//print(type(of: g))

//var g:AnyObject = "asd"//报错了！！，因为AnyObject 不嫩表示字符串类型

四十二、类的继承

class Person{
    private var name:String
    private var age:Int
    init(name:String, age:Int) {
        self.name = name
        self.age = age
    }
    public func getName() ->String{
        return self.name
    }
    public func getAge() -> Int{
        return self.age
    }
    public func setName(param:String){
        self.name = param
    }
    public func setAge(param:Int){
        self.age = param
    }
}

class Student: Person{
    func play() -> String {
        return "子类自己的方法"
    }
}
var per = Person(name: "小张", age: 10)
print(per.getAge())
print(per.getName())
print("--------------")
var stu = Student(name: "学生", age: 2)
print(stu.getName())
print(stu.getAge())
print(stu.play())

四十三、重载

//重载
class Person{
    func play(param: String)  {
        print("Person Play Func ... String")
    }
    func play(param: Int) {
        print("Parson Play Func ... Int")
    }
    func play(params: Int) {
        print("Parson Play Func ... params")
    }
}
var person = Person()
person.play(param: "hello")
person.play(param: 1)
person.play(params: 1)

四十四、重写

class Person{ //不想被继承 加上 final
     var name:String = ""
    private var age:Int = 0
    init(name:String ,age:Int) {
        self.age = age
        self.name = name
    }
    public func setName(name:String){
        self.name = name
    }
    public func setAge(age: Int){
        self.age = age
    }
    public func getAge() ->Int{
        return self.age
    }
    public final func getName() ->String{ //无法重写此方法
        return self.name
    }
}
class Student: Person {
    override var name: String{
        set{
            super.name = super.name  + "!!" + newValue
        }
        get{
            return super.name
        }
    }
    override init(name: String, age: Int) {
        super.init(name: name, age: age)
        self.name = name
    }
    override func getAge() -> Int {
        print("重写了getAge方法")
        return super.getAge()
    }
    override func setAge(age: Int) {
        print("重写setAge方法 ，年轻10岁")
        super.setAge(age: age - 10)
    }
}

var per = Person(name: "小敏", age: 100)
print(per.getName())
print(per.getAge())
var stu = Student(name: "小滨", age: 20)
print(stu.name)
stu.setAge(age: 100)
print(stu.getAge())

四十五、类型判断处理、对象相等性判断

//类型判断
class A{
    
}
class B: A {
    var name:String
    init(name:String) {
        self.name = name
    }
    func printName() {
        print("this is B name = " + self.name)
    }
}
class C: A {
    var name:String
    init(name:String) {
        self.name = name
    }
    func printName() {
        print("this is C name = " + self.name)
    }
}
func getObject(param: Int) -> A {
    if param > 10 {
        return B(name: "小B")
    }else{
        return C(name: "小C")
    }
  
}
var t1 = A()
var t2 = A()
print(t2 === t1) //false
var t3 = t2
print(t2 === t3) //true
print("-----------")
var obj = getObject(param: 5) //var obj:A = B(name:"")
print(type(of: obj))
if(obj is B){
    let p = obj as! B
    p.printName()
}else if (obj is C){
    let p = obj as! C
    p.printName()
}
print("--------")
//可选项绑定
if let t1 = obj as? B{
    t1.printName()
}else if let t2 = obj as? C{
    t2.printName()
}

四十六、extension

class A{
    
}
extension A{
    var name: String{
//        get{
//            return "Hello"
//        }
        return "Hello" //简写、等同上面
    }
    func print() {
        Swift.print("A extension Print")
    }
    static func print() {
        Swift.print("A extension Print")
    }
}
extension String{
    func toString() -> String {
        return "长度:" + String(self.count)
    }
}

var a = A()
a.print()
A.print()
print(a.name)
var s = "Hello"
print(s.toString())

四十七、泛型

func toString<T>(param: T) -> T{
    return param
}

print(toString(param: "Hello"))
print(toString(param: 1))
print(toString(param: ["Hello","World"]))
var array:Array<Int> = [1,2,3,41,2]

四十八、协议protocol

//协议 protocol  ->intface
class TestClass{
    
}
protocol protocol1 {
    var value:String{set get}
    func play1() -> String
}
protocol protocol2 {
    var value2:String{get} //必须是变量。具体是不是变量由实现类决定
    func play2() -> String
}
class Data: TestClass,protocol1,protocol2 {
    var value: String
    var value2: String{
        return "Value2"
    }
    init(value:String) {
        self.value = value
    }
    func play1() -> String{
        return "实现play1" + value
    }
    func play2() -> String{
        return "实现play2" + value2
    }
}
var data = Data(value: "Hello")
print(data.play1())
print(data.play2())

四十九、lazy 延迟加载

//延迟属性 lazy
class Data{
    init() {
        print("data init")
    }
    func play() ->  Void{
        print("data play 方法")
    }
}
class Test {
   lazy var data:Data = Data()
    init() {
        print("Test Init")
    }
}
var test = Test()
print("-----")
test.data.play()
/*
 不加延迟加载的输出:
     data init
     Test Init
 加延迟加载的输出:
    Test Init
 */

五十、普通初始化器、可失败初始化器

//普通初始化器、可失败初始化器
class Test{
    var name:String
    //普通初始化器
    init(name:String) {
        self.name = name
    }
    
}
var t = Test(name: "Hello")
print(t.name)
print("---------")
class Test2{
    var name:String
    //可失败初始化器
    init?(name:String) {
        if name == "unknow" {
            return nil
        }else{
            self.name = name
        }
    }
}
var t1:Test2? = Test2(name: "unknow")
if t1 == nil{
    print("初始化失败")
}else{
    print(t1!.name)
}
print("----------")
if let p = t1{
    print(p.name)
}else{
    print("初始化失败2")
}

五十一、必要初始化器、 结构体成员初始化器、闭包设置初始值

//必要初始化器
class Test{
    var name:String
    required init(name:String) {
        self.name = name
    }
}
class T: Test {
    required init(name: String) {
        super.init(name: name)
    }
}
var t = T(name: "hello")
print(t.name)

struct A{
    var name: String
    var age: Int
    //默认系统自动生成。-> 结构体成员初始化器
//    init(name:String, age:Int) {
//        self.name = name
//        self.age = age
//    }
}
var a = A(name: "", age: 1)
print(a.age)
class B{
    //闭包设置初始值
    var name:String = {return "IOS"}()
    var score:Int = {
        var a = 10
        var b = 10
        return a + b
    }()
    var age:Int = 100
}

五十二、ARC

//必要初始化器
class Test{
    var name:String
     init(name:String) {
        self.name = name
    }
    deinit {
        print("对象被销毁了!" + name)
    }
}
var t1:Test? = Test(name: "Hello")
var t2:Test? = t1
var t3:Test?  = t2

print(t1!.name)

print(t2!.name)
print(t3!.name)
print("--------")
t1 = nil
t2 = nil
t3 = nil
print("--------")
var a:Test? = Test(name: "123")
a = nil
print("--------")

五十三、循环引用

//循环强引用
class TestA{
    var name:String
    weak var ref:TestB? = nil
    init(name:String) {
        self.name = name
    }
    deinit {
        print("TestA 实例被释放 - " + self.name)
    }
}
class TestB{
    var name:String
   weak var ref:TestA? = nil
    weak var ref2:TestA? = nil
    init(name:String) {
        self.name = name
    }
    deinit {
        print("TestB 实例被释放 - " + self.name)
    }
}
var testA:TestA? = TestA(name: "A")
print(testA!.name)

print("----------")
var testB:TestB? = TestB(name: "B")
print(testB!.name)
print("---循环引用了-------")
testB?.ref = testA
testB?.ref2 = testA
testA?.ref = testB
testA = nil
testB = nil

五十四、无主引用unowned

//无主引用 unowned
//使用unowned时 永远不会为nil 使用weak时 则是可选值
class TestA{
    var name:String
    var ref:TestB? = nil
    init(name:String) {
        self.name = name
    }
    deinit {
        print("TestA 实例被释放 - " + self.name)
    }
}
class TestB{
    var name:String
    unowned var ref:TestA// 无主引用，不会阻止释放对象。与弱应用不同的是 他不会是nil
    init(name:String,ref:TestA) {
        self.name = name
        self.ref = ref
    }
    deinit {
        print("TestB 实例被释放 - " + self.name)
    }
}
var testA:TestA? = TestA(name: "A")
testA?.ref = TestB(name: "B", ref: testA!)

print("----------")
//print(testA!.ref)
//testA?.ref = nil
//print(testA!.ref) //这里销毁TestB
testA = nil
//testA? = nil
//print(testA!.ref) //报错 上一部为nil了

五十五、闭包循环引用

//闭包循环引用，定义捕获列表
class TestA{
    var name:String
    
    lazy var data:() -> Void = {[unowned self]() -> Void in //weak self 
        //闭包持有引用
        print(self.name)
        
    }
    
    init(name:String) {
        self.name = name
    }
    deinit {
        print("TestA 实例被释放 - " + self.name)
    }
}
var t:TestA? = TestA(name: "hello")
t?.data()
t = nil

五十六、可选链展开

class Data{
    var name:String
    func play() {
        print(self.name)
    }
    init(name:String) {
        self.name = name
    }
    deinit {
        print("Data 被销毁了")
    }
}
class Test {
    var name:String
    var data:Data? = nil
    
    init(name:String,data:Data) {
        self.data = data
        self.name = name
    }
    deinit {
        print("Test 被销毁了")
    }
}
var test:Test? = Test(name: "hello", data: Data(name: "world"))
(test!.data)?.play()

五十七、尾随闭包

import UIKit
//尾随闭包
func play(param:String, param2:(String) -> Void){
    param2(param + "SWift")
}
play(param: " Hello1 ", param2: {(data:String) -> Void in
    print(data)
})
play(param: " Hello2 ", param2: {(data) -> Void in
    print(data)
})
play(param: " Hello3 ", param2: {data in
    print(data)
})
//尾随闭包
play(param: " Hello4 ") { (data) in
    print(data)
}
func play2(param:(String)->String) {
    let value = param("swift")
    print("返回值 = " + value)
}
play2(param: {(data:String) -> String in
    return data + "IOS "
})
//尾随闭包
play2 { (data) -> String in
    return data + "IOS "
}

func play3(param:() -> Void){
    param()
}
//尾随闭包
play3 {
    print("HHAHAHA")
}
func play4(param:() -> String){
    let value = param()
    print(value)
}
//尾随闭包
play4 { () -> String in
    return "OC"
}
func play5(param:(Int) ->Void , param2: Int){
    param(param2 * 2)
}
play5(param: { (data) in
    print(data)
}, param2: 20)

五十八、错误捕获和处理

//错误捕获和处理
enum TestError: String, Error{
    case error1 = "错误1"
    case error2 = "错误2"
    
}

func play(parma:Int) throws -> String{
    if parma < 0 {
        throw TestError.error1
    }else if parma >= 0 && parma <= 10{
        throw TestError.error2
    }
    print("正常执行")
    return "Hello"
}
do{
    let value = try play(parma: 110)
    print(value)
}catch TestError.error1{
    print(TestError.error1.rawValue)
}catch TestError.error2{
    print(TestError.error2.rawValue)
};defer {//5.1之后defer之前都要加;
    print("defer")
}
print("---------")
let value = try? play(parma: 10)
print(value)

print("---------")

五十九、枚举简写

enum TestError: String, Error{
    case error1 = "错误1"
    case error2 = "错误2"
    
}
//枚举简写
func play(paramError:TestError){
    print("hhaha")
}
play(paramError: TestError.error1)
play(paramError: .error1)

六十、补充

泛型类型的限定

class Data{
    var name: String
    init(name:String) {
        self.name = name
    }
}
//泛型类型的限定
func play<T:Any>(param:T){ //如果这里写Data就没事
    let a = param as! Data
    print(a.name)
    print(param)
}
play(param: Data(name: "Hello"))

协议的限定

class Data{
    var name: String
    init(name:String) {
        self.name = name
    }
}
protocol Test {
    associatedtype D //由实现类具体规定D的类型
    func play(param: D)
}
class Student:Test {

    func play(param:String) {
        print(param)
    }
}
var stu = Student()
stu.play(param: "Hello")

访问权限

private（方法里） < fileprivate（Swift当前文件内） <internal (默认、框架内) < public < open（可以被任何人继承、重写）