Apa perbedaan antara fungsi statis dan fungsi kelas di Swift?

Saya bisa melihat definisi ini di perpustakaan Swift:

extension Bool : BooleanLiteralConvertible {
    static func convertFromBooleanLiteral(value: Bool) -> Bool
}

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    class func convertFromBooleanLiteral(value: BooleanLiteralType) -> Self
}

Apa perbedaan antara fungsi anggota yang didefinisikan static funcdan yang lainnya didefinisikan sebagai class func? Apakah itu hanya staticuntuk fungsi statis dari struct dan enum, dan classuntuk kelas dan protokol? Apakah ada perbedaan lain yang harus diketahui? Apa alasan untuk memiliki perbedaan dalam sintaksis itu sendiri?

Apakah hanya itu statis untuk fungsi statis struct dan enum, dan kelas untuk kelas dan protokol?

Itulah perbedaan utama. Beberapa perbedaan lain adalah bahwa fungsi-fungsi kelas secara dinamis dikirim dan dapat ditimpa oleh subclass.

Protokol menggunakan kata kunci kelas, tetapi tidak mengecualikan struct dari penerapan protokol, mereka hanya menggunakan statis. Kelas dipilih untuk protokol sehingga tidak perlu ada kata kunci ketiga untuk mewakili statis atau kelas.

Dari Chris Lattner tentang topik ini:

Kami mempertimbangkan untuk menyatukan sintaks (mis. Menggunakan "ketik" sebagai kata kunci), tetapi itu sebenarnya bukan sekadar hal. Kata kunci "kelas" dan "statis" baik untuk keakraban dan cukup deskriptif (setelah Anda memahami cara kerja + metode), dan buka pintu untuk kemungkinan menambahkan metode yang benar-benar statis ke kelas. Keanehan utama dari model ini adalah protokol harus memilih kata kunci (dan kami memilih "kelas"), tetapi pada keseimbangan itu adalah tradeoff yang tepat.

Dan inilah cuplikan yang menunjukkan beberapa perilaku override fungsi kelas:

class MyClass {
    class func myFunc() {
        println("myClass")
    }
}

class MyOtherClass: MyClass {
    override class func myFunc() {
        println("myOtherClass")
    }
}

var x: MyClass = MyOtherClass()
x.dynamicType.myFunc() //myOtherClass
x = MyClass()
x.dynamicType.myFunc() //myClass

Agar lebih jelas, saya membuat contoh di sini,

class ClassA {
  class func func1() -> String {
    return "func1"
  }

  static func func2() -> String {
    return "func2"
  }

  /* same as above
  final class func func2() -> String {
    return "func2"
  }
  */
}

static func sama dengan final class func

Karena itu final, kita tidak dapat menimpanya dalam subkelas seperti di bawah ini:

class ClassB : ClassA {
  override class func func1() -> String {
    return "func1 in ClassB"
  }

  // ERROR: Class method overrides a 'final` class method
  override static func func2() -> String {
    return "func2 in ClassB"
  }
}

Saya melakukan beberapa percobaan di taman bermain dan mendapatkan beberapa kesimpulan.

TL; DR

Seperti yang Anda lihat, dalam kasus class, penggunaan class funcatau static funchanya masalah kebiasaan.

Contoh taman bermain dengan penjelasan:

class Dog {
    final func identity() -> String {
        return "Once a woofer, forever a woofer!"
    }

    class func talk() -> String {
        return "Woof woof!"
    }

    static func eat() -> String {
        return "Miam miam"
    }

    func sleep() -> String {
        return "Zzz"
    }
}

class Bulldog: Dog {
    // Can not override a final function
//    override final func identity() -> String {
//        return "I'm once a dog but now I'm a cat"
//    }

    // Can not override a "class func", but redeclare is ok
    func talk() -> String {
        return "I'm a bulldog, and I don't woof."
    }

    // Same as "class func"
    func eat() -> String {
        return "I'm a bulldog, and I don't eat."
    }

    // Normal function can be overridden
    override func sleep() -> String {
        return "I'm a bulldog, and I don't sleep."
    }
}

let dog = Dog()
let bullDog = Bulldog()

// FINAL FUNC
//print(Dog.identity()) // compile error
print(dog.identity()) // print "Once a woofer, forever a woofer!"
//print(Bulldog.identity()) // compile error
print(bullDog.identity()) // print "Once a woofer, forever a woofer!"

// => "final func" is just a "normal" one but prevented to be overridden nor redeclared by subclasses.


// CLASS FUNC
print(Dog.talk()) // print "Woof woof!", called directly from class
//print(dog.talk()) // compile error cause "class func" is meant to be called directly from class, not an instance.
print(Bulldog.talk()) // print "Woof woof!" cause it's called from Bulldog class, not bullDog instance.
print(bullDog.talk()) // print "I'm a bulldog, and I don't woof." cause talk() is redeclared and it's called from bullDig instance

// => "class func" is like a "static" one, must be called directly from class or subclassed, can be redeclared but NOT meant to be overridden.

