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()

最后

以上就是现代小丸子为你收集整理的Swift-类和结构体的全部内容，希望文章能够帮你解决Swift-类和结构体所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。