Swift 类与结构体的使用

//
//  ClassesStructures.swift
//  SwiftCode
//
//  Created by Alisa on 2022/4/5.
//  Copyright © 2022 Alisa. All rights reserved.
//

import Foundation
import UIKit

/*
** 关于结构体：
    在swift语言中，结构体时功能仅逊于类的数据结构
    在oc中，结构体中只可以定义属性，而不能定义方法，而在swift中，结构体与类十分相似，其中既可以定义属性，又可以定义方法，但其不像类一样具有继承的特性。
    结构体中可以声明变量或者常量作为结构体的属性，也可以创建函数作为结构体的方法，结构体使用点语法来调用其中的属性和方法。
 
    结构体的使用场景：
        要描述的数据类型中只有少量的简单数据类型的属性
        要描述的数据类型在传递数据时需要以复制的方式进行
        要描述的数据类型中的所有属性在进行传递时需要以复制的方式进行
        不需要继承另一个数据类型
 
    
** 关于类：
    继承是类独有的特点，子类和父类通过继承关系进行关联，并且子类可以对父类进行扩展。
    子类对父类的方法进行覆写，需要使用override关键字声明，覆写的意义是将继承于父类的方法进行新的实现
    在子类的方法中，调用父类的方法使用super关键字
    swift语言中还提供了一个final关键字，final关键字用于修饰某些终极的属性、方法或者类。被final修饰的属性和方法不能够被子类覆写
    不希望某个类被继承也可以使用final来修饰class
 
    类的使用场景：
        
 
**类与结构体的区别：
    <1> 结构体是值的类型，类是引用的类型
    <2> 在结构体中开发者并不需要提供构造方法，结构体会根据属性自动生成一个构造方法，而类则要求开发者自己提供构造方法，在init()构造方法中，需要完成对类
        中所有属性的赋值操作
    <3> 类可以继承，但结构体不可以继承
  
 
**知识点的扩展：
    swift语言中，数据类型分为两种：值类型、引用类型
    值类型：结构体、枚举等，以及其它所有除了类以为的数据类型，都属于值类型
    引用类型：类
    值类型与引用类型的区别
        <1>当进行数据传递时，值类型总是被复制，而引用类型不会被复制，引用类型是通过引用计数来管理生命周期的
        <2>如果要对值类型进行比较操作使用"=="运算符，对引用类型进行比较操作，应使用等同运算符“===”
    
*/



//使用struct关键字来定义结构体
struct Car{
    
    //价格
    var price:Int
    //品牌
    var brand:String
    //油量
    var petrol:Int
    //提供一个行路的方法
    mutating func drive(){
        if petrol > 0{
            petrol -= 1
            print("drive 10 milo")
        }
    }
    //提供一个加油的方法
    mutating func addPetrol(){
        petrol += 10
        print("加了10单位油")
    }
}

//swift中类使用关键字class来声明，使用类的方式来模拟汽车类型
class BaseCar : NSObject {
    //价格
    var price:Int
    //品牌
    var brand:String
    //油量
    var petrol:Int
    //提供一个行路的方法
    func drive(){
        if petrol > 0{
            petrol -= 1
            print("drive 10 milo")
        }
    }
    //提供一个加油的方法
    func addPetrol(){
        petrol += 10
        print("加了10单位油")
    }
    
    //提供一个构造方法
    init(price:Int, brand:String, petrol:Int){
        self.price = price
        self.brand = brand
        self.petrol = petrol
    }
}

//设计一个交通工具类
class Transportation{
    //油量，默认提供10
    var petrol:Int = 10
    //提供一个行驶的方法
    func drive(){
        //具体由子类实现
        if petrol == 0{
            self.addPetrol()
        }
    }
    //提供一个加油方法
    func addPetrol(){
        petrol += 10
    }
}
//继承于Transportation类的子类
class Boat:Transportation{
    //不同大小的轮船有不同的层数，为轮船提供一个层数的属性
    var floor:Int
    override func drive() {
        super.drive()
        print("轮船在海上行驶了50km")
        self.petrol -= 2
    }
    init(floorCount:Int) {
        floor = floorCount
    }
}
class Airplane:Transportation{
    //不同的飞机有不同的行驶高度，为飞机提供一个行驶高度的属性
    var height:Int
    //对父类的方法进行重写
    override func drive() {
        super.drive()
        print("在天上行驶了100km")
        self.petrol -= 5
    }
    init(height:Int) {
        self.height = height
    }
}

class ShapeBase{
    final var center:(Double, Double)
    final func drawSay(){
        print("The final method draw say")
    }
    init(){
        center = (0, 0)
    }
}

//final的使用
class ShapeSub : ShapeBase{
    
    var height = 0.0;
    //不能重复声明
    //var center:(Double, Double)     //Cannot override with a stored property 'center'
    //不能覆写父类中使用final修饰的方法
    //override func drawSay(){}   //Instance method overrides a 'final' instance method
    init(height:Double) {
        self.height = height
    }
}

//这个类不可以被继承
final class NoSub{
    var preName = "no sub class"
}

class ClassesStructs{
    
    //结构体的初始化与简单使用
    func structInitWork(){
        
        //在创建结构体后，结构体会默认生成一个构造方法供开发者使用，开发者可以在构造方法中完成完成对结构体的实例化
        var car = Car(price: 2000, brand: "奔驰", petrol: 10)
        print("这辆\(car.brand)汽车价格\(car.price),油量\(car.petrol)")
        //模拟汽车行路行为
        for _ in 0...100{
            if car.petrol == 0{
                //如果油量为0时，进行加油
                car.addPetrol()
            }
            else{
                //进行行路行为
                car.drive()
            }
        }
        
        //结构体是值的类型，如果值类型有数据传递，原来的实例会被复制一份，修改新的实例并不能修改原始的实例
        var car2 = car
        car2.price = 5000
        print("值传递后这辆\(car.brand)汽车价格\(car.price),油量\(car.petrol)")
        //可以看到还是原来的值：值传递后这辆奔驰汽车价格2000,油量8
    }
    
    //类的初始化与简单使用
    func classInit(){
        
        let car = BaseCar(price: 45000, brand: "宝马", petrol: 100)
        print("class:这辆\(car.brand)汽车的价格\(car.price), 油量\(car.petrol)")
        
        //创建另一个变量进行值的传递
        let car2 = car
        car2.price = 55000
        print("class:值传递后：这辆\(car.brand)汽车的价格\(car.price), 油量\(car.petrol)")
    }
    
    //类的继承
    func inheritClassWork(){
        
        //创建轮船
        let boat = Boat(floorCount: 3)
        //创建飞机
        let plane = Airplane(height: 3000)
        
        //调用父类的drive方法
        boat.drive()
        plane.drive()
    }
}