Swift基础语法2 类与对象

类的定义

class Person{
    static let str:String = "我是swift"
     var name:String?
     var age:Int8?
    
    private var sex:Int?
    init() { // 初始化构造器 不写也有默认的
    }
    
    public func setSex(sex:Int)->Person{
        self.sex = sex
        return self
    }
    public func getSex() -> Int?{
        return self.sex
    }
}

var person = Person()
person.setSex(sex: 1).age = 18
person.name = "张三"
print(person.getSex()!,person.age!,person.name!,Person.str)

var person2 = Person()
print(person === person2) // 对象是否相等 
print(person !== person2) // 对象是否不等 
/*
对象间传递的是引用 object1 = object2
修改 object2 的值 object1的值也修改 
浅拷贝
*/

析构函数

deinit{
  // 类销毁 可以在这里处理 一些资源释放
}

Any 和 AnyObject

var a:Any = 1 // Object 包含所有 基础数据类型 类 结构体 。。。 
var a:AnyObject = Person() // 只能是类 

类的继承 （单继承）

// 基类 final class 不允许继承  final Methods 不允许重写
class Base{
    private var name:String?
    
    public func setName(name:String?)->Base{
        self.name = name
        return self
    }
    
    public func getName()->String {
        return self.name!
    }
}
// Person 继承 Base
class Person:Base{
    
    public override func getName() -> String { // 重写
        return "123"
    }
  
   public func o1(a:Int){
        return
    }
    public func o1(b:Int){ // 参数名 参数类型 参数个数 返回值不同都能重载
        return
    }
  
}
var person = Person()
person.setName(name: "张三")
print(person.getName()) // 123

var person1:Base = Person() // 多态
print(type(of: person)) // Person

// Person2 继承 Base
class Person2:Base{
    
    public func sum(a:Int,b:Int)->Int{
        return a * b
    }
}
person1 = Person2()

if(person1 is Person2){ // instanceof
    let person2 = person1 as! Person2 // 向下类型转换 as！明确知道什么类型 as？不明确什么类型 需要加默认类型

    print(person2.sum(a: 20,b: 10))
}else{
    print("person 不是 Person2 类型")
}

扩展 extension

// 为已有类进行扩展  final 类也是可以扩展的 
// 对于已有类的API觉得不好用 自己可以对类功能扩展增强 
extension Base{
  static func toString(){
    print("toString")
  }
}
Person.toString()

泛型

// 和Java一样 可以使用不定类型符 也可指定类型 也可以指定 T:Int 是某一个协议 或者 类的子类
class Test<T>{
    var name:T?
   
    public func test(a:T)->T{
        return a
    }
}

class Dict<String,V>{
    var key:String?
    var val:V?
}

协议 protocol ≈ interface 接口

// interface

protocol BaseProtocol{ // 协议 
    func play(a:Int) -> String // 接口定义
}

class Base{
    var name:String?
}
protocol BaseProtoco2{
    // 接口
    func play() -> String
}

class Test:Base,BaseProtocol,BaseProtoco2{ // 多协议实现  继承必须放在第一位
    
     func play(a: Int) -> String { // 接口实现
        return String(a)
    }
    
    func play() -> String { // 接口实现
        return self.name!
    }
}
/*
	协议也可以继承别的协议
	扩展也可以实现协议
*/

类的属性中 包含闭包引用 无法析构

class Test{
  var name:String
  lazy var a:()->Void = {  () -> Void  in 
 	     print(self.name)                    
  }
  init(name:String){
    // 构造函数
    self.name = name
  }
  deinit{
    // 析构函数
  }
}

var test = Test("张三")
test = nil // 会执行析构

test = Test("李四")
test!.a()
test = nil // 不会执行析构
/*
test 执行了闭包后  闭包会持有一个 self 的强引用 
类自动析构时的条件是 没有任何一个强引用指向它
此时的 就是 类持有闭包 闭包持有类引用 形成了循环 所以不能触发 析构函数 
*/
// 修改闭包 加入引用捕获 在没有外部强引用是 内部闭包会变更强引用会无主引用
// 【无主引用申明 引用名】  
lazy var a:()->Void = {[unowned self]  () -> Void  in 
 	     print(self.name)                    
  }
//感觉这里 改成 weak 弱引用应该也是可以的

可选链

// 就是链式调佣
class Data{
  public func play{
    print("11")
  }
}
class Test{
  var data:Data?
}

var test:Test? = Test()
test.data = Data()
test?.data?.play()  // 此处要是没有Data 的实例 就不会调用 paly（）方法 
test!.data!.play() // 确定有data 实例就可以使用 !. 来调用 如果没有data 实例 会报错 

尾随闭包

函数中只有一个参数 并且参数是一个函数类型 或者N个参数 最后一个参数是一个函数类型在函数调用的形参列表后面跟随 闭包 就是尾随闭包

func test(param:(Int)->String){
  var val =  param(1)
  print(val)
}
test(){(param)->String in  // 只有一个参数 小括号可以省略
      return String(param)
 }

异常处理

enum TestExeption:String,Error,CaseIterable{ // 异常枚举
    case Error1 = "内部错误" // 错误消息
    case Error2 = "找不到"
}

func test(i:Int) throws { // 抛出错误
    if(i < 0 ){
        throw TestExeption.Error1
    }else if(i > 0 && i < 10){
        throw TestExeption.Error2
    }else{
        print("正常")
    }
}

// 捕获异常处理 
do { 
    try test(i: 2)
    print("try")
} catch TestExeption.Error1 {
    print(TestExeption.Error1.rawValue)
}catch TestExeption.Error2{
    print(TestExeption.Error2.rawValue)
}
defer {
    print("这里就是 finally")
}

访问权限

private  私有类内部
public   公有模块下 导入后 模块外部也能用
internal 公有模块下 导入后 模块外部也不能用 不申明默认就是它
fileprivate 文件内部有效 实现再外部 其他也看不到只能自己用
open 和 public 的区别是：open 可以在其他模块中被继承、重载。 public 不可以 只能被访问