Есть ли способ создать абстрактный класс в Swift Language, или это ограничение, как в Objective-C? Я хотел бы создать абстрактный класс, сопоставимый с тем, что Java определяет как абстрактный класс.
Есть ли способ создать абстрактный класс в 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
protocol Animal { var property : Int { get set } }
. Вы также можете не
func logSalary()
в объявление протокола Employee, пример будет напечатан overridden
для обоих вызовов logSalary()
. Это в Swift 3.1. Таким образом, вы получаете преимущества полиморфизма. В обоих случаях вызывается правильный метод.
Обратите внимание, что этот ответ ориентирован на 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)
Итак, в основном вы получаете:
Drivable
с реализациейspeed
Drivable
( accelerate
)Drivable
гарантированно не будет создан, поскольку это просто протоколЭта модель на самом деле больше похожа на черты, что означает, что вы можете соответствовать нескольким протоколам и использовать реализации любого из них по умолчанию, тогда как с абстрактным суперклассом вы ограничены простой иерархией классов.
UICollectionViewDatasource
,. Я хотел бы удалить весь шаблон и инкапсулировать его в отдельный протокол / расширение, а затем повторно использовать несколькими классами. На самом деле, шаблонный узор здесь был бы идеальным, но ...
Я думаю, что это ближе всего к 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()
(MyConcreteClass() as MyInterface).myMethod()
но это работает! Ключ включен 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()