Swift笔记(七)--枚举 结构体和类

一 枚举

1.1在oc和swift中枚举的不同

• 在oc中 枚举仅支持int类型,默认首元素值为0,后续的元素依次+1
  中间的元素有赋值,以此为准,后续没赋值的元素值依旧依次+1
• 在swift中比oc强大很多
  不用逗号分离,类型需要使用case声明
  支持int double sting等基础类型,当类型为string时候,默认值为key,当类型为int double时,默认值从0开始+1递增
  支持自定义选项

1.2枚举使用

//写法一
enum Week:String{
    
    case Mom = "Mom"
    case TUE
    case WED
    case THU
    case FRI
    case SAT
    case SUN
    
    func testmeiju(_ testStr:String) -> Void {
        print(testStr)
    }
}

//写法二 可以直接一个case,使用逗号隔开
enum Week1 {
case Mon,TUE,WED,THU,FRI
}
var type: Week = .Mom

在siwft中枚举除了int外还可以是string

enum Week1:Int {
case Mon = 3,TUE,WED,THU,FRI
}
var type: Week1 = .WED
print(type.rawValue)

我们可以看到typr输出的是5

enum Week2:String {
case Mon = "星期一",TUE,WED="星期三",THU,FRI
}
var type1:Week2 = .Mon
print(type1.rawValue)

type1输出的是 星期一,而我们没有自定义值的则默认为case对应key.TUE打印输出的是TUE.

1.3 枚举的关联值

枚举的关联值是将额外信息,附加到枚举值中的一种方式.每一种枚举值都可以试再某种特定的情形下,关联特定的值

//定义交易枚举,包含了买 和卖
enum Trade {
    case Buy(thing:String,count:Int)
    case Sell(thing:String,money:Int)
}
//关联某一些值
var tradebuy = Trade.Buy(thing: "买了一个房", count: 2)
var tradesell = Trade.Sell(thing: "卖出去", money: 100)

//取值 需要把各种分类都判断
switch(tradebuy){
case .Buy(let thing,let count):
    print("操作:\(thing) 买了多少\(count)")
case .Sell(let thing,let money): break
    
}
if case let Trade.Buy(thing, count) = tradebuy {
    print("bug:\(thing) of \(count)")
}

二 结构体

我们先以一个简单的结构体 引出它的定义

struct Student{
    var name:String
}
var midstudents=Student(name: "harry")
midstudents.name = "小二 上酒"
print(midstudents.name)

上面我们创建了一个Student结构体，在它里面包含了name属性。然后下面就是它的调用。midstudents它是一个变量结构体，所以是持有name属性的。

2.1 计算属性

我们在来看看下面代码

struct Student{
    var name:String
    var score:Int
    var isgood:String{
        if score>80{
            return "这是个好学生啊"
        }else{
            return "一般吧"
        }
    }
}
var midstudents=Student(name: "小张", score: 60)
//midstudents.isgood = "好学生"
print(midstudents.isgood)

isgood这个属性是无法直接赋值的，它是一个计算属性。是根据其他的存储属性来判断计算的。

2.2 属性观察者

在结构体中，当我们想知道属性的变化时。我们可以这样写

struct Progress{
    var task:String
    var count:Int{
        didSet{
            print("\(task)已经完成了\(count)")
        }
//        willSet{
//            print("\(task)已经完成了\(count)")
//        }
    }
}
var test=Progress(task: "小白", count: 10)
test.count=20
test.count=30
test.count=40
test.count=80

小白已经完成了20
小白已经完成了30
小白已经完成了40
小白已经完成了80

这里就观察到了属性的变化，其实这个观察和我们的set方法是类似的。只不过相较于与oc中的set方法，他又多了一个willSet

2.3 方法

既然在结构体中可以有属性变量，那是否可以存在方法呢？这肯定是可以的。

struct MathAction{
    var num:Int
    func squreAction()->Int{
        return num*num
    }
}
var math=MathAction(num: 10)
math.num=11
print(math.squreAction())

上面的结构体中就实现了一个简单的方法。
上面的方法中，只有我们在结构体外设置num，num发生变化。那么在方法中我们是不是可以自己设置num的值呢？

struct MathAction{
    var num:Int
    mutating func squreAction()->Int{
        num=88
        return num*num
    }
}
var math=MathAction(num: 10)
math.num=11
print(math.squreAction())
7744

我们可以看到 num变为了88，所以最后的值是7744.想要改变属性值时，需要在方法前使用mutating来修饰。

2.4 构造器

构造器是一种可以用来支持不同方式创建结构体的特殊方法，所有的结构体都有一个默认的构造器。像上面的例子中，在创建爱你结构体实例的时候，我们都提供了属性的值。如果不提供就会报错。

struct Person{
    var name:String
    init() {
        name="小李"
    }
}
var ren=Person()
print(ren.name)

我们可以加入init方法来初始化默认属性变量

2.5 静态属性和方法

Swift在不同的结构体实例之间共享属性和方法，这些属性和方法被称为静态属性和静态方法，实现的方式是添加 static 声明。

struct Person{
    var name:String
    static var count=0
    init(name:String) {
        self.name=name
        Person.count+=1
    }
}
var ren=Person(name: "二啊")
var people=Person(name: "xiaoming")
print(Person.count)

打印出来的count是2 并非1.这说明结构体中间共享了属性和方法.

三 类

相较于结构体,类是可以继承的.

class Animal {
    var name:String = ""
    var age:Int = 0
    func makeNoise() {
        print("父类的输出")
    }
    deinit {
        print("销毁类")
    }
}

class Dog:Animal {
    
    var nickname:String = ""
    //重写父类的函数方法
    override func makeNoise() {
        print("子类的输出的就就得")
    }
}

我们创建了一个Animal类,而dog是继承于Animal.是可以访问name, age,函数的.

重写方法

还是上面的代码
我们可以看到,在父类中存在方法makeNoise.输出的是"父类的输出".
我们在子类中想实现其他逻辑时,就需要重写这个方法.就想上面的代码,我们需要再重写的方法前添加上override.

限制继承

当我们在Animal类之前添加上final关键字时候,就可以看到class dog类直接报错了,这是因为添加上final以后,将没有类能够继承这个修饰的类.所以就会报错