Swift中enum, struct, class的有关使用方法

import Foundation

print("Hello, World!")

let a = 10
var b = 20
var c = a + b;
c = 3000

//重载:函数名相同, 函数类型不同(参数, 返回值不同), 构成重载, 调用的时候, 根据参数确定调用那个函数
func helloworld(a:Int)->Int {
    return a * 100
}
func hellowold(a:String)->Int {
    return 100
}
print(hellowold("123"))

//for 循环
//区间0...10 = [0, 10]  0..<10 = [0, 10)
for i in 0...10 {
    print("i = \(i)")
}

//1.枚举
//2.类 和 结构

//定义枚举值
enum Direction : String {
    case East = "东"
    case West = "西"
    case South = "南"
    case North = "北"
}

//定义变量接受枚举值
//如果给一个变量赋值过一次枚举值, 下次赋值可以直接使用.进行赋值
var dir = Direction.East
print(dir)

var dir2 = dir
dir = .North
print("dir = \(dir.rawValue), dir2 = \(dir2.rawValue)")

//枚举值的原始值
enum Season: Int{
    case Spring = 100
    case Snmmer
    case Fall
    case Winter
}

var se = Season.Spring
//rawValue, 原始值
print(se.rawValue)

//通过枚举值的原始值找到枚举值
let sea = Season(rawValue: 100)
print(sea)

//隐式解析
if let s = sea {
    print("s = \(s)")
} else {
    print("无法找到枚举值")
}

enum Student: String{
    case Primary = "小学"
    case junior
    case senior
    case university
}

var stu = Student.Primary
print(                                                                                                                                                                                                                                                                                                                                                                                                                                    stu.rawValue)

let student = Student(rawValue:"小学")
print(student)

if let st = student {
    print("st = \(st)")
} else {
    print("无法找到枚举值")
}


enum FourFlower : String {
    case 闯神 = "尼古拉斯·闯"
    case 龙神 = "龙神"
    case 宗主 = "宗主"
    case 半张 = "半张"
}

let flower = FourFlower.闯神.rawValue
print("闯神\(flower)")

//类 和 结构体
struct Person{
    var height = 1.8
    var weight = 75
    var age = 25
}

//实例结构体化
//()就是结构体的一个初始化方法
var 广恩 = Person()
print(广恩.weight)
广恩.weight = 90
print("广恩的体重 = \(广恩.weight)KG")


//逐一构造器
//构造 = alloc...init = 初始化
//析构 = dealloc = 释放
var 康康 = Person (height: 178, weight: 70, age: 23)

let str = "康康的身高为\(康康.height), 体重为\(康康.weight)" + ", 年龄为\(康康.age)"
print(str)

var 李阳 = 康康
康康.height = 180
print("李阳.height = \(李阳.height)")

//类
class Student1{
    var num = 12345
    var name = "万宝"
    var GoodFriend = "闯神"
}

//系统没有给类自动添加逐一构造器
var 万少 = Student1()
万少.GoodFriend = "越南"
print(万少.GoodFriend)

var 龙神 = 万少
万少.GoodFriend = "Xcode"
print(龙神.GoodFriend)

//A = B
//值类型 : 赋值完成以后, B 修改, A不变. 枚举值 和 结构体就是值类型. 类似 copy 的过程
//引用类型 : 赋值完成以后, B 修改, A 随着 B 改变, 类就是引用类型. 类似 retain 的过程

//属性
//存储属性:用来存值和取值
//计算属性:计算属性的值通过 GET 方法, 用其他因素获取, set方法一般用来处理事务. 只写 GET, 这个属性是只读的; 不能只写 set
class Animal {
    //存储属性
    var type = "Elephant"
    var weigh = 1000
    //计算属性
    var leg : Int {
        get {
            if type == "Elephant" {
                return 4
            } else if type == "bird" {
                return 2
            } else {
                return 3
            }
        }
        //set 方法需要一个 新值 参数
        set(newValue){
            if(newValue >= 4){
                print("不可能是人")
            } else {
                print("有可能是人")
            }
        }
    }
}

var per = Animal()
per.type = "老人"
print("per.leg = \(per.leg)")

per.leg = 10
print("per.leg = \(per.leg)")

//练习
//1.定义一个名字为rect的结构体
//2.属性包括 存储属性, x, y, with, height  计算属性 centerX, centerY
//3.centerX 和 centerY 由存储属性计算得出
//4.centerX 和 centerY 的 set 方法内分别依据 x/y 和 新值计算width/height

struct Rect {
    
