Swift 类和对象

Swift 也是一种面向对象的编程语言。并且，与其他 OOP 语言一样，它也支持对象和类的概念。

一个对象只是数据（变量）和方法（函数）的集合。同样，一个类是该对象的蓝图。

在学习对象之前，我们先来了解一下 Swift 中的类。

Swift 类

类被认为是对象的蓝图。我们可以将类看作是房子的草图（原型）。它包含了关于楼层、门、窗户等的所有细节。基于这些描述，我们建造房子。房子就是对象。

因为可以根据同一个描述建造许多房子，所以我们可以从一个类创建许多对象。

定义 Swift 类

我们使用 `class` 关键字在 Swift 中创建一个类。例如，

class ClassName {
  // class definition 
}

在这里，我们创建了一个名为 `ClassName` 的类。

让我们看一个例子，

class Bike {

  var name = ""
  var gear = 0
}

这里，

• Bike - 类的名称
• name/gear - 类内部的变量，分别具有默认值 `""` 和 **0**。

注意：类内部的变量和常量称为属性。

Swift 对象

对象被称为类的实例。例如，假设 `Bike` 是一个类，那么我们可以从该类创建 `bike1`、`bike2` 等对象。

这是创建对象的语法。

var objectName = ClassName()

让我们看一个例子，

// create class
class Bike {

  var name = ""
  var gears = 0
}

// create object of class
var bike1 = Bike()

在这里，`bike1` 是类的对象。现在，我们可以使用此对象来访问类的属性。

使用对象访问类属性

我们使用 `.` 符号来访问类的属性。例如，

// modify the name property
bike1.name = "Mountain Bike"

// access the gear property
bike1.gears

在这里，我们使用 `bike1.name` 和 `bike.gears` 分别更改和访问 `name` 和 `gears` 属性的值。

示例：Swift 类和对象

// define a class
class Bicycle {

// define two properties
var name = ""
var gears = 0
}

// create instance of Person
var bike1 = Bicycle()

// access properties and assign new values
bike1.gears = 11
bike1.name = "Mountain Bike"

print("Name: \(bike1.name), Gears: \( bike1.gears) ")

输出

Name: Mountain Bike, Gears: 11

在上面的示例中，我们定义了一个名为 `Bike` 的类，它有两个属性：name 和 gears。

我们还创建了 `Bike` 类的一个对象 `bike1`。

最后，我们使用 `.` 符号访问并修改了对象的属性。

创建类的多个对象

我们也可以从一个类创建多个对象。例如，

// define a class
class Employee {

// define a property
var employeeID = 0
}

// create two objects of the Employee class
var employee1 = Employee()
var employee2 = Employee()

// access property using employee1
employee1.employeeID = 1001
print("Employee ID: \(employee1.employeeID)")

// access properties using employee2
employee2.employeeID = 1002
print("Employee ID: \(employee2.employeeID)")

输出

Employee ID: 1001
Employee ID: 1002

在上面的示例中，我们创建了 `Employee` 类的两个对象 `employee1` 和 `employee2`。

Swift 类中的函数

我们也可以在 Swift 类中定义一个函数。在类中定义的 Swift 函数称为方法。

让我们看一个例子，

// create a class
class Room {

  var length = 0.0
  var breadth = 0.0

  // method to calculate area
  func calculateArea() {
    print("Area of Room =", length * breadth)
  }
}

  // create object of Room class
  var studyRoom = Room()

  // assign values to all the properties 
  studyRoom.length = 42.5
  studyRoom.breadth = 30.8

  // access method inside class
  studyRoom.calculateArea()

输出

Area of Room = 1309.0

在上面的示例中，我们创建了一个名为 `Room` 的类，其中包含

• 属性：length 和 breadth
• 方法：calculateArea()

在这里，我们从 `Room` 类创建了一个名为 `studyRoom` 的对象。然后我们使用该对象为属性 length 和 breadth 赋值。

请注意，我们还使用该对象调用了类中的方法。

room1.calculateArea()

在这里，我们使用了 `.` 符号来调用方法。最后，执行了方法内的语句。

Swift Initializer

之前，我们为类属性分配了一个默认值。

class Bike {
  
  var name = ""
}
...

// create object
var bike = Bike()

但是，我们也可以使用初始化器来初始化值。例如，

class Bike {
  
  var name: String

  init(name: String){
  self.name = name
  }
}

在这里，`init()` 是用于为 name 变量赋值的初始化器。我们使用 `self.name` 来引用 `bike1` 对象的 `name` 属性。

如果我们使用初始化器在类中初始化值，则在创建类对象时需要传递相应的值。

var bike1 = Bike(name: "Mountain Bike")

这里，

• "Mountain Bike" 被传递给 init() 的 name 参数。
• self 代表 `bike1` 对象。
• self.name 等于 "Mountain Bike"。

示例：Swift 初始化器

class Bike {

  // properties with no default values
  var name: String
  var gear: Int

  // assign value using initializer
  init(name: String, gear: Int){
    self.name = name
    self.gear = gear
  }
}

// object of Person with custom initializer 
var bike1 = Bike(name: "BMX Bike", gear: 2)

print("Name: \(bike1.name) and Gear: \(bike1.gear)")

输出

Name: BMX Bike and Gear: 2

在上面的示例中，我们创建了一个名为 `Bike` 的类，它有两个属性 `name` 和 `gear`。

我们使用了自定义初始化器来为类的属性赋值。

最后，在创建 `Bike` 类的对象时，我们传递了 `"BMX Bike"` 和 **2** 作为参数。

Swift 中的 Struct 与 Class 对比

尽管 struct 和 class 的工作方式看起来相似，但它们之间存在一些主要的区别。

1. 类是面向对象编程的概念。因此，它提供了一些 OOP 特性，例如继承，我们可以从现有类派生出一个新类。

然而，struct 不支持继承。

要了解有关继承的更多信息，请访问 Swift Inheritance。

2. 类是引用类型。这意味着类的每个实例共享同一份数据副本。例如，

class Bike {
  var color: String

  init(color:String) {
    self.color = color
  }
}

var bike1 = Bike(color: "Blue")

var bike2 = bike1

bike1.color = "Red"
print(bike2.color)  // prints Red

如你在此处所见，我们正在更改 `bike1` 对象的颜色。但是，`bike2` 对象的颜色也发生了变化。

另一方面，struct 是值类型。这意味着 struct 的每个实例都将拥有独立的数据副本。例如，

struct Bike {
  var color: String

  init(color:String) {
    self.color = color
  }
}

var bike1 = Bike(color: "Blue")

var bike2 = bike1

bike1.color = "Red"
print(bike2.color)  // prints blue

如你在此处所见，我们正在更改 `bike1` 对象的颜色。但是，`bike2` 对象的颜色未发生变化。