面向对象的核心是类和对象，面向对象的三大特征：封装，继承和多肽。swift可以定义枚举，结构体和类三种面向对象的实例，支持定义存储属性，计算属性，方法，下标，构造器和嵌套类型
这次说的是枚举，结构体和类的相关知识
枚举
//用于管理一组有限值的集合
/*
swift 定义枚举的语法格式
enum 枚举名 ｛
//使用case关键字列出所有的枚举值
//枚举的其它成员
｝
*/
//定义枚举
enum season {
case spring
case summer
case fall
case winter
}
//1.使用一个case来列举所有的值
enum season2 {
case spring, summer, fall, winter
}
//2.使用枚举来声明变量
var weather: season
weather = season.spring//或者表示称.spring
print(weather)
//枚举和swift语句之间的联系
var chooseday = season.fall
switch chooseday{
case .spring :
print("春天")
case .summer :
print("夏天")
case .fall :
print("秋天")
default :
print("在家")//若是列出了season所有的枚举值，default可以省略
}
//为每一个枚举值赋值，即为原始值
/*
原始值的语法格式：
enum 枚举值 ： 原始值类型 ｛
case 枚举值 ＝ 原始值
｝
在swift中不需要为每个枚举值指定原始值，它可以根据已经存在的原始值推断出前后的枚举值的原始
值。这是用于原始值是整形的情况，如果原始值是字符串，或者是字符，就需要完全指定原始值。
*/
enum weekday: Int {
case mon , tur , wen = 3,thur, fri , sat , sun
}
enum season3 : Character {
case spring = "春"
case summer = "夏"
case fall = "秋"
case winter = "冬"
}
//获取枚举中的原始值
print(weekday.fri.rawValue)//rawValue获取原始值
//如何根据原始值获取枚举值
var myseason = season3(rawValue: "春")
if myseason != nil {
switch (myseason) {
// case .spring :
// print("春天")
// case .summer :
// print("夏天")
default :
print("")
}
}
//为枚举成员定义关联值
/*
swift不要求每一个成员拥有相同的关联值
使用枚举值的时候也要指定她的关联值
*/
enum planet {
case earth(weight: Double , name: String)
case mars(density: Double , name: String, weight: CGFloat)
case venus(Double , String)
case saturn
case neptune
}
var p1 = planet.earth(weight: 1.0, name: "地球")
var p2 = planet.venus(0.815, "金星")
var p3 = planet.mars(density: 3.0, name: "火星", weight: 0.1)
//获取关联值
switch (p3) {
//将关联值绑定到变量或者常量来提取
case planet.earth(var weight , var name):
print(weight, name)
//将关联值都提取为常量或者变量，直将一个var或者let放置枚举成员之前
case let planet.mars(density: d, name : n, weight: w):
print(d,n,w)
default:
break
}
类和结构体
//类和结构体
/*
定义类和结构体，创建实例，值类型与引用类型。
类和结构体是很相似的，区别就是：结构体不支持继承，不支持定义构造器。
*/
//类
/*
[修饰符]class 类名｛
0到多个构造器//初始化方法
0到多个属性
0到多个方法
0到多个下标
｝
修饰符可以是 private public internal final
*/
/*
定义结构体的语法
［修饰符］struct 结构体名｛
｝
修饰符可以是 private public internal final
*/
/*
存储属性的语法
[修饰符]var 或者 let 存储属性名：类型名字 ＝ 初始值
*/
/*
定义构造器的语法
[修饰符] init(形参列表)｛
0到多行可执行语句组成的构造器执行体
｝
*/
/*
定义方法的语法
[修饰符]func 方法名（形参列表）-> 返回值类型 ｛
//0到多行可执行语句
｝
*/
//定义一个person类
class person {
var name : String = "jack"
var age : Int = 0
func say (content: String){
print(content)
}
}
struct dog {
var name : String
var age : Int
func run(){
print("")
}
}
//创建person类的实例,它是引用类型
var p: person
p = person()//var p = person()，p只是一个引用变量，并没有包含响应的属性数据
print(p.name)
p.say(content: "hello swift")
//创建结构体的实例,它是值类型
var dog1 = dog(name: "玩彩", age: 12)
print(dog1.name)
//内存中的对像可以有多个引用，即多个引用变量指向同一个对象
var p2 = p
p2.name = "rose"
print(p.name)
//值类型，创建dog实例时，这个变量就存储了dog实例;
//若是把dog实例赋给另外一个变量，系统会将dog实例进行复制，不会影响原有的变量
var dog2 = dog1
dog2.name = "snoppy"
print(dog2.name)
print(dog1.name)
如何选择类和结构体
/*
了解引用类型的比较
self关键字的使用
类和结构体的选择
*/
//引用类型的比较
class user {
var name : String
var age : Int
init (name :String , age : Int){
self.name = name
self.age = age
}
}
var u1 = user(name : "han",age: 32)
var u2 = user(name : "han",age: 32)
//通过运算符比较是否指向同一个类型的实例，返回Bool变量
print(u1 === u2)
print(u1 !== u2)
var u3 = u1
print(u3 === u1)
//self关键词
/*
1.构造器中的self代表该构造器正在初始化的实例
2.方法中的self代表该方法的调用者
*/
class dog {
func jump(){
print("正在执行jump方法")
}
func run(){
self.jump()
print("正在执行run")
}
}
class person {
var name : String = ""
var age : Int = 2
//显示定义带参数的构造器
init(name: String, age : Int){
self.name = name
self.age = age
}
//定义一个info方法
func info (){
print("\(name),\(age)")
}
}
var person1 = person(name: "lily", age: 12)
person1.info()