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

 import Foundation

 print("Hello, World!")

 let a =
 var b =
 var c = a + b;
 c = 

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

 //for 循环
 //区间0...10 = [0, 10]  0..<10 = [0, 10)
 for i in ... {
     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 =
     case Snmmer
     case Fall
     case Winter
 }

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

 //通过枚举值的原始值找到枚举值
 let sea = Season(rawValue: )
 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 =
     var age =
 }

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

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

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

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

 //类
 class Student1{
     var num =
     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 =
     //计算属性
     var leg : Int {
         get {
             if type == "Elephant" {
                 return
             } else if type == "bird" {
                 return
             } else {
                 return
             }
         }
         //set 方法需要一个 新值 参数
         set(newValue){
             if(newValue >= ){
                 print("不可能是人")
             } else {
                 print("有可能是人")
             }
         }
     }
 }

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

 per.leg =
 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)*
         }
     }

     var centerY :Double {
         get{
             return y + height/2.0
         }set{
             height = (newValue - y)*
         }
     }

 }

 //属性观察器
 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 =
     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 =
     func teach(){
         print("某\(academic)的薪资是\(offer)")
     }

     //禁止被重写的方法
     //final 禁止被重写的关键字
     final func study(bookName:String){
         print("某\(academic),刻苦钻研\(bookName)")
     }

     var num : Int {
         get {
             return
         } 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
         } 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:"", price:, director:"王晶")
 //        name = "123"
 //        price = 22
 //        director = "王晶"
     }
 }

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

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