Funções / variáveis ​​estáticas versus classes nas classes Swift?

416

O código a seguir é compilado no Swift 1.2:

class myClass {
    static func myMethod1() {
    }
    class func myMethod2() {
    }
    static var myVar1 = ""
}

func doSomething() {
    myClass.myMethod1()
    myClass.myMethod2()
    myClass.myVar1 = "abc"
}

Qual é a diferença entre uma função estática e uma função de classe ? Qual devo usar e quando?

Se eu tentar definir outra variável class var myVar2 = "", ele diz:

Propriedades armazenadas de classe ainda não suportadas em classes; você quis dizer 'estático'?

Quando esse recurso é suportado, qual será a diferença entre uma variável estática e uma variável de classe (ou seja, quando ambas são definidas em uma classe)? Qual devo usar e quando?

(Xcode 6.3)

Sensível
fonte
Pergunta semelhante aqui: static vs class como variável de classe / método (Swift) .
Martin R

Respostas:

690

statice classambos associam um método a uma classe, em vez de uma instância de uma classe. A diferença é que as subclasses podem substituir os classmétodos; eles não podem substituir staticmétodos.

class teoricamente, as propriedades funcionarão da mesma maneira (as subclasses podem substituí-las), mas ainda não são possíveis no Swift.

mipadi
fonte
89
Então, qual é a diferença entre final classfunção e função 'estática' dentro de uma classe?
Hippo_san 17/07/2015
57
@hippo_san, em uma classe base, os dois são funcionalmente iguais. No entanto, finalpode ser usado para eliminar substituições adicionais quando usado em uma subclasse. Os dois têm o seu lugar, eu diria que o uso staticou finalquando usado em uma função de classe é trivial e depende da sua escolha de estilo.
Andrew Robinson
8
ah, então static func foo(){}no Swift é como public static final foo(){}em Java?
Supuhstar
3
@ Supuhstar: Basicamente, sim.
Mipadi
2
@ mipadi eu entendo agora. Para funções de classe, podemos substituir "estático" por "classe final", mas para propriedades em uma classe, podemos ter apenas propriedades estáticas em vez de propriedades de classe. Portanto, a palavra-chave "estática" ainda tem seu lugar.
allenlinli
72

Eu tentei a resposta de mipadi e comentários no playground. E pensou em compartilhá-lo. Aqui está. Acho que a resposta de mipadi deve ser considerada aceita.

class A{
    class func classFunction(){
    }
    static func staticFunction(){
    }
    class func classFunctionToBeMakeFinalInImmediateSubclass(){
    }
}

class B: A {
    override class func classFunction(){

    }

    //Compile Error. Class method overrides a 'final' class method
    override static func staticFunction(){

    }

    //Lets avoid the function called 'classFunctionToBeMakeFinalInImmediateSubclass' being overriden by subclasses

    /* First way of doing it
    override static func classFunctionToBeMakeFinalInImmediateSubclass(){
    }
    */

    // Second way of doing the same
    override final class func classFunctionToBeMakeFinalInImmediateSubclass(){
    }

    //To use static or final class is choice of style.
    //As mipadi suggests I would use. static at super class. and final class to cut off further overrides by a subclass
}

class C: B{
    //Compile Error. Class method overrides a 'final' class method
    override static func classFunctionToBeMakeFinalInImmediateSubclass(){

    }
}
MadNik
fonte
27

Em relação ao POO , a resposta é muito simples:

As subclasses podem substituir métodos de classe , mas não podem substituir métodos estáticos .

Além da sua postagem, se você quiser declarar uma variável de classe (como você fez class var myVar2 = ""), faça o seguinte:

class var myVar2: String {
    return "whatever you want"
}
eMdOS
fonte
23

Eu também peguei essa confusão em um dos meus projetos e achei este post muito útil. Tentei o mesmo no meu playground e aqui está o resumo. Espero que isso ajude alguém com propriedades e funções do tipo armazenados static, final, class, classe substituindo vars etc.

class Simple {

    init() {print("init method called in base")}

    class func one() {print("class - one()")}

    class func two() {print("class - two()")}

    static func staticOne() {print("staticOne()")}

    static func staticTwo() {print("staticTwo()")}

    final func yesFinal() {print("yesFinal()")}

    static var myStaticVar = "static var in base"

