Swift 类

Swift.png

类的简单介绍

• 继承允许一个类继承另一个类的特征，也可以不继承其他类。
• 类型转换允许在运行时检查和解释一个类实例的类型
• 析构器允许一个类实例释放任何其所被分配的资源
• 引用计数允许对一个类的多次引用
• 默认情况下，不能保证所有的非可选属性有值
• 当用定义的类 创建 对象完成后，必须保证里面所有的非可选属性都有值
• 格式如下：

class 类名称 {
   //在这里定义 类的属性 或者方法
}
//类中的实例和方法
// 属性 包括 实例属性和类型属性
// 方法 包括 实例方法和类型方法

• 注意：在定义类的时候，属性和析构函数必须写在类里面，不能写在扩展里面，Swift之运行在ARC环境下

定义类

//定义一个类
class Person {
    
    var name:String?
  
}
// 当一个实例对象被创建完成好之后，必须保证里面的所有非可选属性都有值
let p = Person();

//注意： 在创建类是 用一下方法 可以解决 上面 描述的问题
//1.在创建时 解决 - > 添加  init方法 在里面 赋值

//2.在 非可选类型 解决 -> 用可选的属性 

//3.给非可选的属性 给一个默认值 ->在添加属性的时候 给默认值

类是引用类型

• 引用类型在被赋予到一个变量、常量或者被传递到一个函数时，其值不会被拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
• 我们知道 结构体是 值类型，它是 值传递的

//我们声明一个Person类
class Person {
    var name:String?
   var age:Int?
    var sex:Int = 0; //(0是男 1是女)
    
    
}

//创建一个实例对象
let p = Person();
p.name = "CC";
p.age = 18;
//讲p赋值给p1,
// 因为 类是引用类型，所以p1和p实际上应用的是相同的 Person实例，也就是说他们是 同一个实例的 2个不用的称呼
let p1 = p;
p1.name = "BB";

print(p1.name,p.name,p1.age);

// 打印结果 ：Optional("BB") Optional("BB") Optional(18)

析构函数

• 析构函数就相当于OC中的dealloc函数
• 析构函数必须写在 类里面 ，不能写在扩展里面

class Person {
    
    var name:String = ""
    var age:Int = 0
    
    //析构函数 等于OC中的 dealloc函数
    deinit {
        
        print("对象释放了")
    }
    
}

var p:Person? = Person();
p = nil;

//打印结果:  对象释放了

类的属性和方法

• 属性
  • 实例属性
    • 存储属性
    • 计算属性
  • 类型属性

• 类型属性

class Person {
    
    //类型属性
    static var personCount:Int = 0;
    
    init() {
        Person.personCount += 1;
    }
    
    //析构函数 等于OC中的 dealloc函数
    deinit {
        Person.personCount -= 1;
    }
    
}

//查看创建对象的个数
var p1:Person? = Person();

var p2:Person? = Person();

var p3:Person? = Person();

Person.personCount;
//对象销毁
p1 = nil;

Person.personCount;

• 实例属性

class Student {
    //实例属性
    var name:String?
    var age:Int?
    var score:Double?
    var score1:Double?
    
    //计算属性：求平均值
    var pingjunScore:Double {   
  // get 方法
        get{
            return ((score ?? 0) + (score1 ?? 0))/2;
        }
        
    }
   
}

let S = Student();
S.pingjunScore;
S.score1 = 10;
S.score = 20;
S.pingjunScore;

• 方法
  • 实例方法
  • 类型方法
    • 用static声明，但是在使用中子类不可以重写
    • 用class声明，在使用中子类可以重写
    • 重写方法的关键字是： override

class Student {
   
    //实例方法
    func test() -> Void {
        
        print("实例测试");
    }
   //类型方法 
   static func test() -> Void {
        print("类型测试");
    }

  class func test2() {
         print("clsaa类型测试");
    }
  
}

let S = Student();
S.test();
Student.test();
Student.test2();
//打印结果:
实例测试
类型测试
clsaa类型测试

监听属性的改变 - 属性观察器

• 属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，即使新值和当前值相同的时候也不例外
• willSet 在新的值被设置之前调用,
  • willSet观察器会将新的属性值作为常量参数传入，在 willSet 的实现代码中可以为这个参数指定一个名 称，如果不指定则参数仍然可用，这时使用默认名称 newValue表示。
