Абстрактные классы на Swift Language

Есть ли способ создать абстрактный класс в Swift Language, или это ограничение, как в Objective-C? Я хотел бы создать абстрактный класс, сопоставимый с тем, что Java определяет как абстрактный класс.

В Swift нет абстрактных классов (как и в Objective-C). Лучше всего будет использовать протокол , который похож на интерфейс Java.

В Swift 2.0 вы можете затем добавлять реализации методов и реализации вычисляемых свойств с использованием расширений протокола. Ваши единственные ограничения заключаются в том, что вы не можете предоставлять переменные-члены или константы и не использовать динамическую отправку .

Примером этой техники может быть:

protocol Employee {
    var annualSalary: Int {get}
}

extension Employee {
    var biweeklySalary: Int {
        return self.annualSalary / 26
    }

    func logSalary() {
        print("$\(self.annualSalary) per year or $\(self.biweeklySalary) biweekly")
    }
}

struct SoftwareEngineer: Employee {
    var annualSalary: Int

    func logSalary() {
        print("overridden")
    }
}

let sarah = SoftwareEngineer(annualSalary: 100000)
sarah.logSalary() // prints: overridden
(sarah as Employee).logSalary() // prints: $100000 per year or $3846 biweekly

Обратите внимание, что это обеспечивает функции, подобные «абстрактному классу», даже для структур, но классы также могут реализовывать тот же протокол.

Также обратите внимание, что каждый класс или структура, реализующие протокол Employee, должны будут снова объявить свойство AnnualSalary.

