Sự khác biệt giữa func tĩnh và func lớp trong Swift là gì?

Tôi có thể thấy các định nghĩa này trong thư viện Swift:

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

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

Sự khác biệt giữa hàm thành viên được định nghĩa là static funcvà hàm khác được định nghĩa là class funcgì? Có phải nó chỉ đơn giản staticlà dành cho các hàm tĩnh của cấu trúc và enum, và classcho các lớp và giao thức? Có sự khác biệt nào khác mà người ta nên biết về? Lý do để có sự khác biệt này trong chính cú pháp là gì?

Có phải chỉ đơn giản là tĩnh dành cho các hàm tĩnh của cấu trúc và enum, và lớp cho các lớp và giao thức?

Đó là sự khác biệt chính. Một số khác biệt khác là các hàm lớp được gửi động và có thể bị ghi đè bởi các lớp con.

Các giao thức sử dụng từ khóa lớp, nhưng nó không loại trừ các cấu trúc thực hiện giao thức, chúng chỉ sử dụng tĩnh thay thế. Lớp được chọn cho các giao thức vì vậy sẽ không phải có từ khóa thứ ba để thể hiện tĩnh hoặc lớp.

Từ Chris Lattner về chủ đề này:

Chúng tôi đã xem xét việc thống nhất cú pháp (ví dụ: sử dụng "loại" làm từ khóa), nhưng thực tế đó không đơn giản là những thứ. Các từ khóa "class" và "static" rất tốt cho sự quen thuộc và khá mô tả (một khi bạn hiểu cách thức + phương thức hoạt động) và mở ra cơ hội để thêm các phương thức tĩnh thực sự vào các lớp. Điều kỳ lạ chính của mô hình này là các giao thức phải chọn một từ khóa (và chúng tôi đã chọn "lớp"), nhưng trên cân bằng, đó là sự đánh đổi đúng đắn.

Và đây là đoạn trích hiển thị một số hành vi ghi đè của các hàm lớp:

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

Để rõ ràng hơn, tôi làm một ví dụ ở đây,

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 giống như final class func

Bởi vì nó là final, chúng tôi không thể ghi đè nó trong lớp con như dưới đây:

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"
  }
}

Tôi đã làm một số thí nghiệm trong sân chơi và có một số kết luận.

TL; DR

Như bạn có thể thấy, trong trường hợp class, việc sử dụng class funchoặc static funcchỉ là một câu hỏi về thói quen.

Ví dụ sân chơi với lời giải thích:

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."

Để khai báo một thuộc tính biến loại, đánh dấu khai báo bằng công cụ staticsửa đổi khai báo. Các lớp có thể đánh dấu các thuộc tính được tính toán bằng công cụ classsửa đổi khai báo thay vào đó để cho phép các lớp con ghi đè lên việc thực hiện của lớp cha. Thuộc tính loại được thảo luận trong Thuộc tính loại.

LƯU Ý
Trong một khai báo lớp, từ khóa staticcó tác dụng tương tự như đánh dấu khai báo bằng cả hai biến tố khai báo classvà finalkhai báo.

Nguồn: Ngôn ngữ lập trình Swift - Thuộc tính biến loại

Theo Sách Swift 2.2 được xuất bản bởi apple:

Bạn chỉ ra các phương thức loại bằng cách viết statictừ khóa trước từ khóa func của phương thức. Các lớp cũng có thể sử dụng classtừ khóa để cho phép các lớp con ghi đè lên cách thực hiện của lớp cha của phương thức đó .

Từ Swift2.0, Apple nói:

"Luôn luôn yêu cầu thuộc tính loại tiền tố với từ khóa tĩnh khi bạn xác định chúng trong giao thức. Quy tắc này liên quan đến mặc dù các yêu cầu thuộc tính loại có thể được tiền tố với lớp hoặc từ khóa tĩnh khi được lớp thực hiện:"

Ví dụ này sẽ xóa mọi khía cạnh!

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.
 */

Đầu ra:

Đây được gọi là phương thức kiểu và được gọi với cú pháp dấu chấm, như phương thức thể hiện. Tuy nhiên, bạn gọi các phương thức loại trên loại, không phải trên một thể hiện của loại đó. Đây là cách bạn gọi một phương thức kiểu trên một lớp có tên là someClass: