Classe rapide


Une classe Swift est une construction générale et flexible pour le code du bâtiment.

Nous pouvons définir des propriétés (constantes, variables) et des méthodes pour les classes.

Contrairement à d'autres langages de programmation, Swift ne vous oblige pas à créer des fichiers d'interface et d'implémentation distincts pour les classes personnalisées. Tout ce que vous avez à faire est de définir une classe dans un seul fichier et le système génère automatiquement des interfaces externes vers un autre code.

Comparaison des classes et des structures

Les classes et les structures de Swift ont beaucoup en commun. Les points communs sont :

  • Définir des attributs pour stocker des valeurs

  • Définir des méthodes pour fournir des fonctions

  • Définir des scripts auxiliaires pour accéder aux valeurs

  • Définir des constructeurs pour générer des valeurs d'initialisation

  • Étendre pour augmenter les fonctionnalités de l'implémentation par défaut

  • Se conformer au protocole pour fournir des fonctions standards pour une certaine classe

Par rapport aux structures, les classes ont les fonctions supplémentaires suivantes :

  • L'héritage permet à une classe d'hériter des caractéristiques d'une autre classe

  • La conversion de type permet d'inspecter et d'interpréter le type d'une instance de classe au moment de l'exécution

  • Le destructeur permet à une instance de classe de libérer toutes les ressources allouées

  • Le comptage de références permet plusieurs références à une classe

Syntaxe :

Class classname {
   Definition 1
   Definition 2
   ……
   Definition N
}

Définition de classe

class student{
   var studname: String
   var mark: Int 
   var mark2: Int 
}

Classe instanciée :

let studrecord = student()

Instance

import Cocoa

class MarksStruct {
    var mark: Int
    init(mark: Int) {
        self.mark = mark
    }
}

class studentMarks {
    var mark = 300
}
let marks = studentMarks()
print("成绩为 \(marks.mark)")

Le résultat de sortie de l'exécution du programme ci-dessus est : 

成绩为 300

Accès aux attributs de classe comme type de référence

Les attributs de la classe sont accessibles via .. Le format est : Nom de la classe instanciée. Nom de l'attribut :

import Cocoa

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark1 = 300
   var mark2 = 400
   var mark3 = 900
}
let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Le résultat de l'exécution du programme ci-dessus est : 

Mark1 is 300
Mark2 is 400
Mark3 is 900

Opérateur d'identité

Étant donné que les classes sont des types référence, il peut y avoir plusieurs constantes et variables faisant référence à une certaine instance de classe en arrière-plan en même temps.

Afin de déterminer si deux constantes ou variables font référence à la même instance de classe, Swift dispose de deux opérateurs d'identité intégrés :

恒等运算符不恒等运算符
运算符为：===运算符为：!==
如果两个常量或者变量引用同一个类实例则返回 true如果两个常量或者变量引用不同一个类实例则返回 true
Opérateur d'identité

Opérateur d'identité

Opération L'opérateur est : == =L'opérateur est : !==
Si deux constantes ou variables font référence à la même instance de classe, il renvoie vraiSi deux constantes ou variables font référence à des instances de classe différentes, retournez true

Instance
import Cocoa

class SampleClass: Equatable {
    let myProperty: String
    init(s: String) {
        myProperty = s
    }
}
func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {
    return lhs.myProperty == rhs.myProperty
}

let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")

if spClass1 === spClass2 {// false
    print("引用相同的类实例 \(spClass1)")
}

if spClass1 !== spClass2 {// true
    print("引用不相同的类实例 \(spClass2)")
}
<🎜>La sortie d'exécution du programme ci-dessus Le résultat est : <🎜>
引用不相同的类实例 SampleClass
<🎜>