接下来就讨论一下可选链，类型属性和类型方法，构造器
1.可选链是用于处理可选类型的属性，方法和下标
2.使用可选链代替强制解析
3.调用方法
4.调用下标
//创建3个关联类
class customer{
var name = ""
var emp: employee?
init(name: String){
self.name = name
}
}
class company {
var name = ""
var addr = ""
init(name: String , addr: String){
self.name = name
self.addr = addr
}
}
class employee{
var name = ""
var title = "行政"
var company: company!
init(name: String, title: String){
self.name = name
self.title = title
}
func info() {
print("本员工名为\(self.name),职位为\(self.title)")
}
}
var c = customer(name: "tom")
var emp = employee(name: "jack", title: "student")
//设置customer关联的employee实例
c.emp = emp
//设置empoyee关联的compony实例
emp.company = company(name: "swift", addr:"shanghai")
print("为\(c.name)服务的公司是：\(c.emp!.company.name)")
//第二种情况
var c2 = customer(name: "lucky")
//设置customer关联的employee实例
c2.emp = employee(name:"helly", title: "客服")
//print(c2.emp!.company.name)//此时是没有为company赋值的，它的值为nil.为此使用可选链访问属性
//使用可选链访问属性
/*
可选链的访问方式：将强制解析的！换成？，即是是隐式解析后面也要添加？
*/
print(c2.emp?.company?.name)//输出为nil
//可选链会自动防伪关联属性的可选情况，自动判别是否为nil
通过可选链来访问方法和下标
首先做可选链访问方法
//创建3个关联类
class customer{
var name = ""
var emp: employee?
init(name: String){
self.name = name
}
//定义一个常量类型的employee数组，用于模拟系统中所有的员工
let employees = [employee(name: "张三" , title: "销售"),
employee(name: "小明" , title: "售后"),
employee(name: "han" , title: "普通员工"),
employee(name: "better" , title: "销售主管")
]
//定义一个方法，该方法可根据员工名返回对应的员工，返回值为可选类型
func findemp(empname: String) -> employee!{
for emp in employees{
if emp.name == empname {
return emp
}
}
return nil
}
}
class company {
var name = ""
var addr = ""
init(name: String , addr: String){
self.name = name
self.addr = addr
}
}
class employee{
var name = ""
var title = "行政"
var company: company!
init(name: String, title: String){
self.name = name
self.title = title
}
func info() {
print("本员工名为\(self.name),职位为\(self.title)")
}
}
//通过可选链来调用方法
var c3 = customer(name: "paul")
c3.findemp(empname: "张三")?.info()
c3.findemp(empname: "小明")?.info()
可选链访问下标
//可选链访问下标
var dict = [Int : customer]()
dict[1] = customer(name: "han")
dict[2] = customer(name: "angle")
dict[1]?.findemp(empname: "better")?.info()
dict[4]?.findemp(empname: "better")?.info()
类型属性和类型方法
值类型的类型属性
//1.值类型的类型属性
enum season {
//为枚举定义类型存储属性，使用可选类型，系统将其初始化为nil
static var desc : String?
//为枚举定义类型存储属性，且声明为常量
static let name = "季节"
static var info: String{
get{
return "代表季节的枚举，其desc为：\(desc)"
}
set{
print("程序尝试对info计算属性进行赋值：\(newValue)")
}
}
}
//对season枚举的类型属性赋值
season.desc = "季节类"
print(season.name)
season.info = "新的info"
print(season.info)
//结构体可以包含实例计算属性，不能包含实例存储属性
struct fkrange{
//为结构体定义类型存储属性，使用可选类型，系统将其初始化为nil
static var desc : String?
//为结构体定义类型存储属性，且声明为常量
static let maxwidth = 10000
static let maxheight = 40000
//定义类型计算属性，该属性只有get部分，是一个只读属性
static var maxarea: Int{
return maxwidth * maxheight
}
}
fkrange.desc = "描述范围的结构体"
print(fkrange.desc)
print(fkrange.maxwidth)
print(fkrange.maxheight)
print(fkrange.maxarea)
class在类中修饰属性和方法
类的属性：
//类的类型属性
class user{
//为类定义类型计算属性
class var namemaxlength: Int {
get{
return 24
}
set{
print(newValue)
}
}
}
print(user.namemaxlength)
user.namemaxlength = 20
//类中不可以定义类型存储属性，只能包含类型存储属性
值类型的类型方法
//值类型的类型方法
enum season2{
//为枚举定义类型存储属性，使用可选类型，系统将其初始化为nil
static var desc : String?
//为枚举定义类型存储属性，且声明为常量
static let name = "季节"
//定义无参数的类型方法
static func info(){
print("季节类的info方法")
}
//定义一个带参数的类型方法
static func setdesc(desc : String){
self.desc = desc
}
}
season2.info()
season2.setdesc(desc: "季节变化的枚举")
print(season2.desc)
类的类型方法：
//类的类型方法
class math{
//类中不允许定义类型存储属性，使用类型计算属性代替
class var pi: Double{
return 3.1415
}
class func abs(value: Double) -> Double{
return value < 0 ? -value : value
}
//定义类型方法，取消第二个形参的外部形参名
class func pow(base: Double, _ exponet: Int) -> Double{
var result = 1.0
for idx in 1...exponet{
result *= base
}
return result
}
//定义类型方法，类型方法可以直接访问类型属性
class func radian2degree(radian: Double) -> Double{
return radian*180 / pi
}
//定义类型方法，类型方法可通过self应用类型属性
class func degree2radian(degree: Double) -> Double{
return degree * self.pi / 180
}
}
print(math.pi)
print(math.pow(base: 2, 5))
print(math.radian2degree(radian: 1.3))
print(math.degree2radian(degree: 1.2))
构造器
1.swift构造器构造出来的实例有系统隐式返回
2.构造器的作用完成结构体和类实例存储属性的初始化
3.为实例存储属性赋初值的时机：
1>定义实例存储属性时赋初始值
2>在构造器中为实例存储属性赋初始值
实例存储属性的初始化分类：
1>定义实例存储属性时，显示指定了初始值
2>实例存储属性的类型为可选类型
3>系统提供的默认构造器为实例存储属性提供初始值
4>显示提供的构造器为实例存储属性提供初始值
类和结构体的构造器
swift只为类提供一个无参数的构造器
swift为结构体提供2个构造器：无参数的构造器和初始化所有实例存储属性的构造器
可能失败的构造器
结构体，枚举或者是类不能成功返回这个类型的实例。如：用户传入的参数不对，会让构造器的创建失败，而此时就需要可能失败的构造器
1.使用init?或者init!来进行定义
2.在构造器执行体中return nil 标示构造器失败
3.swift不允许构造2个形参列表的构造器，即是一个是可能失败的构造器，一个是普通的构造器也不行。
构造器的外部形参名
//构造器的外部形参名
struct fkpoint{
var left: Int = 0
var top: Int = 0
//定义带两个参数的构造器，并为第二个参数显示指定外部形参名
init(left: Int , y top: Int){
self.left = left
self.top = top
}
}
var p1 = fkpoint(left: 20, y: 12)
取消构造器的外部形参名
//取消构造器的外部形参名
class person {
var name: String?
var gender: String?
var age = 0
//由于该类中前2个实例存储属性使用了可选类型，后一个存储属性指定了初始值
//因此该结构体对构造器没有要求，故此处可以随便定义构造器
//取消构造器参数的外部形参名
init(_ name: String, _ gender: String){
self.name = name
self.gender = gender
}
}
//调用构造器时无需要使用外部形参名
var p = person("虽无空", "南")
print(p.name)
在构造过程中，使用闭包初始化存储属性
//使用闭包或函数为属性设置初始值
struct closureinit {
//使用闭包对test实例属性执行初始化
var test: Int = {
var dt = NSDate()
var gregorian = NSCalendar.current
//定义一个时间字段的旗标，指定将会获取指定月日的信息
var unitflags = NSCalendar.Unit.month | NSCalendar.Unit.day
var comp = gregorian.component(unitflags, from: dt)
//获取当前的月份
var month = Int(comp.month)
return month
}()
}
值类型的构造器重载
//值类型的构造器重载
struct constructoroverload {
var name: String?
var amount: Int?
//提供无参数的构造器
init(){}
//提供带两个参数的构造器来完成构造过程
init(name: String, amount: Int){
self.name = name
self.amount = amount
}
}
//通过无参数构造器创建constructoroverload实例
var oc1 = constructoroverload()
//通过有参数构造器创建constructoroverload
var oc2 = constructoroverload(name: "swift", amount: 8000)
print(oc1.name)
print(oc2.name)
构造器代理
在定义构造器时，通过self,init(实参)来调用其它构造器，来完成实例的部分构造过程
//构造器代理
struct apple{
var name: String
var color: String
var weight: Double!
init(_ name: String , _ color: String)
{
self.name = name
self.color = color
}
//两个参数的构造器
init(name: String, color: String){
self.init( name, color)
}
//为构造器显示指定外部形参名
init(applename n: String, applecolor c: String){
self.init(n, c)
}
}
//可能失败的构造器
//可能失败的构造器
struct cat {
let name: String
init?(name: String){
//如果传入的name参数为空字符串，构造器失败，返回nil
if name.isEmpty {
return nil
}
self.name = name
}
}
enum season {
case spring, summer, autumn, winter
//使用init!定义可能失败的构造器，则改构造器创建的实例可以进行隐式解析
init!(name: Character){
switch name {
case "s":
self = .spring
case "u":
self = .summer
case "a":
self = .summer
case "w":
self = .winter
default:
return nil
}
}
}
