Lesson_Swift_Class_Struct

// Playground - noun: a place where people can play

import UIKit


//使用关键字class和struct来分别表示类和结构体

struct SomeStruct {
    
}

class SomeClass {
    
}


struct Length {
    //在swift中可以对变量初始化
    var start: Float = 0.0
    var end: Float = 0.0
    
    //在swift中可以定义方法
    func calLength () {
        println(end - start)
    }
}


//调用默认的构造器 init
var length = Length()
length.start = 10
length.end = 20

length.calLength()

//逐一构造器,只有结构体才有,类是没有的
var length2 = Length(start: 2, end: 15)
length2.calLength()


//定义类
class Car {
    var name: String?
    
    func printName() -> String {
        return name!
    }
}

var car = Car()
car.name = "法拉利🚗"
car.printName()


// 权限控制
// public    公共的
// private   私有的
// internal  内部的


//TODO
class Permission {
    var guozhong: String?
    private var qiaodaye: String?
    internal var xiangwang: String?
}

var permission = Permission()
permission.guozhong = "国中"
permission.qiaodaye = "乔大爷"
permission.xiangwang = "祥望"


//构造器
class ZS {
    var name: String?
    
    //默认构造器
    init() {
        name = "张帅"
    }
    
    //自定义构造器
    init(name: String) {
        self.name = name
    }
    
    //析构方法
    deinit {
        
    }
}

var zs = ZS()
zs.name!

var zs1 = ZS(name: "张帅2")
zs1.name!


//属性
//1.存储属性
struct Point {
    var x = 0.0
    var y = 0.0
}

struct Size {
    var width = 0.0
    var height = 0.0
}

//2.计算类型,不直接存值,提供了一个getter方法来获取值,提供了一个setter方法来设置新的值
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = self.origin.x + self.size.width / 2
            let centerY = self.origin.y + self.size.height / 2
            return Point(x: centerX, y: centerY)
        }
        
        set(newCenter) {
            origin.x = newCenter.x - size.width / 2
            origin.y = newCenter.y - size.height / 2
        }
    }
    
    //使用mutating关键字来修饰,可以修改属性的值
    mutating func calCenter() {
        self.center = Point(x: self.origin.x + self.size.width / 2, y:self.origin.y + self.size.height / 2)
    }
    
    init(x: Double, y: Double, width: Double, height: Double) {
        self.origin.x = x
        self.origin.y = y
        self.size.width = width
        self.size.height = height
    }
}

var rect = Rect(x: 10, y: 20, width: 200, height: 150)

var rect1 = Rect(x: 100, y: 100, width: 100, height: 100)
rect1.center
rect1.center = Point(x: 200, y: 200)


//类型属性
//在结构体中使用static来声明类方法和类属性
//在类中使用class来声明类方法

struct Stu {
    static var xiaoming = "小明"
    
    static func sayHi() {
        println("Hi")
    }
}

Stu.xiaoming
var stu = Stu()
Stu.sayHi()

class Stu1 {
    var xiaoming = "小明"
    class func sayHi() {
        println("Hi")
    }
}

Stu1.sayHi()


//结构体是值类型
//值类型被赋予给一个变量,常量或者本身被传递给一个函数的时候,实际上操作的是其的拷贝

length
let length1 = length

length.start = 20
length.end = 30

length1


//类是引用类型
//引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的是已存在的实例本身而不是其拷贝


car
let car1 = car
car.name = "玛莎拉蒂🚗"
car1


//类跟结构体的选择
//按照通用的准则:当符合以下七种一条或者多条时,请考虑使用结构体
//1.结构体的使用目的:用来封装尽量少的简单数据
//2.结构体拷贝的时候,属于值拷贝
//3.任何在结构体中存储的值类型属性都会被拷贝而不是引用
//4.结构体无需去继承另一个已存在的类型的属性或者行为


//练习
struct Student {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func printStudentInfo() {
        println("name:\(name), age:\(age)")
    }
    mutating func changeName (newName: String) {
        self.name = newName
    }
    
    static func printStudentSorry() {
        println("I'm sorry!")
    }
}

var stu3 = Student(name: "别人家的孩子", age: 18)
stu3.changeName("乔明")

stu3.printStudentInfo()

Student.printStudentSorry()


class Teacher {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func printTeachInfo() {
        println("name:\(name), age:\(age)")
    }
    
    class func printTeachSorry() {
        println("I'm sorry!")
    }
}

var teacher = Teacher(name: "你妹", age: 20)
teacher.printTeachInfo()
Teacher.printTeachSorry()



//=======================================
class Person {
    var identify = "Person"
    var name: String?
    var sex: String?
    let age: Int?
    //定义变量/长粮食,可以不对其初始化,但是一定要在构造方法中进行初始化
    init(name: String, sex: String) {
        self.name = name
        self.sex = sex
        self.age = 25
    }
    
    deinit {

    }
    
    func personInfo() {
        println("name=\(name!), sex=\(sex!), age=\(age!)")
    }
    
    class func PersonInfo() -> String {
        return "他是个人"
    }
    
    class var xiang: String {
        get {
            return "飞翔✈️"
        }
        set(newXiang) {
            self.xiang = newXiang
        }
    }
    
}

var person = Person(name: "乔明", sex: "女")
person.personInfo()

Person.xiang

var personA = Person(name: "豆豆", sex: "男")
var personB = Person(name: "快递妹", sex: "女")
personA.personInfo()
personB.personInfo()


class Coder: Person {
    override init(name: String, sex: String) {
        super.init(name: name, sex: sex)
        self.identify = "Coder"
    }
    
    override func personInfo() {
        println("我是一个悲伤地Coder" + "😢")
    }
}

var coder: Person = Coder(name: "程序猿🐒", sex: "不明")
coder.personInfo()


if coder is Coder {
    println("Coder")
} else {
    println("Person")
}


//协议
protocol aProtocol {
    func funcOne()
}

//结构体遵守协议
struct aStudent: aProtocol {
    func funcOne() {
        println("结构体,协议")
    }
}

//类遵守协议
class aClass: aProtocol {
    func funcOne() {
        println("类,协议")
    }
}

//类既有父类又遵循某种协议
class bClass: Person, aProtocol {
    func funcOne() {
        println("类,协议")
    }
}

//声明一个协议,如果里面有optional,需要在protocol前面加@objc
@objc protocol bProtocol {
    func funcA()
    optional func funcB()
}

class cClass: bProtocol {
    func funcA() {
        println("")
    }
}