İçeriğe geç

Swift 3 ile open class kullanımı

Swift 3

Merhabalar bu yazımda Swift 3 ile yeni gelen open adında sınıf türünden bahsedeceğim.

Bildiğimiz gibi Nesne yönelimli (OOP) programlama dillerinde genel olarak Public,Protected(Internal),Private vardır. Ancak Swift‘te bunlara ek olarak 2 adet daha ek vardır.

Bunlar fileprivate,open dir. Swift 3 ile birlikte dile eklenmiş sınıf yapılarıdır.

open sınıf yapısı’da bunlardan biri diğer yazımda fileprivate’den bahsetmiştim. Bu yapı normal tek modul kullanımlarında public kullanımdan bir farkı yok. Ancak farklı 2 modul arasında işler değişiyor. A modulunde tanımlanmış sınıf ve fonksiyonlar, B modulunde kullanılabilinmesi için open olarak tanımlı bir sınıf gerekli ve fonksiyon open olarak override edilmeli.

Not: open class yapısını çıkarmalarının nedeni kütüphaneler arası sınıfların bir biri arasında override ve alt sınıf ilişkilerini düzene sokmaktır. Çünkü public yapı farklı moduller arasında eğer bir sınıf veya fonksiyon public tanımlıysa diğer modulde alt sınıf olamaz ve fonksiyonlar override edilemez.

Access Level olarak Swift 3 ” open > public > internal > fileprivate > private  şeklinde tanımlanmıştır.

Aşağıda basit bir şekilde open örneğini verdim inceleyebilirsiniz.

open class A {
    
    open var name:String = ""
    
    init(name:String) {
        
        self.name = name
    }
    
    open func foo(str:String) {
        
        self.name += " \(str)"
        
    }
    
}

class B:A {

    override func foo(str: String) {
    
        super.foo(str: " \(str)")
        
    }
    
}

var obj = A(name: "Kenan")
obj.name // Kenan
obj.foo(str: "Atmaca")
obj.name // Kenan Atmaca


var objB = B(name: "Ankara")
objB.name // Ahmet
objB.foo(str: "İzmir")
objB.name // Ankara İzmir

Diğer bir örnekte moduller yapı üzerinde open kullanırken override yapıyı anlamanız için Swift ekibi tarafından verilmiş.

/// ModuleA:

// This class is not subclassable outside of ModuleA.
public class NonSubclassableParentClass {
    // This method is not overridable outside of ModuleA.
    public func foo() {}

    // This method is not overridable outside of ModuleA because
    // its class restricts its access level.
    // It is not invalid to declare it as `open`.
    open func bar() {}

    // The behavior of `final` methods remains unchanged.
    public final func baz() {}
}

// This class is subclassable both inside and outside of ModuleA.
open class SubclassableParentClass {
    // This property is not overridable outside of ModuleA.
    public var size : Int

    // This method is not overridable outside of ModuleA.
    public func foo() {}

    // This method is overridable both inside and outside of ModuleA.
    open func bar() {}

    /// The behavior of a `final` method remains unchanged.
    public final func baz() {}
}

/// The behavior of `final` classes remains unchanged.
public final class FinalClass { }
/// ModuleB:

import ModuleA

// This is invalid because the superclass is defined outside
// of the current module but is not `open`.
class SubclassA : NonSubclassableParentClass { }

// This is allowed since the superclass is `open`.
class SubclassB : SubclassableParentClass {
    // This is invalid because it overrides a method that is
    // defined outside of the current module but is not `open'.
    override func foo() { }

    // This is allowed since the superclass's method is overridable.
    // It does not need to be marked `open` because it is defined on
    // an `internal` class.
    override func bar() { }
}

open class SubclassC : SubclassableParentClass {
    // This is invalid because it overrides an `open` method within
    // an `open` class but is not declared `open`.
    override func bar() { } 
}

open class SubclassD : SubclassableParentClass {
    // This is valid.
    open override func bar() { }    
}

open class SubclassE : SubclassableParentClass {
    // This is also valid.
    public final override func bar() { }    
}

Github link.

Tarih:SwiftSwift 3

Bu yazı yorumlara kapalı.

Copyright © 2021 Kenan Atmaca