Swift -4 面向对象基础(上)

枚举

定义枚举

/*Swift定义枚举的语法格式

    enum 枚举名{
        // 使用case关键字列出所有的枚举值
        // 枚举的其他成员
}
*/

// 定义枚举
enum Season {
    case Spring
    case Summer
    case Autumn
    case Winter
}

使用一个case列举所有的值

enum Season2 {
    case Spring, Summer, Autumn, Winter
}

使用枚举声明变量

var weather: Season
weather = .Summer
print(weather)

枚举值和Switch语句

var chooseDay = Season.Autumn
// 使用switch语句判断枚举值
switch(chooseDay) {
case .Spring:
    print("春天来了")
case .Summer:
    print("夏天来了")
default:
    print("还是在家吧")
}
// switch中的case没有覆盖枚举的所有值,必须添加default语句

原始值

/*
enum 枚举名: 原始值类型{
    case 枚举值 = 原始值
}
*/
enum Weekday: Int {

    case Mon, Tur, Wen = 3, Thur, Fri, Sat, Sun
}

enum Season3: Character {
    case Spring = "春"
    case Summer = "夏"
    case Autumn = "秋"
    case Winter = "冬"
}
// rawValue 获取原始值
print(Weekday.Fri.rawValue)
var mySeason = Season3(rawValue: "春")
if mySeason != nil {

    switch(mySeason!) {

    case .Spring:
        print("春天来了")
    case .Summer:
        print("夏天来了")
    case .Autumn, .Winter:
        print("秋天还是冬日一起来了")
    }
}

关联值

enum Planet {
    case Earth(weight: Double, name: String)
    case Mars(density: Double, name: String, weight: Double)
    case Venus(Double, String)
    case Saturn
    case Neptune
}
var p1 = Planet.Earth(weight: 1.0, name: "地球")
var p2 = Planet.Venus(0.915, "金星")
var p3 = Planet.Mars(density: 3.95, name: "火星", weight: 0.1)
switch(p3) {
    // 将关联值绑定到变量或者常量来提取
case Planet.Earth(var weight, var name):
    print("此行星的名字为:\(name), 质量相当于\(weight)个地球")
    // 将关联值都提取为常量或者变量,只将一个var或者let放在枚举成员之前
case let Planet.Mars(density: d, name: n, weight: w):
    print("此行星的名字为:\(n), 质量相当于\(w)个地球, 密度为\(d)")
default:
    break
}

类和结构体

1.结构体的主要目的是用于封装少量相关的简单数据
2.如果需要在传递参数或者赋值时自动复制副本,使用结构体
3.明确该类型无需继承另一个已有的类或被其他类继承
注意:大部分时候,程序应该自定义类而不是自定义结构体

定义

// 1.定义类
/*
    [修饰符]class 类名 {
        零到多个构造器
        零到多个属性
        零到多个方法
        零到多个下标
}
修饰符可以是 private.public.internal.final,也可以省略

*/

// 定义结构体
/*
    [修饰符]struct 结构体名 {

}
修饰符可以是 private.public.internal
*/

// 定义属性的语法
/*
    [修饰符] var或者let 存储属性名: 类型名字 = 初始值
*/

// 定义构造器语法
/*
    [修饰符] init(形参列表) {
        // 零到多条可执行语句组成的构造器执行体
}
*/

// 定义一个Person类
class Person {
    var name: String = "Jcak"
    var age: Int = 0
    func say(content: String) {

        print(content)
    }
}
// 定义一个Dog结构体
struct Dog {
    var name: String
    var age: Int
    func run() {

        print("\(name)在奔跑")
    }
}

// 创建Person类的实例
var p: Person
p = Person() // 等价于var p = Person()
print(p.name)
p.say("hello world")

// 创建Dog结构体的实例
var dog = Dog(name: "旺财", age: 2)
print(dog.name)
dog.run()

值类型和引用类型

值类型需要复制,引用类型不复制,改变了原来的值
内存里的对象可以有多个引用,多个引用变量指向同一个对象
下面代码延续上面代码

// 引用类型
//var pp = p
//pp.name = "Rose"
//print(p.name)

// 值类型
//var dog2 = dog
//dog2.name = "snoopy"
//print(dog2.name)
//print(dog.name)

引用类型的比较

class User {
    var name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}
var u1 = User(name: "Devin", age: 18)
var u2 = User(name: "Devin", age: 18)

print(u1 === u2) // u1 和 u2引用的不是同一个对象,结果为false
print(u1 !== u2) // 结果为true

var u3 = u1
print(u3 === u1) // 引用同一个对象,结果为true

self关键词

/*
    1.构造器中的self代表该构造器正在初始化的实例
    2.方法中的self代表该方法的调用者
*/
class Dog1 {
    func jump() {
        print("正在执行jump方法")
    }
    func run() {
        self.jump()
        print("正在执行run方法")
    }
}
class Person1 {
    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 dog = Dog1()
dog.jump()
dog.run()

var person = Person1(name: "Lily", age: 20)
person.info()

总结:
1.枚举.类.结构体的定义
2.只有类才支持继承,枚举和结构体都不可以
3.只有类的实例可以称为对象