Quickly understand Swift's classes and structures based on OC

First of all, I found that when writing Swift code, I often encountered problems such as Xcode not being able to prompt, freezing, and directly crashing, especially when mixing Swift and OC. (I don’t know if other developers have had such experiences, but I believe such problems will be solved soon.

Then I feel that Swift is not as simple as many friends on the Internet say. There are many details that are worth noting, and even many ideas have subverted traditional development languages! There are also many features that combine the advantages of other programming languages!

I personally think Swift is a trend and the most avant-garde development language at present, combining the advantages of many development languages!
There are already many Swift-related papers and blogs on the Internet, so I won’t recommend or reprint them here! I will summarize classes and structures, as well as related knowledge!

In Swift, classes and structures are common ways to encapsulate data and methods! First, let's take a look at what they have in common:

Can have attributes and methods;

All have constructors;

Both support subsidiary scripts;

Both support extensions;

Both support the protocol.

Then let's look at their differences:

Classes have inheritance;

The structure has an automatically generated one-by-one initializer;

When performing assignment operations, structures are always copied (Arrays are specially handled);

Structures can declare static properties and methods;

From the perspective of design patterns, class design focuses more on encapsulation of functions, while structure design focuses more on encapsulation of data. (Use cars and bookshelves to distinguish between classes and structures)

1. Construction process

1. Default Values

In OC classes and structures, member properties are implicitly given default values. The default value of an object is nil, and the default value of a basic data type is 0. However, in Swift, properties must be explicitly set to default values. Swift will call the default value constructor before calling the constructor to initialize all properties that have default values ​​set.

When a construction process is completed, the storage properties of the constructed class or structure instance will have values, otherwise it will compile incorrectly!

 class A : SuperClass {
 var _a = 1        // Default value = Int(1)  
 var _b: Int? // default value = nil  
 var _c: Int // No default value, must be assigned in the constructor  
 var _d: Int! // default value = nil  
 init() {
 _c = 1        // Before calling the parent class's constructor, you must assign a value to _c, otherwise a compilation error will occur  
 super .init()
 }
 ...
 }

2. Constructor

Similar to the -(instance)init method of OC. The difference from OC*** is that OC returns a pointer to the object after initialization, while Swift returns a reference to the object after initialization.

According to the actual construction process of the constructor, the constructor can be divided into convenience constructor and designated constructor, but only the designated constructor is the real constructor. The convenience constructor only adds a convenient parameter to the designated constructor, or adds some additional operations.

The following points need to be noted during development:

Both classes and structures need to initialize all storage properties in the constructor;

Before calling the superclass's constructor, the subclass must ensure that all stored properties declared in this class have values.

A convenience initializer must directly or indirectly call the designated initializer of the class.

 class A : SomeClass {
 var _a: Int
 var _b = 1_000
 //Specify the constructor  
 init() {
 self._a = 5       // If it is declared like this 'var _a: Int = 5' or 'var _a = 5', then the init() constructor can be called directly without writing  
 super .init()
 }
 //Specify the constructor  
 init(a: Int) {
 self._a = a // Because the _a attribute has no default value, _a must be assigned a value before calling super.init(), otherwise a compilation error will occur!  
 super .init()
 }
 // Convenience constructor  
     convince init(a: Int, b: Int) {
 self.init(a: a + b) // Directly call the specified constructor  
 }
 // Convenience constructor  
     convince init(a: Int, b: Int, c: Int) {
 self.init(a: a, b: b + c) // Indirectly call the specified constructor  
 }
 ...
 }

3. Destructor

It is very similar to OC's dealloc, so I won't explain it here.

 class A {
 ...
 deinit {
 //... internal processing of the destructor  
 }
 ...
 }

2. Attributes

Classes in Objective-C have both properties and instance variables, but in Swift, both instance variables and properties of a class are implemented as properties.

1. Storage properties

Simply put, it is a member variable/constant. Swift can add property monitors to storage properties to respond to changes when the property value is set.

 class SomeClass {
 let _a = 100          // Constants  
 var _b: Int // variable without default value  
 var _c = 200          // Default value = Int variable of 200  
 var _d: Int = 200 { // Default value = Int variable of 200. If a property monitor is added, the declared variable type must be displayed.  
 didSet {
 println( "A's _c property didSet = old:\(oldValue) -> \(self._c)" ) // oldValue represents the previous value  
 }
 willSet {
 println( "A's _c attribute willSet = \(self._c) -> new:\(newValue)" ) // newValue represents the value that will be set  
 }
 }
 }

2. Computed properties

Computed properties do not store any data, they just provide a convenient set/get interface.

 class A {
 class var a: Int { // This is a computed property of the class (different from the computed property of the instance of the class below)  
 return   1001  
 }
 private (set) var _b = 100     // Externally accessible but not modifiable  
 private var _a = 100          // Private variables, cannot be accessed from outside  
 var a: Int { // read-only computed property  
 return _a
 }
 var b: Int { // readable and writable computed property  
 get {
 retrun _a
 }
 set {
 _a = newValue // newValue represents the input value  
 }
 }
 }

3. Delayed storage properties

I believe everyone has heard of lazy loading, which is to avoid unnecessary performance overhead and only perform data loading when the data is really needed. Swift can use the lazy keyword to declare lazy storage properties. Lazy storage properties will not be initialized in the default value constructor, but will be initialized before the first use! Although it is not initialized, the compiler will think it has a value.

Global constants or variables are all lazily loaded, including static properties of structures.

 let some = A()
 class A {
 lazy var view = UIView(frame: CGRectZero) // Defines a lazy storage property ...  
 }

4. Static properties

Structures can use the keyword static to declare static storage properties. (Enumerations can also have static properties.) Swift classes do not support static properties or static temporary variables. This can be used as a way to declare a singleton in Swift:

 class Tools {
 class func sharedInstance() -> Tools {
 struct Static {
 static let sharedInstance = QNTools()
 }
 return Static.sharedInstance
 }
 }

III. Methods

Swift classes and structures can define their own methods! (OC structures do not have methods)

1. Parameters

The parameters of a method have local parameter names and external parameter names. If they are the same, just write one! The parameters of Swift methods are very flexible. They can be values, references, closures, tuples... The return value of Swift methods is as flexible as the parameters.

Here is a simple addition method to demonstrate the method's parameters:

 class A {
 // eg. A simple addition method  
 // Full version  
 class func sum1(let a /*external parameter name*/ aValue /*internal parameter name*/ : Int, let b /*external parameter name*/ bValue /*internal parameter name*/ : Int) -> Int {
 return aValue + bValue
 }
 // When the external and internal parameters of a function are the same, you can only write one. In this case, the name of the first parameter is hidden when calling  
 class func sum2(a: Int, b: Int) -> Int {
 return a + b
 }
 // Use the _ symbol to hide the function parameter name when calling. The first parameter is hidden by default.  
 class func sum3(a: Int, _ b: Int) -> Int {
 // The parameter names of embedded functions can be hidden. No need to use the _ symbol to declare  
        func sum4(a: Int, b: Int) -> Int {
 return a + b
 }
 return sum4(a, b)
 }
 // You can use the let/var keyword to declare whether the parameter is passed in as a constant or a variable. (If it is a constant, you don't need to write let explicitly)  
 class func sum4(let a: Int, _ b: Int) -> Int {
 // The parameter names of embedded functions can be hidden. No need to use the _ symbol to declare  
        func sum4(a: Int, b: Int) -> Int {
 return a + b
 }
 return sum4(a, b)
 }
 // You can use the let/var keyword to declare whether the parameter is passed in as a constant or a variable. (If it is a constant, you don't need to write let explicitly)  
 class func sum5(let a: Int, let _ b: Int) -> Int {
 // The parameter names of embedded functions can be hidden. No need to use the _ symbol to declare  
 return a + b
 }
 class func sum6(var a: Int, var _ b: Int) -> Int {
 // The parameter names of embedded functions can be hidden. No need to use the _ symbol to declare  
 a++
 b++
 return a + b
 }
 // You can use the inout keyword to pass by reference  
 class func add(inout value: Int) {
 value++
 }
 }

 A.sum1(a: 1 , b: 2 ) // result: 3  
 A.sum2( 1 , b: 2 ) // result: 3  
 A.sum3( 1 , 2 ) // result: 3  
 var aTemp: Int = 1001         // aTemp = 1001  
 A.add(&aTemp)
 aTemp // aTemp = 1002  
 A.sum5( 1 , 2 ) // result: 3  
 A.sum6( 1 , 2 ) // result: 5  

2. Instance Methods

Methods owned by instances of a class or structure!

 class A {
 private (set) var a: Int = 100  
 func reset() -> Void {
 self.a = 100  
 }
 }
 struct S {
 var a: Int = 100  
 mutating func reset() -> Void { // Note: If you need to modify properties in instance methods of structures and enumerations, you need to add a mutating field  
 self.a = 100  
 }
 }

3. Class Methods

The class itself in Swift is also an instance. It has no stored properties, but has calculated properties and methods!

Refer to the example in "1. Parameters"

4. Static Methods

Structures can use the keyword static to declare static methods.

 struct S {
 static func name() -> String {
 return   "Liuyu"  
 }
 }

4. Subsidiary Scripts

Swift provides the syntax of auxiliary scripts to simplify query-like behaviors. For example, accessing the nth element of an array, array[n], accessing the value of a dictionary, dictionary["key"], can all be achieved through auxiliary scripts. Here is an example of querying elements in an array through a string index.

 // Extend a subscript to access data via a string location  
 extension Array {
    subscript(index: String) -> T? {
 if let iIndex = index.toInt() {
 return self[iIndex]
 }
 return nil
 }
 }
 let array = [ "Liu0" , "Liu1" , "Liu2" ]
 array[ 1 ] // result : Liu1  
 array[ "1" ]! // result : Liu1  

5. Inheritance

Like OC, Swift classes can inherit from their parent classes to obtain their properties and methods (with limitations). Swift classes have many safety measures in place for inheritance.

 class SomeSuperClass {
 func someFunc1() {
 ...
 }
 // Define methods that cannot be overridden by subclasses, and need to add the final keyword  
 final func someFunc2() {
 ...
 }
 }
 class SomeClass : SomeSuperClass {
 // To overload the parent class method, you need to add the override keyword  
    override func someFunc1() {
 ...
 super .someFunc1()
 }
 // Methods that cannot be overridden by subclasses  
    override func someFunc2() { // Error  
 ...
 super .someFunc2()
 }
 }

6. Extension

Extensions are about adding new functionality to an existing class, structure, or enumeration type. This includes the ability to extend a type without access to the original source code (i.e., reverse engineering). Extensions are similar to categories in Objective-C, but there are many subtle differences:

Extensions have no name, and once extended they apply to the entire project (module)

If you want to override an existing method in an extension, you need to add the override keyword (it is not recommended to modify existing methods)

New nested types can be defined

Here is an extension for calculating distance in a mathematical project

 typealias Distance = Double
 extension Distance {
    var km: Double { return self/1_000. 0 }
    var m : Double { return self }
    var cm: Double { return self* 100.0 }
    var mm: Double { return self*1_000. 0 }
 }
 let distance = Distance( 1000 ) // 1000m distance  
 distance.km // result : 1.0 (km)  
 distance.m // result : 1000.0 (m)  
 distance.cm // result : 100.0 (cm)