Swift枚举,结构体,类,扩展,协议

1.枚举

有的变量只要几种取值的选择,在swift中对这种比较特殊的变量,可以定义为枚举类型

枚举的定义

//enum 枚举名称{
//    此处放置枚举的成员
//}

枚举的代码

enum UserLever{
    
    case 总经理
    case 业务员
}

enum UserLever1
{
    case 总经理,业务员,哈哈
}

print(UserLever1.哈哈)

//注意:枚举和Swift不同的是他们的值并不会隐式等于0，1，2,3

枚举值的遍历

let caseValue=UserLever1.哈哈

switch  caseValue{
case UserLever1.哈哈:
      print("哈哈")
case UserLever1.总经理:
      print("总经理")
default:
    print("呵呵")
}

枚举的原始值

enum sex:Int
{
    case man=1
    case female=2
    case unknow=3
}
//另一种写法
enum sex1:Int
{
    case man=1,female,unknow
}
print(sex1.man.rawValue)

//给枚举添加方法
enum sex2:Int
{
    case man,female,unknow
    func fun()
    {
        print("哈哈")
    }
}

//调用枚举中的方法
let gender=sex2.man
gender.fun()

2.结构体

结构体的定义

//struct 结构体名称{
//    此处放置结构体的内容
//}

struct People{
    
    var name="大保健"
    var sex="男"
    //给结构体添加方法
    func getName() {
        
        print("name:\(name)    sex:\(sex)")
    }
    
}

let people1=People()

people1.getName()

people1.name

3.类

Swift 类是构建代码的一种通用而灵活的构造体,类是属于用户自定义的数据类型,并且该类型的数据具有一定的行为能力，也就是类中所描述的方法

类的创建

//class 类名
//{
//    属性列表
//    方法别表
//}

class people
{
    var name = "小明"
    var sex = "男"
    
    func fun(){
        
        print("name:\(name)")
    }
}

let p=people()

p.fun()
print(p.name)

其中可以在定义类的时候,给它指定自定义的init初始化方法

class people2
{
    var name = "小明"
    var sex = "男"
    //自定义的init初始化方法
    init() {
        
        self.name="哈哈"
        self.sex="女"
    }
    //带参数的实例化
    init(name:String,sex:String) {
        
        self.name=name
        self.sex=sex
        
    }
}

let pp1=people2(name:"呵呵",sex:"女")

print(pp1.name)

类属性的set和get方法，使用get和set来间接获取/改变其他属性的值

class people3
{
    var name = "小明"
    var getpeopleName: String {
        get {
            return name
        }
        set {
            name = newValue
        }
    }
}

let pp3 = people3()
pp3.getpeopleName="呵呵呵呵呵呵"//set
pp3.name//get

类属性的willSet和didSet方法,可以给类添加属性观察者

属性观察者可以观察属性值得变化,并对此作出相应的鹅反应，当设置属性值时,属性观察者就被调用,即使当新值和原值相同时也就会被调用
可以单独或者同时使用下面的方法,以进行属性观察者的定义:willset方法在设置属性值之前被调用。而didset方法则在设置属性值之后被调用
当实现willset观察者时,新的属性值作为常量参数被传递。可以为这个参数起一个名字，如果不命名,则这个参数就被默认命名为newValue
注意:set get 方法和willSet,didSet不能一起用好像

class people4
{
    var name = "小明"
    {
        
        willSet{
            
            print("即将设置为新值\(newValue)")
        }
        didSet{
            
           print("新值设置成功\(name)")
        }
    }
}

let pp4 = people4()
pp4.name="======哈哈"

类的静态方法

静态方法为类所有,需要通过类来使用,因此静态方法不必建立类的实例就可以使用,在Swift环境中可以为类,结构体和枚举等类型定义静态的方法,也称为类型方法

class people5
{
    //定义静态方法
    class func GetName(name:NSString)->NSString {
        
        return  name;
    }

}

print(people5.GetName(name:"哈哈哈"))

类的析构

与构造工程相反,实例最后释放的时候,需要清除一些资源,这个过程就是析构的过程。在析构过程中也会调用一个特殊的方法deinit，称之析构函数。析构函数deinit没有返回值,也没有参数,也不需要参数的小括号,所以不能重载

class people6
{
    var name:String
    
    init(name:String) {
        self.name=name
    }
    
    deinit { //定义了析构函数
        
      print("调用析构函数...")
      
        
    }
    
}


var pp6:people6? = people6(name:"小明")
print(pp6!.name)
pp6 = nil

类的继承