    //Class stored properties not yet supported in classes; did you mean 'static'?
    class var myClassVar1 = "class var1"

    //This works fine
    class var myClassVar: String {
       return "class var in base"
    }
}

class SubSimple: Simple {
    //Successful override
    override class func one() {
        print("subClass - one()")
    }
    //Successful override
    override class func two () {
        print("subClass - two()")
    }

    //Error: Class method overrides a 'final' class method
    override static func staticOne() {

    }

    //error: Instance method overrides a 'final' instance method
    override final func yesFinal() {

    }

    //Works fine
    override class var myClassVar: String {
        return "class var in subclass"
    }
}

E aqui estão as amostras de teste:

print(Simple.one())
print(Simple.two())
print(Simple.staticOne())
print(Simple.staticTwo())
print(Simple.yesFinal(Simple()))
print(SubSimple.one())
print(Simple.myStaticVar)
print(Simple.myClassVar)
print(SubSimple.myClassVar)

//Output
class - one()
class - two()
staticOne()
staticTwo()
init method called in base
(Function)
subClass - one()
static var in base
class var in base
class var in subclass
Santosh
fonte
23

Os testes no Swift 4 mostram a diferença de desempenho no simulador. Eu fiz uma classe com "class func" e struct com "static static" e as executei no teste.

func estático é:

  • 20% mais rápido sem otimização do compilador
  • 38% mais rápido quando a otimização -whole-module-optimization está ativada.

No entanto, a execução do mesmo código no iPhone 7 no iOS 10.3 mostra exatamente o mesmo desempenho.

Aqui está um exemplo de projeto no Swift 4 para Xcode 9, se você quiser se testar https://github.com/protyagov/StructVsClassPerformance

Alex Protyagov
fonte
isso foi no simulador ou no dispositivo físico?
mmr118
7

Adicionar as respostas acima aos métodos estáticos é despacho estático significa que o compilador sabe qual método será executado em tempo de execução, pois o método estático não pode ser substituído, enquanto o método da classe pode ser um despacho dinâmico, pois a subclasse pode substituí-los.

Ankit garg
fonte
0

Há mais uma diferença. A classe pode ser usada para definir somente propriedades de tipo computado. Se você precisar de uma propriedade de tipo armazenado, use static.

Classe: - tipo de referência

struct: - tipo de valor


fonte
0

classé usado dentro Reference Type(classe):

  • propriedade computada
  • método
  • pode ser substituído pela subclasse

staticé usado dentro Reference Typee Value Type(classe, enum):

  • propriedade computada e propriedade armazenada
  • método
  • não pode ser alterado pela subclasse
protocol MyProtocol {
//    class var protocolClassVariable : Int { get }//ERROR: Class properties are only allowed within classes
    static var protocolStaticVariable : Int { get }

//    class func protocolClassFunc()//ERROR: Class methods are only allowed within classes
    static func protocolStaticFunc()
}

struct ValueTypeStruct: MyProtocol {
    //MyProtocol implementation begin
    static var protocolStaticVariable: Int = 1

    static func protocolStaticFunc() {

    }
    //MyProtocol implementation end

//    class var classVariable = "classVariable"//ERROR: Class properties are only allowed within classes
    static var staticVariable = "staticVariable"

//    class func classFunc() {} //ERROR: Class methods are only allowed within classes
    static func staticFunc() {}
}

class ReferenceTypeClass: MyProtocol {
    //MyProtocol implementation begin
    static var protocolStaticVariable: Int = 2

    static func protocolStaticFunc() {

    }
    //MyProtocol implementation end

    var variable = "variable"

//    class var classStoredPropertyVariable = "classVariable"//ERROR: Class stored properties not supported in classes

    class var classComputedPropertyVariable: Int {
        get {
            return 1
        }
    }

    static var staticStoredPropertyVariable = "staticVariable"

    static var staticComputedPropertyVariable: Int {
        get {
            return 1
        }
    }

    class func classFunc() {}
    static func staticFunc() {}
}

final class FinalSubReferenceTypeClass: ReferenceTypeClass {
    override class var classComputedPropertyVariable: Int {
        get {
            return 2
        }
    }
    override class func classFunc() {}
}

//class SubFinalSubReferenceTypeClass: FinalSubReferenceTypeClass {}// ERROR: Inheritance from a final class

[Referência versus tipo de valor]

yoAlex5
fonte