Swift-类和结构体

A 类和结构体对比
B 类和结构体的选择

类和结构体是人们构建代码所用的一种通用且灵活的构造体，为了类和结构体中实现各种功能，我们必须要严格按照常量，变量重点内容以及函数所规定的语法来定义属性和添加方法。

与其他编程语言所不同的是，Swift并不要求你为自定义类和结构体去创建独立的接口和实现文件，你只需自定义一个类或者结构体，系统将会自动生成面向其他代码的尾部接口

类和结构体对比
Swift中类和结构体由很多共同点。
※定义属性用于存储值
※定义方法用于提供功能
※定义附属脚本用于访问值
※定义构造器用于生成初始化值
※通过扩展以增加默认实现的功能
※复合协议以对某类提供标准功能

与结构体相比，类还有如下的附加功能：

※继承允许一个继承另一个类的特征
※类型转换允许在运行是检查和解释一个类实例的类型
※结构怄气允许一个类实例释放任何其所被分配的资源
※引用计数允许对一个类的多次引用
    注意：结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数

类和结构体的定义：
结构体用struct定义以及使用

//声明一个协议，只做方法的声明
//如果协议里面有可选方法，就需要在该协议前面加上 @objc
//Swift中结构体只能遵守必须执行的协议，如果一个协议中又可选协议的方法，只能用类去实现

//@objc
protocol proMethodDelegate{
    //默认是必须执行的
    func proMethod()->String
    //可选方法
//    optional func proOptionalMethod()->String
}

//定义一个点的结构体
struct Point {
    var x = 0
    var y = 0
}
//定义一个Size的结构体
struct Size {
    var width = 0
    var height = 0
}
//定义一个Frame的结构体
struct Rect:proMethodDelegate {

    //1 属性
    var Origin = Point()
    var size = Size()

    //构造函数(就是OC里面的初始化方法)
    //2 为该结构体创造一个构造函数
    init(x:Int,y:Int,w:Int,h:Int){
        self.Origin.x = x;
        self.Origin.y = y;
        self.size.width = w;
        self.size.height = h;
        print("创建一个Rect对象")
    }

    //3 在Rect结构体内定义一个静态方法(和OC中的类方法一样)要用static修饰
    static func classMathed(){
        print("这是一个结构体的类方法")
    }

    //4 结构体可以实现协议方法
    func proMethod() -> String {
        return "这是一个结构体实现的协议方法"
    }
}
//结构体的使用
var r:Rect = Rect(x: 10, y: 10, w: 100, h: 100)
print(r)     
//-输出-->创建一个Rect对象,Rect(Origin: Swift_2.Point(x: 10, y: 10), size: Swift_2.Size(width: 100, height: 100))
//结构体调用结构体的类方法
Rect.classMathed()   //--->这是一个结构体的类方法
print(r.proMethod())   //---->这是一个结构体实现的协议方法

类用class来定义以及类的使用

//在swift中也是单继承，但并不是所有的类都要继承于NSObject
//没有继承的类，表示是基类

class Person {
    /*
    swift中属性有三种
    1，存储属性：就是用来保存某个值使用的，很类似于OC的实例变量
    2，计算属性：专门用来处理属性数据的运算
    3，类属性：用类直接调用的属性
    */

    //1 存储属性
    var name:String
    var age = 20
    var chinese = 0
    var math = 0
    var English = 0
    //延迟储存属性 (懒加载)
    lazy var f:file = file()   //在属性前面加 lazy 表示懒加载

    //2 计算属性
    //计算属性一定是变量
    //计算属性一定会重写set或get方法
    var sum:Int{
        get{
            return chinese+math+English
        }
        set(newValue){
            print("newValue的值为\(newValue)")
        }
    }
     //3 类属性
    //类属性只能是计算属性
    class var cVar:String{
        get{
            return "这是一个人的类属性"
        }
    }

    //******** 方法 *********//
    //seift中所有属性都必须赋初始值，如果在类里面声明属性的时候没有初始值，那么在构造函数中就必须初始化。如果有多个初始化方法，那么每个初始化方法都要对没有赋值的属性进行赋值，例如：name这个属性
    //默认的构造函数(初始化方法)
    init(){
        self.name = ""
        print("这是默认的初始化方法")
    }
    //方法的重载：OC中没有这个概念，借鉴的java和C++里面的概念

    //方法名一样，只是参数不同（参数名和参数个数都不一样）
    //自定义构造函数
    init(name:String,age:Int){
        //在swift中不用写return
        self.name = name
        self.age = age
    }

    //遍利构造器(实质上还是调用正常的构造函数),就是在正常的构造函数前面加了一个convenience关键字
    convenience init(Name:String,Age:Int){
        self.init(name:Name,age:Age)
    }

    //析构函数：类似一OC里面的dealloc方法
    deinit{
        print("人死了")
    }

    //
    func sleep(){
        print("这是一个人在睡觉")
    }
}

//文件类
class file {
    init(){
        print("这是一个很大的文件")
    }
}

var p = Person()
//属性访问   使用点语法为属性赋值
p.chinese = 80
p.math = 60
p.English = 80

//方法的访问
print(p.sum)

//类属性的访问
p.sum = 100
print("*-*******",Person.cVar) //-->*-******* 这是一个人的类属性
//便利构造器的调用
var p1 = Person(Name: "gang", Age: 25)
print(p1.name)       //-->gang

func text(){
    _ = Person()
}
print("*****************函数调用前*********************")
text()  //--->这是默认的初始化方法 ,  人死了
print("*****************函数调用后*********************")

面向对象

class Man: Person {
    //override：重写父类方法的关键字，子类的初始化方法会先调用super指针为其创建一个父类对象
    override init() {
        super.init()
        print("这是一个男人的初始化方法")
    }

    //子类重写父类方法，优先调用子类里面的方法
    override func sleep() {
        print("这是一个男人在睡觉")
    }

    func eat(){
        print("这是一个男人在吃饭")
    }
}
var m = Man()
m.sleep()

多态

//多态：父类指针指向子类对象
//因为子类里面可以添加自己的方法，相比于父类来说子类里面的方法和属性会更丰富，所以父类能指向的范围比较小，而子类指针的范围比较大，一个小范围的指针，指向大范围，肯定不会溢出范围，只是有些范围指不到而已。但是如果大范围的指针，指向小的区域就有可能，指向小区域以外的东西，从而找不到想要的内容，引起程序崩溃，所以子类指针指向父类对象，在oc语法上没有错误（swift中直接语法报错）， 但是有以上隐患，所以我们只把多态看做是父类指针指向子类对象。
class Woman: Person {
    override func sleep() {
        print("这是一个女人在睡觉")
    }
    func eat(){
        print("这是一个女人在吃饭")
    }
}
//Woman对象
var w = Woman()
w.sleep()

print("~~~~~~~~~~~~~多态~~~~~~~~~~~~~~~~~")
// 父类指针指向子类对象
var p4:Person = Woman()
p4.sleep()

延展
OC中 延展里面可以象一个类里面添加属性，方法和实例变量
在swift中只能添加方法

extension Woman{
    func wash(){
        print("这是一个女人在洗衣服")
    }
}
w.wash()