78-Swift 之关键字的解释
2017-10-27 本文已影响26人
NetWork小贱
引入
在App的开发中，无论是那种开发语言在编写代码的过程中，避免不了和该语言的关键字打交道。有的开发中可能也对之了解很少。今天我们一起在详细的了解一下吧
第一：var 和 let 两个关键字
1、 声明常量与变量的关键字
1、let 常量
2、var 变量
2、注意：
1、let 声明的常量是不可修改的。但是由 let 声明的类，类中的可变参数是可修改的。
2、由let声明一个类B引用由let 声明的类A，则B和A所指向同一个地址。修改一个类会影响另一个类。
3、var 声明变量是可以修改的。由var声明的类A引用由var声明的类B。则 A和B是指向不同的地址。修改一个类不影响另一个类。
3、 测试代码
// TODO:测试一
let person_1 = NewWork小贱()
person_1.age += 1
print("person_1修改后的年龄：",person_1.age)
let person_2 = person_1
person_2.age += 1
print("person_2修改后的年龄：",person_2.age)
print("person_2修改后person_1的年龄：",person_1.age)
// 输出preson_1 和 preson_2的地址
print(Unmanaged.passUnretained(person_1).toOpaque())
print(Unmanaged.passUnretained(person_2).toOpaque())
测试效果
28B43CFB-27B9-4DDF-AB87-ADFC84E0C675.png
4、 变量测试
// TODO: 测试二
var preson_3 = NewWork()
var preson_4 = preson_3
// 修改preson_3 的地址，看是否影响preson_4的地址
preson_3.data = 110
print("preson_3的data数值：",preson_3.data)
print("preson_4的data数值：",preson_4.data)
效果测试
F98147D1-92ED-4C69-AB6C-25A5680497FE.png
第二:class 关键字
class 改关键字是用于声明一个类
1、 代码测试
/*!
class 改关键字是用于声明一个类
*/
class SwiftOcject {
var name = "Swift_OC"
let age = 2
}
// 调用我们声明的类
let Swift = SwiftOcject.init()
print(Swift.age)
print(Swift.name)
效果如下：
2AD48C30-73A0-4DAB-A8D4-4C4AE264CB9B.png
第三： struct 关键字
struct 是Swift结构体声明的关键字
1、代码测试
/*!
struct 是Swift结构体声明的关键字
*/
struct SwiftStruct {
let age = 200
var name = "王小二"
func add() -> Float {
return Float(2 * age)
}
}
// 使用我们创建的结构体
let Struct_1 = SwiftStruct.init()
print(Struct_1.age)
print(Struct_1.add())
print(Struct_1.name)
2、class 与 struct 的区别
1、 class 和 struct 定义类方法时，class 类定义的方法可以被子类重写，而由struct定义的类方法不可以被子类从写。
2、 class 声明的类里的可变对象可以被修改，而struct修饰的结构体内的可变量不可修改。
第四：enum 关键字
enum 是Swift 枚举类型声明的关键字
1、代码测试
enum SwiftType {
case BM_剑魂
case BM_贱人
case BM_逗比
case BM_SB(value:String)
}
print(SwiftType.BM_剑魂)
print(SwiftType.BM_贱人)
print(SwiftType.BM_逗比)
// Swift的基本枚举类型，不会隐式自动赋值。
enum Count:Int {
case OneValue = 0 , TowValue, ThreeValue
}
print(Count.OneValue.hashValue)
print(Count.TowValue.hashValue)
print(Count.ThreeValue.hashValue)
// 要实现Swift的枚举隐式赋值，在创建枚举的时候要给出枚举值的类型，在赋值第一个数值，下面各值就会自动赋值。
效果如下：
364FDB9A-6937-49D1-8A72-182A26DCA189.png
第五：override 关键字
override 在Swift 中是重写一个类方法和属性的修饰关键字.
1、 代码测试
/*！
override 在Swift 中是重写一个类方法和属性的修饰关键字
*/
class Person {
var name:String {
return "王者"
}
func sum(a:Float,b:Float) -> Float {
return a + b
}
}
// 重写 Person 的方法和属性
class NewPerson :Person {
override var name: String {
return "王子"
}
override func sum(a: Float, b: Float) -> Float {
return a * 2 + b
}
}
第六： final 关键字
final 是防止重写一个的方法和属性
1、 代码测试
/*!
final 是防止重写一个的方法和属性
*/
class Name {
final var name :String {
return "肖安"
}
final func add(a:Float)->Float {
return a * 100
}
}
class MyName:Name {
override var name :String {
return "ssss"
}
}
测试结果：
23CC43EA-2015-4396-AC54-2EA04367941F.png
第七： super 关键字
派生类中的方法实现，可以通过super关键字来引用基类的属性和方法。
super不是父类的意思，是编译器的符号，只是告诉去父类找方法或属性，略过当前类不找。
1、测试代码
/*！
super 关键字
派生类中的方法实现，可以通过super关键字来引用基类的属性和方法。
super不是父类的意思，是编译器的符号，只是告诉去父类找方法或属性，略过当前类不找。
*/
class sum {
func addS(a:Float,b:Float) -> Float {
return a + b
}
}
class addSum :sum {
func sm(a:Float) -> Float {
return super.addS(a: a, b: a)
}
}
第八： lazy 关键字
lazy 修饰的变量，只有在第一次调用的时候才去计算其属性。
1、 代码测试
/*!
lazy 关键字
lazy 修饰的变量，只有在第一次调用的时候才去计算其属性。
*/
class Class {
var name = "ss"
lazy var address = name
}
let cl = Class.init()
print(cl.name)
print(cl.address)
/*
1.用lazy修饰的变量必须是用var声明的, 因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
2.如果被lazy修饰的变量没有在初始化时就被多个线程调用, 那就没有办法保证它只被初始化一次了.
*/
第九： init 关键字
init 是Swift构造一个类的关键字
1、 代码测试
/*!
init 关键字
init 是Swift构造一个类的关键字
*/
class MyClass {
var name:String?
init(value:String) {
name = value
}
}
let Myc = MyClass.init(value: "sss")
print(Myc.name)
// 或者
class MyClass_1 {
var name:String?
init?(value:Any) {
name = value as? String
}
}
let myC = MyClass_1.init(value: 100)
print(myC?.name)
2、说明
init? 是指该类可以初始化失败
第十 ：convenient 关键字
convenient 是类快捷初始化关键字。
1、代码测试
/*!
convenient 关键字
convenient 是类快捷初始化关键字
*/
class KJClass {
var name:String?
var address:String?
init(value:String) {
name = value
}
convenience init(value:String,addressValue:String){
self.init(value: value)
address = addressValue
}
}
// 调用
let kjSwift = KJClass.init(value: "ss", addressValue: "ssssccc")
print(kjSwift.address!,kjSwift.name!)
第十一：required 关键字
required 是用于修饰init方法，在创建类时该方法必须实现。
1、代码测试
/*!
required 关键字
required 是用于修饰init方法，在创建类时该方法必须实现。
*/
class requiredClass{
required init(ss:String) {
print("方法调用了")
}
}
// 调用
let requiredc = requiredClass.init(ss: "SS")
print(requiredc)
class required_1:requiredClass {
var name = "sss"
}
let re = required_1(ss: "SS")
print(re.name)
测试效果：
AEB65336-1D8F-4502-B66C-FD6BF267A93F.png
第十二： deinit 关键字
deinit 在Swift中类似dealloc方法。 但有一些区别, dealloc方法是在引用计数为0的时候, 也就是被释放的时候才会调用, 而deinit是在实例不再引用的自动调用, 并且不用手动去管理引用计数。
1、代码测试
/*!
deinit 关键字
deinit 在Swift中类似dealloc方法。 但有一些区别, dealloc方法是在引用计数为0的时候, 也就是被释放的时候才会调用, 而deinit是在实例不再引用的自动调用, 并且不用手动去管理引用计数。
*/
class deinitClass {
var name:String?
init?() {
name = "ssxxx"
}
deinit {
print(name!)
}
}
// 调用
var dclass = deinitClass.init()
print(dclass!.name!)
dclass = nil
// 设置为 nil 的时候就会调用 deinit 方法
print(dclass?.name! as Any)
第十三：is 关键字
is Swift 用于类型对比
1、代码测试
/*!
is 关键字
is Swift 用于类型对比
*/
class isClass {
func equale(value:Any) {
if value is Float {
print("我是数字")
}
if value is String {
print("我是字符串")
}
}
}
// 调用
let iss = isClass.init()
iss.equale(value: "ssss")
第十四：extension 关键字
extension 是在不改变原来类的方法和协议，来个方法同添加属性和方法
1、扩展代码
/*!
类的扩展
*/
extension String {
var length :CGFloat {
return CGFloat(self.characters.count)
}
func lengthSize() -> CGFloat {
return CGFloat(self.characters.count)
}
}
2、测试代码
/*!
extension 关键字
extension 是在不改变原来类的方法和协议，来个方法同添加属性和方法
*/
// 通过extension 扩展来获取字符串的长度
print("ssss".length,"sssscccc".lengthSize())
第十五：typealias 关键字
typealias 是领取别名，也叫命名空间。
1、代码测试
/*!
typealias 关键字
typealias 是领取别名，也叫命名空间。
*/
typealias MyInt = Int
let a_value :MyInt = 100
print(a_value)
第十六：fallthrough 关键字
fallthrough Swift fallthrough 语句让 case 之后的语句会按顺序继续运行，且不论条件是否满足都会执行。fallthrough 一般不使用。
1、测试代码
/*!
fallthrough 关键字
fallthrough Swift fallthrough 语句让 case 之后的语句会按顺序继续运行，且不论条件是否满足都会执行。fallthrough 一般不使用。
*/
switch 100 {
case 80:
print("80")
fallthrough
case 100:
print("100")
fallthrough
case 200:
print("200")
fallthrough
default:
print("1000")
}