• didSet 在新的值被设置之后立即调用
  • didSet 观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名 oldValue 。如果 在 didSet 方法中再次对该属性赋值，那么新值会覆盖旧的值。

class Student {

    var name:String?{
        
        //即将赋值
        willSet{
            
            print(name);
            print(newValue);
            
        }
        
        //已经赋值
        didSet {
            
            print(oldValue);
            print(name);
            
        }
    }
  
}


let stu = Student();
stu.name = "CC";

//没有赋值之前
nil ->name
Optional("CC")  -> newValue
//赋值之后
nil  ->oldValue
Optional("CC")  ->name

Swift自动引用计数

• 当有一个强引用指向某一个对象时，该对象的引用计数会 +1
• 当该强引用消失时，引用计数-1
• 当引用计数为0时，对象会被销毁

//创建2个类 person类里面有一个dog属性  Dog里面有一个master属性

class Person {
    var dog:Dog?
    deinit {
        print("人没了");
    }
    
}

class Dog {
    //weak 防止循环引用
   weak var master:Person?
    deinit {
        print("狗没了");
    }
    
}

//引用计数 +1
var p:Person? = Person(); 
 //引用计数加1
var p2 = p;
//当 p=nil 时 引用计数-1  对象没有被销毁 因为引用计数现在是1
p = nil
//当 p2 = nil 销毁 应用计数为0
p2= nil 


//循环应用

var d = Dog();
// 相互引用
p.dog = d;
d.master = p;
//解决方法是在属性前面加一个 weak

循环引用.jpeg

类的3大特性

• 封装：把一些功能或者代码块整合起来方便使用

• 继承：子类继承父类的属性或者方法，子类可以重写父类的方法（重写和重载是不一样的）

• 多态：父类指针，指向子类，来调用子类的方法

• 重写方法的 关键字 override

class Person {
    
    func test() {
        
        print("方法")
    }
    
}

class Student:Person {
    
    override func test() {
        print("子类重写父类的方法")
    }
    
    
}

• 重载方法
  • 重载方法其实是根据函数的类型来的
  • 编译器区分函数类型
    • 1.根据函数的名称区别函数
    • 2.根据外部参数名称 区别函数
    • 3.根据 参数类型 + 返回值类型 = 函数类型 来区别

class Person {
    
    //重载方法
    func test(a:Int) -> Int {
        
        return 1;
    }
    
 @objc(test：)
    func test(a:Double) -> Int {
        
        return 2;
    }
    
    
    
    
}


let p = Person();
let num = p.test(a: 1.0);

//如果Person继承自NSObject  需要 @objc(函数名) 因为反正继承NSObject的类，都有可能转化成OC 的方法

结构体和类的区别

• 结构体有逐一构造器，类没有
• 结构体是值类型，类是引用类型
• 结构体不能继承没有多态

Any NSObject AnyObject的区别

• Any :一个协议的声明
• AnyObject:一个具体的协议，协议里面没有内容，默认情况下，所有的类，都遵循这个协议
• NSObject:类

Swift中Any可以存放任意的类型
AnyObject只能存放类
NSObject只能存放继承自己的类的子类

遍历构造函数

• 遍历构造函数:通常是对系统的类 进行构造函数扩充
• 遍历构造函数 通常写在 extension里面
• 遍历构造函数 必须在 init 前面加上 convenience 关键字
• 遍历构造函数必须 调用 self.init() ，不调用会 报错

我们通常在编程的时候，会写分类 扩展，所以就会用到 遍历构造函数
比如给一个button扩展 如下：

//扩展
extension UIButton {

//关键字 convenience 
//调用：   self.init();
 convenience init(imageName:String,bgImageName:String) {
       
        self.init();
       
        setImage(UIImage(named:imageName), for: .normal);
        setImage(UIImage(named:imageName + "_highlighted"), for: .highlighted);
        setBackgroundImage(UIImage(named:bgImageName), for: .normal)
        setBackgroundImage(UIImage(named: bgImageName + "_highlighted"), for: .highlighted)
        sizeToFit();
    }




}