swift-default constructor-standby

Instances of structs and classes call a special Init method, called a constructor, during construction. The constructor does not have a return value and can be overloaded. In the case of multiple constructor overloads, the runtime can invoke the appropriate constructor based on its external parameter name or parameter list.
Default constructor
Structs and classes call a constructor during construction, and even if no constructors are written, the compiler provides a default constructor. Here's the sample code:

 

2. Class Rectangle {
4. var width: Double = 0.0
6. var height: Double = 0.0
8. }
10. var rect = Rectangle ()//Create instance and invoke default constructor init ()
12. Rect.width = 320.0
14. Rect.height = 480.0
16. Print ("Rectangle: \ (rect.width) x \ (rect.height)")
18. Rectangle () means that a method is called, which is the default constructor, Init ().
20. In fact, the constructor is omitted during the definition of rectangle, which is equivalent to the following code:
22. Class Rectangle {
24. var width: Double = 0.0
26. var height: Double = 0.0
30. Init () {
32. }
34. }

If rectangle is a struct, it is defined as follows:
struct Rectangle {
var width:double = 0.0
var height:double = 0.0
}
The default constructor for struct rectangle is different from the default constructor for class rectangle, which is equivalent to the following code:

 

2. struct Rectangle {
4. var width: Double = 0.0
6. var height: Double = 0.0
8. Init () {
10. }
12. Init (width:double, height:double) {//parameter-constructor
14. self.width = width
16. self.height = height
18. }
20. }

Which constructor to invoke is determined by the parameter name and the type of argument passed.

You can use the constructor proxy in a constructor to help complete some of the construction work. Class constructor proxies are divided into horizontal and upward proxies, which can only occur inside the same class, and this constructor is called a convenience constructor. An up-agent occurs in the case of inheritance, in which the parent class constructor is called to initialize the stored property of the parent class, which is called the specified constructor, during the child class construction.  

Constructor Call rules

 

2. Examples of person and student classes:
6. Class Person {
10. var name:string
14. var age:int
18. Func description ()-> String {
22. Return "\ (name) age is: \ (aged)"
26. }
30. Convenience init () {//convenience constructor
34. Self.init (Name: "Tony")
38. self.age =
42. }
46. Convenience init (name:string) {//convenience constructor
50. Self.init (Name:name, age:18)
54. }
58. Init (name:string, Age:int) {//Specify constructor
62. self.name = name
66. self.age = Age
70. }
74. }
78. Class Student:person {
82. var school:string
86. Init (name:string, Age:int, school:string) {//Specify constructors
90. Self.school = School
94. Super.init (Name:name, Age:age)
98. }
102. Convenience override Init (name:string, Age:int) {//convenience constructor
106. Self.init (Name:name, Age:age, School: "Tsinghua University")
110. }
114. }
118. Let student = student ()
122. Print ("Student: \ (student.description ())")

Calls between constructors form a chain of constructor functions.

Swift restricts the rules for proxy calls between constructors to have 3, as shown below.

Specifies that the constructor must call the specified constructor of its immediate parent class. Visible from the diagram,the ④ number in student specifies that the constructor calls the ③ number in the person specified by the constructor.

• The convenience constructor must call other constructors defined in the same class. As seen from the diagram,the ⑤ in student facilitates constructors to call the ④ in the same class to facilitate constructors, andthe ① number in person facilitates constructors by calling the ② number in the same class.

• The convenience constructor must eventually end with a call to a specified constructor function. From the diagram, the⑤ number in student facilitates the constructor to call the ④ number in the same class to specify the constructor, andthe ② number in the person facilitates the constructor to call the ③ number in the same class to specify the constructor.

• ==================================================

• There are two sources of child class constructors in Swift: writing and inheriting from the parent class. Not all constructors of the parent class can inherit, and constructors that inherit from the parent class are conditional, as shown below.

  • Condition 1: If the subclass does not define any of the specified constructors, it automatically inherits the specified constructors for all the parent classes.

  • Condition 2: If the subclass provides all of the parent class to specify the implementation of the constructor, whether inherited through condition 1, or by writing it yourself, it will automatically inherit all the convenience constructors of the parent class.

  Here's the sample code:

   
  2. Class Person {
  6. var name:string
  10. var age:int
  18. Func description ()-> String {
  22. Return "\ (name) age is: \ (aged)"
  26. }
  30. Convenience init () {
  34. Self.init (Name: "Tony")
  38. self.age =
  42. }
  46. Convenience init (name:string) {
  50. Self.init (Name:name, age:18)
  54. }
  58. Init (name:string, Age:int) {
  62. self.name = name
  66. self.age = Age
  70. }
  74. }
  82. Class Student:person {
  86. var school:string
  90. Init (name:string, Age:int, school:string) {
  94. Self.school = School
  98. Super.init (Name:name, Age:age)
  102. }
  106. Convenience override Init (name:string, Age:int) {
  110. Self.init (Name:name, Age:age, School: "Tsinghua University")
  114. }
  118. }
  126. Class Graduate:student {
  130. var Special: String = ""
  134. }
  
  

  To see the inheritance of Condition 1,graduate inherits Student, and thegraduate class does not define any of the specified constructors, it automatically inherits all the Student specified constructors. After qualifying 1,graduate inherits from student the following specified constructor:

  Init (name: string, age: int,school: string)

  Again, with the inheritance of condition 2, because graduate implements all the specified constructors for student,graduate automatically inherits all the student convenience constructors. After qualifying 2,graduate inherited the following 3 convenient constructors from student:

  Init (name: String, age: Int)

  Init (name: String)

  Init ()

  Student has 4 constructors after inheriting a person.

  Condition 1 does not satisfy the student because it has the specified constructor, andthe convenience constructor Init (name:string, Age:int) in the student class satisfies condition 2, which implements the parent class to specify the constructor Init (name:string, Age:int). In addition, because the subclass constructor is the same as the parent class constructor parameter, you need to use the override keyword to represent the subclass constructor override (overriding) of the parent class constructor.

  Because the student class implements the parent class to specify the constructor, it also inherits two other convenient constructors for the parent class.

swift-default constructor-standby