Самое главное, обратите внимание, что нет динамической отправки . Когда logSalaryвызывается в экземпляре, который хранится как объект, SoftwareEngineerон вызывает переопределенную версию метода. Когда logSalaryвызывается в экземпляре после того, как он был приведен к типу Employee, он вызывает исходную реализацию (она не отправляет динамически переопределенной версии, даже если экземпляр фактически является Software Engineer.

Для получения дополнительной информации посмотрите отличное видео WWDC об этой функции: Создание лучших приложений с типами значений в Swift

Обратите внимание, что этот ответ ориентирован на Swift 2.0 и выше.

Вы можете добиться того же поведения с протоколами и расширениями протоколов.

Сначала вы пишете протокол, который действует как интерфейс для всех методов, которые должны быть реализованы во всех типах, которые ему соответствуют.

protocol Drivable {
    var speed: Float { get set }
}

Затем вы можете добавить поведение по умолчанию для всех типов, которые ему соответствуют.

extension Drivable {
    func accelerate(by: Float) {
        speed += by
    }
}

Теперь вы можете создавать новые типы, реализуя Drivable.

struct Car: Drivable {
    var speed: Float = 0.0
    init() {}
}

let c = Car()
c.accelerate(10)

Итак, в основном вы получаете:

1. Compile проверка времени , что гарантирует , что все Drivableс реализациейspeed
2. Вы можете реализовать поведение по умолчанию для всех типов, которые соответствуют Drivable( accelerate)
3. Drivable гарантированно не будет создан, поскольку это просто протокол

Эта модель на самом деле больше похожа на черты, что означает, что вы можете соответствовать нескольким протоколам и использовать реализации любого из них по умолчанию, тогда как с абстрактным суперклассом вы ограничены простой иерархией классов.

Я думаю, что это ближе всего к Java abstractили C # abstract:

class AbstractClass {

    private init() {

    }
}

Обратите внимание, что для того private, чтобы модификаторы работали, вы должны определить этот класс в отдельном файле Swift.

РЕДАКТИРОВАТЬ: Тем не менее, этот код не позволяет объявить абстрактный метод и, следовательно, принудительно реализовать его.

Самый простой способ - использовать вызов fatalError("Not Implemented")абстрактного метода (не переменной) в расширении протокола.

protocol MyInterface {
    func myMethod() -> String
}


extension MyInterface {

    func myMethod() -> String {
        fatalError("Not Implemented")
    }

}

class MyConcreteClass: MyInterface {

    func myMethod() -> String {
        return "The output"
    }

}

MyConcreteClass().myMethod()

После нескольких недель борьбы я наконец понял, как перевести абстрактный класс Java / PHP в Swift:

public class AbstractClass: NSObject {

    internal override init(){}

    public func getFoodToEat()->String
    {
        if(self._iAmHungry())
        {
            return self._myFavoriteFood();
        }else{
            return "";
        }
    }

    private func _myFavoriteFood()->String
    {
        return "Sandwich";
    }

    internal func _iAmHungry()->Bool
    {
        fatalError(__FUNCTION__ + "Must be overridden");
        return false;
    }
}

public class ConcreteClass: AbstractClass, IConcreteClass {

    private var _hungry: Bool = false;

    public override init() {
        super.init();
    }

    public func starve()->Void
    {
        self._hungry = true;
    }

    public override func _iAmHungry()->Bool
    {
        return self._hungry;
    }
}

public protocol IConcreteClass
{
    func _iAmHungry()->Bool;
}

class ConcreteClassTest: XCTestCase {

    func testExample() {

        var concreteClass: ConcreteClass = ConcreteClass();

        XCTAssertEqual("", concreteClass.getFoodToEat());

        concreteClass.starve();

        XCTAssertEqual("Sandwich", concreteClass.getFoodToEat());
    }
}

Однако я думаю, что Apple не реализовала абстрактные классы, потому что вместо этого обычно использует шаблон делегат + протокол. Например, тот же шаблон выше лучше было бы сделать так:

import UIKit

    public class GoldenSpoonChild
    {
        private var delegate: IStomach!;

        internal init(){}

        internal func setup(delegate: IStomach)
        {
            self.delegate = delegate;
        }

        public func getFoodToEat()->String
        {
            if(self.delegate.iAmHungry())
            {
                return self._myFavoriteFood();
            }else{
                return "";
            }
        }

        private func _myFavoriteFood()->String
        {
            return "Sandwich";
        }
    }

    public class Mother: GoldenSpoonChild, IStomach
    {

        private var _hungry: Bool = false;

        public override init()
        {
            super.init();
            super.setup(self);
        }

        public func makeFamilyHungry()->Void
        {
            self._hungry = true;
        }

        public func iAmHungry()->Bool
        {
            return self._hungry;
        }
    }

    protocol IStomach
    {
        func iAmHungry()->Bool;
    }

    class DelegateTest: XCTestCase {

        func testGetFood() {

            var concreteClass: Mother = Mother();

            XCTAssertEqual("", concreteClass.getFoodToEat());

            concreteClass.makeFamilyHungry();

            XCTAssertEqual("Sandwich", concreteClass.getFoodToEat());
        }
    }

Мне нужен такой шаблон, потому что я хотел объединить некоторые методы в UITableViewController, такие как viewWillAppear и т. Д. Было ли это полезно?

Есть способ моделирования абстрактных классов с помощью протоколов. Это пример:

protocol MyProtocol {
   func doIt()
}

class BaseClass {
    weak var myDelegate: MyProtocol?

    init() {
        ...
    }

    func myFunc() {
        ...
        self.myDelegate?.doIt()
        ...
    }
}

class ChildClass: BaseClass, MyProtocol {
    override init(){
        super.init()
        self.myDelegate = self
    }

    func doIt() {
        // Custom implementation
    }
}

Еще один способ реализации абстрактного класса - заблокировать инициализатор. Я сделал это так:

class Element:CALayer { // IT'S ABSTRACT CLASS

    override init(){ 
        super.init()
        if self.dynamicType === Element.self {
        fatalError("Element is abstract class, do not try to create instance of this class")
        }
    }
}

Я пытался создать Weatherабстрактный класс, но использование протоколов не было идеальным, поскольку мне приходилось писать одни initи те же методы снова и снова. У расширения протокола и написания initметода были проблемы, особенно с учетом того, что я использовал NSObjectсоответствие NSCoding.

Итак, я придумал это для NSCodingсоответствия:

required init?(coder aDecoder: NSCoder) {
    guard type(of: self) != Weather.self else {
        fatalError("<Weather> This is an abstract class. Use a subclass of `Weather`.")
    }
    // Initialize...
}        

Что касается init:

fileprivate init(param: Any...) {
    // Initialize
}

Переместите все ссылки на абстрактные свойства и методы базового класса в реализацию расширения протокола, где собственное ограничение - в базовый класс. Вы получите доступ ко всем методам и свойствам Базового класса. Дополнительно компилятор проверяет реализацию абстрактных методов и свойств в протоколе для производных классов

protocol Commom:class{
  var tableView:UITableView {get};
  func update();
}

class Base{
   var total:Int = 0;
}

extension Common where Self:Base{
   func update(){
     total += 1;
     tableView.reloadData();
   }
} 

class Derived:Base,Common{
  var tableView:UITableView{
    return owner.tableView;
  }
}

С ограничением динамической отправки вы можете сделать что-то вроде этого:

import Foundation

protocol foo {

    static var instance: foo? { get }
    func prt()

}

extension foo {

    func prt() {
        if Thread.callStackSymbols.count > 30 {
            print("super")
        } else {
            Self.instance?.prt()
        }
    }

}

class foo1 : foo {

    static var instance : foo? = nil

    init() {
        foo1.instance = self
    }

    func prt() {
        print("foo1")
    }

}

class foo2 : foo {

    static var instance : foo? = nil

    init() {
        foo2.instance = self
    }

    func prt() {
        print("foo2")
    }

}

class foo3 : foo {

    static var instance : foo? = nil

    init() {
        foo3.instance = self
    }

}

var f1 : foo = foo1()
f1.prt()
var f2 : foo = foo2()
f2.prt()
var f3 : foo = foo3()
f3.prt()