    //属性包括 存储属性, x, y, with, height
    var x = 0.0
    var y = 0.0
    var width = 0.0
    var height = 0.0
    
    //在类内部使用属性的时候, 可以省略 self.
    //只有涉及到参数名字和属性相同的时候, 建议加上 self.以示
    
    //计算属性 centerX, centerY
    var centerX :Double {
        get{
            //centerX 和 centerY 由存储属性计算得出
            return self.x + self.width/2.0
        }set{
            //centerX 和 centerY 的 set 方法内分别依据 x/y 和 新值计算width/height
            width = (newValue - x)*2
        }
    }
    
    
    var centerY :Double {
        get{
            return y + height/2.0
        }set{
            height = (newValue - y)*2
        }
    }
    
}


//属性观察器
class Plant {
    
    var type = "绿色植物"{
        willSet(newType) {
            print("newType = \(newType), 当前值\(type)")
        } didSet(oldType) {
            print("oldType = \(oldType), 当前值\(type)")
        }
    }
    
    var hasFlower : Bool = false {
        willSet {
            print("新值为\(newValue), 当前值为\(hasFlower)")
        } didSet {
            print("旧值为\(oldValue), 当前值为\(hasFlower)")
        }
    }
}
var appleTree = Plant()
appleTree.type = "苹果树"
appleTree.hasFlower = true


//类型属性
class Fruit {
    //是否有皮
    static var hasRind = true
}

print("水果是否有皮: \(Fruit.hasRind)")


//方法
class Computer{
    var brand = "美帝良心想"
    var price = 6888
    func des(name:String){
        print("\(name)买了\(brand), 花了￥\(price)")
    }
}
var compu = Computer()
compu.des("闯神")

class Car {
    var brand = "奥迪"
    var color = "黑色"
    func TYPE(name:String){
        print("\(name)买了颜色为\(color)的车, 牌子是\(brand)")
    }
}
var car = Car()
car.TYPE("外星人")

//继承
//定义父类
class Teacher {
    var academic = "教授"
    var offer = 8888
    func teach(){
        print("某\(academic)的薪资是\(offer)")
    }
    
    //禁止被重写的方法
    //final 禁止被重写的关键字
    final func study(bookName:String){
        print("某\(academic),刻苦钻研\(bookName)")
    }
    
    var num : Int {
        get {
            return 100
        } set {
            
        }
    }
    
    
}

//定义一个子类
//讲师
class Lecturer: Teacher {
    var industry = "iOS"
    //重写父类方法
    //override 重写父类方法关键字
    override func teach() {
        //调用父类方法
        super.teach()
        print("从事行业是\(industry)")
    }
}
let lec = Lecturer()
lec.academic = "两院院士"
lec.teach()
lec.study("<<论持久战>>")

//重写属性
//把存储属性重写为计算属性
//不能把计算属性重写为存储属性
class ChildrenTeacher:Teacher {
    override var offer: Int {
        get{
            return 10000
        } set {
            
        }
    }
//    override  var num = 100
}

//构造
//除了可选类型属性, 在构造过程中, 必须给各个属性赋初始值
class Hero{
    var age :Int?
    var name : String
    var equipment = "金箍棒"
    var saddleHorse : String
    init(){
        name = "孙悟空"
        saddleHorse = "筋斗云"
    }
    //自定义一个构造方法
    init(name:String, equipment:String, saddleHorse:String ){
        self.name  = name
        self.equipment = equipment
        self.saddleHorse = saddleHorse
    }
}
let 孙悟空 = Hero()
print(孙悟空.saddleHorse)
let 大禹 = Hero(name: "大禹", equipment: 孙悟空.equipment, saddleHorse: "11路公交")

class Film {
    var name :  String
    var price : Float
    var director : String
    
    init (name:String, price:Float, director:String){
        self.name = name
        self.price = price
        self.director = director
    }
    func description(){
        print("电影名字\(name), 价格为\(price), 导演是\(director)")
    }
    
    //遍历构造器
    //和 OC 的不是一回事, OC的是 类方法
    //convenience 在构造方法前添加 convenience代表当前构造器为便利构造器
    //遍历构造器必须调用自身的指定构造器
    convenience init(){
        self.init(name:"123", price:22, director:"王晶")
//        name = "123"
//        price = 22
//        director = "王晶"
    }
}

let 澳门风云三 = Film(name: "澳门风云三", price: 33, director: "尔冬升")
print(澳门风云三.price)
澳门风云三.description()

let 恶棍天使 = Film()
恶棍天使.description()