// STATIC FUNC
print(Dog.eat()) // print "Miam miam"
//print(dog.eat()) // compile error cause "static func" is type method
print(Bulldog.eat()) // print "Miam miam"
print(bullDog.eat()) // print "I'm a bulldog, and I don't eat."

// NORMAL FUNC
//print(Dog.sleep()) // compile error
print(dog.sleep()) // print "Zzz"
//print(Bulldog.sleep()) // compile error
print(bullDog.sleep()) // print "I'm a bulldog, and I don't sleep."

Untuk mendeklarasikan properti tipe variabel, tandai deklarasi dengan staticpengubah deklarasi. Kelas dapat menandai tipe properti yang dikomputasi dengan classpengubah deklarasi alih-alih untuk memungkinkan subclass untuk mengesampingkan implementasi superclass. Tipe properti dibahas dalam Tipe Properties.

CATATAN
Dalam deklarasi kelas, kata kunci staticmemiliki efek yang sama dengan menandai deklarasi dengan pengubah deklarasi classdan final.

Sumber: Bahasa Pemrograman Swift - Tipe Variable Properties

Menurut Swift 2.2 Book yang diterbitkan oleh apel:

“Anda menunjukkan metode jenis dengan menulis statickata kunci sebelum kata kunci func metode. Kelas juga dapat menggunakan classkata kunci untuk memungkinkan subclass untuk mengesampingkan penerapan metode tersebut pada superclass . "

Dari Swift2.0, Apple mengatakan:

"Selalu awali persyaratan jenis properti dengan kata kunci statis saat Anda mendefinisikannya dalam protokol. Aturan ini berkaitan meskipun persyaratan jenis properti dapat diawali dengan kelas atau kata kunci statis saat diterapkan oleh suatu kelas:"

Contoh ini akan menghapus setiap aspek!

import UIKit

class Parent {
    final func finalFunc() -> String { // Final Function, cannot be redeclared.
        return "Parent Final Function."
    }

    static func staticFunc() -> String { // Static Function, can be redeclared.
        return "Parent Static Function."
    }

    func staticFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Static Function, redeclared with same name but as non-static(normal) function."
    }

    class func classFunc() -> String { // Class Function, can be redeclared.
        return "Parent Class Function."
    }

    func classFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Class Function, redeclared with same name but as non-class(normal) function."
    }

    func normalFunc() -> String { // Normal function, obviously cannot be redeclared.
        return "Parent Normal Function."
    }
}

class Child:Parent {

    // Final functions cannot be overridden.

    override func staticFunc() -> String { // This override form is of the redeclared version i.e: "func staticFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Static Function redeclared and overridden, can simply be called Child Normal Function."
    }

    override class func classFunc() -> String { // Class function, can be overidden.
        return "Child Class Function."
    }

    override func classFunc() -> String { // This override form is of the redeclared version i.e: "func classFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Class Function, redeclared and overridden, can simply be called Child Normal Function."
    }

    override func normalFunc() -> String { // Normal function, can be overridden.
        return "Child Normal Function."
    }
}

let parent = Parent()
let child = Child()

// Final
print("1. " + parent.finalFunc())   // 1. Can be called by object.
print("2. " + child.finalFunc())    // 2. Can be called by object, parent(final) function will be called.
// Parent.finalFunc()               // Cannot be called by class name directly.
// Child.finalFunc()                // Cannot be called by class name directly.

// Static
print("3. " + parent.staticFunc())  // 3. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("4. " + child.staticFunc())   // 4. Cannot be called by object, this is override form redeclared version (normal function).
print("5. " + Parent.staticFunc())  // 5. Can be called by class name directly.
print("6. " + Child.staticFunc())   // 6. Can be called by class name direcly, parent(static) function will be called.

// Class
print("7. " + parent.classFunc())   // 7. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("8. " + child.classFunc())    // 8. Cannot be called by object, this is override form redeclared version (normal function).
print("9. " + Parent.classFunc())   // 9. Can be called by class name directly.
print("10. " + Child.classFunc())   // 10. Can be called by class name direcly, child(class) function will be called.

// Normal
print("11. " + parent.normalFunc())  // 11. Can be called by object.
print("12. " + child.normalFunc())   // 12. Can be called by object, child(normal) function will be called.
// Parent.normalFunc()               // Cannot be called by class name directly.
// Child.normalFunc()                // Cannot be called by class name directly.

/*
 Notes:
 ___________________________________________________________________________
 |Types------Redeclare------Override------Call by object------Call by Class|
 |Final----------0--------------0---------------1------------------0-------|
 |Static---------1--------------0---------------0------------------1-------|
 |Class----------1--------------1---------------0------------------1-------|
 |Normal---------0--------------1---------------1------------------0-------|
 ---------------------------------------------------------------------------

 Final vs Normal function: Both are same but normal methods can be overridden.
 Static vs Class function: Both are same but class methods can be overridden.
 */

Keluaran:

Ini disebut metode tipe, dan disebut dengan sintaks dot, seperti metode instance. Namun, Anda memanggil metode tipe pada tipe, bukan pada instance dari tipe itu. Inilah cara Anda memanggil metode tipe pada kelas yang disebut SomeClass: