这篇接着上一篇内容 写一下类/结构体/枚举

下面我将在Xcode上写的代码带标注写在这里 希望会对大家有所帮助

属性的作用:

1.声明了setter getter方法
2.实现了setter getter方法
3.声明了一个成员变量,名字前边带下划线

struct Frame {
    //存储属性 : 仅仅做存储值得作用
    //计算属性 : 通过计算获得自己的值
    //设置属性的setter 和get方法
    //属性里面的set方法不能单独存在 必须有一个同属性的get方法存在之后才可以写set
    var x : Float
    var y : Float
    var width : Float
    var height : Float
    
    var centerX : Float {
        get {
            return self.x + width / 2
        }
        set {
            self.centerX = newValue
        }
    }
    var centerY : Float {
        get {
            return y + height / 2
        }
        set {
            self.centerY = newValue
        }
    }
    //初始化 外部参数名 内部参数名
    init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float) {
        self.x = newX
        self.y = newY
        self.width = newWidth
        self.height = newHeight
    }
    //修改结构体里函数的值 加mutating
    //Swift的结构体可以任意的创建函数
    //如果需要在函数里面修改属性的值的话 需要在函数面前添加mutating关键字修饰
  mutating func heheeh() {
        self.x = 100
    }  
    //结构体属性
    //结构体属性是不能再普通的函数里面去调用
    //结构体函数里面可以调用结构体属性
    //结构体函数里面可以调用一些本结构体存在的函数
    static var name : String? = nil  
    static func sayName() {
        self.name = "我是一个frame"
        print(self.name)
    }   
}
//调用方式
//第一张调用方式
let frame : Frame = Frame.init(x: 10, y: 10, width: 10, height: 10)
print(frame.centerY, frame.centerX)
//第二种调用方式
let frame1 : Frame = Frame(x: 100, y: 100, width: 100, height: 100)
print(frame1.centerX, frame1.centerY)
//调用结构体函数 必须的通过这个结构体去调用
Frame.sayName()

//类的格式 class 关键字 + 类名 {类的实现 }
class Person {
    //在类里面创建一个属性的时候 必须有初值 如果不想设置初值 那么就设置成为可选类型
    var name : String? = nil
    var age : Int? = nil
    //private 表示的是私有属性
    private var gender : String? = nil
    //static 修饰的属性表示类属性
    static var country : String? = nil
    //初始化方法
    init(name newName : String, age newAge : Int) {
        name = newName
        age = newAge
    }
    //写一些方法
    //实例方法里面不能直接调用类属性
    //实例方法可以直接对实例对象进行修改赋值
    //在函数声明之前添加一个private 表示私有方法
    private func sayHi() {
        self.gender = "女"
        print(self.gender)
    }
    //static 修饰的是类方法 是不可以被子类重写的
    static func  sayhehe() {
        self.country = "中国"
        print(self.country)
    }
    //class修饰的也是类方法
    class func sayNihao() {
        self.country = "China"
        print(self.country)
    }
}
let person : Person = Person(name: "张三丰", age: 118)
Person.sayNihao()
Person.sayhehe()
//类名 : 父类
class Student: Person {
    //在子类里边想重写init方法需要添加override修饰
    override init(name newName: String, age newAge: Int) {
        super.init(name: newName, age: newAge)
    }
    //可以重写class static不可以被重写
    override class func sayNihao() {        
    }    
}
//协议
//格式 protocol 关键字 + 协议名字
protocol myDelegate {
    //协议方法前面添加mutating修饰的关键字之后 可以修改结构体里面的参数 在类里面会自动的忽略mutating
   mutating func hehehe()
    
}
// 如果有需要可选实现的协议 在最前面添加 @objc 修饰 内部的方法用optional修饰可选实现的方法,其他的不变
// OC 的协议
@objc protocol newDelegate {
    //这个方法可选实现 在前边加optional
    optional func lalala()
}
//如果一个类既有父类 也遵守了某个协议 那么格式是class + 类名:父类 协议名字
class newClass: myDelegate {
    func hehehe() {        
    }
}
//创建一个结构体
//结构体可以遵守协议 但是结构体只能遵守Swift的协议
struct newStudent : myDelegate {
    var name : String
    mutating func hehehe() {
        self.name = "asd"
    }
    var x : Float
    var y : Float    
}
//extension 可以给一个类拓展新的协议
extension Person : myDelegate {
    func hehehe() {      
    }
    //extension不可以添加新的属性
//    var height : Float? = nil
    //可以给一个类添加新的函数
    func wangweidong()  
    }
}
//exension 可以给一个结构体拓展新的协议 没有新的属性 会覆盖原有的方法 替换成协议的方法
extension Frame : myDelegate
{
    func hehehe() {
        
    }
}
//枚举
enum time {
    case spring
    case summer
    case autumn
    case winter
}
//使用枚举的时候吗初次给变量赋值 必须使用枚举名.case名
var timer = time.autumn
//第二次使用的时候 可以直接通过.case名使用
timer = .winter
//switch 搭配 枚举使用
// switch 的value 要填写一个枚举类型的实例变量 case .枚举的case名字
switch timer {
case .spring:
    print("春天")
case .summer:
    print("夏天")
case .autumn:
    print("秋天")
case .winter:
    print("冬天")
}
// 闭包表达式
//闭包名字 : ((参数) -> 返回值类型)
var newPassValue : ((a : Int, b : Int) -> Int)
//第一张闭包表达式的写法
newPassValue = { (a : Int, b : Int) -> Int in
    return a > b ? a : b
}
//第二种写法 苹果推荐写法
newPassValue = { (a, b) -> Int in
    return a > b ? a : b
}
//第三种写法
newPassValue = {
    $0 > $1 ? $0 : $1
}
//第四种写法
newPassValue = { (a , b) in
    return a > b ? a : b
}
//第五种写法
newPassValue = { (a , b) in
    a > b ? a : b
}

关于初学Swift的博客就到这来 之后学到Swift新的内容会及时上传