在Swift环境中，类的继承不同于结构体和枚举类型，继承是类所特有的。当一个类继承其他类时,继承类就被称为子类，被继承类称为父类或者超类
类的继承具有以下特点
1.继承是在一些通用类的基础上构造,建立和扩充新类的最有效的手段
2.继承能清晰体现相关类之间的程词机构关系
3.继承提供了软件复用功能
4.继承通过增强一致性,来减少模块间的接口和界面,大大增加了程序的易维护性

class people7{
    
    func say(){
        
        print("我要大保健")
    }
}


class peopleSon:people7{
    
    
    var name:String
    
    init(name:String) {
        
        self.name=name
    }
    
    
    
     func say1(){
        
        print("我们一起大保健")
    }
    
    override func say() {//重写
        
         print("我是：\(name)要去保健")
    }
    
}

let pp7=peopleSon(name:"麻痹戒指")
pp7.say()
pp7.say1()

类的延迟加载属性lazy

延迟加载属性是指当第一次被调用的时候,才会对其进行初始化的属性(就是懒加载)

class people8{

    lazy var name="小明"

}
let pp8=people8()
pp8.name

类的引用特征

class people9
{
    
    var name:String
    init(name:String) {
        
        self.name=name
    }
  
}

var pp9 = people9(name:"呵呵")
pp9.name="麻痹戒指"

var pp91=pp9
pp91.name="古天乐麻痹戒指"
print(pp91.name)

类型的检测

类型检测在swift中是一种检测实例类型的方式，同时也是让实例作为它的父类或者子类的一种方式

class people10
{
    
    var name:String
    init(name:String) {
        
        self.name=name
    }
    
}

class peopleson1:people10
{
    func say() {
        
        print("古天乐麻痹戒指")
    }
}


let pps10 = peopleson1(name:"呵呵")


// is操作符是一个类型检査操作符,在Swift中,对它的定义是:检测一个实例是不是特定类的子类型,如果是,则该操作符返回true,如果不是,则返回false.
if (pps10 is people10){
    
    print("是这种类型")
}

// as操作符是一个类型转换操作符,主要用于实例在子类和父类间的转换
if let item=pps10 as? people10{
    
    item.name="====古天乐麻痹戒指"
    item.name
}

anyObject和any

Swift为不确定类型提供了两种特殊类型别名：
AnyObject可以代表任何class类型(即类类型)的实例。
Any可以表示任何类型，包括方法类型（function types）。用来修饰任意类型的实例,包括AnyObject修饰的实例.
注意：
只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的.
AnyObject类型
AnyObject任意实例类型
Any 其实Any是AnyObject的总类,完全覆盖AnyObject.

class Evil{
    
    var name = ""
}

var hiter = Evil()
hiter.name = "保健"

var hiter1 = Evil()
hiter1.name = "大保健"

var array = [AnyObject]()
array=[hiter,hiter1]

if let item=array[1]as?Evil {
    
    item.name
}

4.扩展

Swift中的扩展功能（Extension）,可以动态地给类增加功能,类似JavaScript中prototype，这包括在没有权限获取原始源代码的情况下,扩展某个类型的功能。而在object-C中,则是通过runtime中来实现动态调用或者添加功能的
现有的类,结构或枚举类型的方法,可以在扩展的帮助下进行添加。类型的功能可以使用扩展加入，但重写的功能不能使用扩展
在Swift中使用扩展可以完成以下任务
添加计算型属性和计算型静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型符合某个协议
注意：
扩展可以对一个类型添加新的功能，但是不能重写已有的功能。

示例代码

extension String{
    
    //添加属性
    var name:  String{
        
        return  "呵呵"
    }
    
    func getname(name:String) -> String {
        
        return name;
    }
}

print("名字".name)
print("名字".getname(name:"麻痹戒指"))

//添加构造器
/*
 
 其实构造器就是一个特殊的方法,所以扩展构造器方法就是添加方法,不过要注意两点:
 1:如果扩展类类型,我们只能够增加便捷构造器,而不能够增加指定构造器和析构器.
 2:对于值类型,比如结构体,枚举,在扩展其构造器时,务必保证所有的属性都被初始化.
 
 */

struct people{
    
    var name = "小明"
    
}

extension people
{
    func say() {
        
        print("麻痹戒指")
    }
}

let p = people()

p.name
p.say()

5.协议定义

协议是为方法,属性等定义一套规范,没有具体的实现,类似Java中的抽象接口，它只是描述了方法或者属性的骨架,而不是实现。
协议可以通过一个类,结构或枚举，来提供协议中要去的具体实现