inheritance - Clases abstractas en Swift Language

abstract-class subclass

Question

¿Hay alguna manera de crear una clase abstracta en Swift Language, o es una limitación como Objective-C? Me gustaría crear una clase abstracta comparable a lo que Java define como una clase abstracta.

Answer 1

Creo que este es el más cercano al abstract de Java o al abstract C #:

class AbstractClass {
private init() {
}
}

Tenga en cuenta que, para que los modificadores private funcionen, debe definir esta clase en un archivo Swift diferente.

EDITAR: Aún así, este código no permite declarar un método abstracto y así forzar su implementación.

Answer 2

Después de luchar durante varias semanas, finalmente me di cuenta de cómo traducir una clase abstracta de Java / PHP a 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());
}
}

Sin embargo, creo que Apple no implementó clases abstractas porque generalmente usa el patrón delegado + protocolo. Por ejemplo, el mismo patrón anterior se haría mejor de esta manera:

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());
}
}

Necesitaba este tipo de patrón porque quería utilizar algunos métodos en UITableViewController, como viewWillAppear, etc. ¿Fue útil?

Answer 3

Hay una forma de simular clases abstractas usando Protocolos. Esto es un ejemplo:

protocol MyProtocol {
func doIt()
}
class BaseClass {
var myDelegate: MyProtocol!
init() {
...
}
func myFunc() {
...
self.myDelegate.doIt()
...
}
}
class ChildClass: BaseClass, MyProtocol {
override init(){
super.init()
self.myDelegate = self
}
func doIt() {
// Custom implementation
}
}

Answer 4

Intentaba crear una clase abstracta de Weather , pero el uso de protocolos no era ideal, ya que tenía que escribir los mismos métodos de init una y otra vez. Extendí el protocolo y escribí un método init con sus problemas, especialmente porque estaba usando NSObject conforme a NSCoding .

Así que se me ocurrió esto para la conformidad de 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...
}

En cuanto a init :

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

Answer 5

La forma más simple es usar una llamada a fatalError("Not Implemented") en el método abstracto (no variable) en la extensión del protocolo.

protocol MyInterface {
func myMethod() -> String
}
extension MyInterface {
func myMethod() -> String {
fatalError("Not Implemented")
}
}
class MyConcreteClass: MyInterface {
func myMethod() -> String {
return "The output"
}
}
MyConcreteClass().myMethod()

Answer 6

No hay clases abstractas en Swift (al igual que Objective-C). Su mejor opción será usar un Protocol , que es como una interfaz Java.

Con Swift 2.0, puede agregar implementaciones de métodos e implementaciones de propiedades calculadas mediante extensiones de protocolo. Sus únicas restricciones son que no puede proporcionar variables o constantes de miembro y no hay despacho dinámico .

Un ejemplo de esta técnica sería:

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

Tenga en cuenta que esto proporciona funciones similares a la "clase abstracta" incluso para las estructuras, pero las clases también pueden implementar el mismo protocolo.

También tenga en cuenta que cada clase o estructura que implementa el protocolo de Empleado tendrá que declarar nuevamente la propiedad anual de Salario.

Lo más importante es darse cuenta de que no hay un despacho dinámico . Cuando se llama a logSalary en la instancia que está almacenada como un SoftwareEngineer , llama a la versión anulada del método. Cuando se llama a logSalary en la instancia una vez que se ha enviado a un Employee , llama a la implementación original (no se distribuye dinámicamente a la versión reemplazada aunque la instancia sea en realidad un Software Engineer .

Para obtener más información, consulte el excelente video de WWDC sobre esta característica: Creación de mejores aplicaciones con tipos de valores en Swift

Answer 7

Una forma más de cómo puede implementar la clase abstracta es bloquear el inicializador. Lo hice de esta manera:

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

Answer 8

Tenga en cuenta que esta respuesta está dirigida a Swift 2.0 y superior

Puede lograr el mismo comportamiento con protocolos y extensiones de protocolo.

Primero, escribe un protocolo que actúa como interfaz para todos los métodos que deben implementarse en todos los tipos que se ajustan a él.

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

Luego puede agregar un comportamiento predeterminado a todos los tipos que se ajusten a él

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

Ahora puede crear nuevos tipos implementando Drivable .

struct Car: Drivable {
var speed: Float = 0.0
init() {}
}
let c = Car()
c.accelerate(10)

Entonces, básicamente, obtienes:

1. Realice comprobaciones de tiempo que garanticen que todos los Drivable s implementen la speed
2. Puede implementar el comportamiento predeterminado para todos los tipos que se ajusten a Drivable ( accelerate )
3. Drivable está garantizado para no ser instanciado ya que es solo un protocolo

Este modelo realmente se comporta mucho más como rasgos, lo que significa que puede ajustarse a múltiples protocolos y asumir implementaciones predeterminadas de cualquiera de ellos, mientras que con una superclase abstracta está limitado a una jerarquía de clases simple.