Compare Protocol in Swift vs Interface in Java
JavaSwiftJava Problem Overview
I'm going through the iOS tutorial from Apple developer page.
It seems to me that protocol
and interface
almost have the same functionality.
-
Are there any differences between the two?
-
the different usage in the project?
Updated
Yes, I did read the link above and I'm still not sure what the differences and usage between protocol
and interface
. When I ask a question like this, I would like to see a simple explanation about the topic. Sometime it could be tough to get everything from the documentation.
Java Solutions
Solution 1 - Java
Essentially protocols are very similar to Java interfaces except for:
- Swift protocols can also specify properties that must be implemented (i.e. fields)
- Swift protocols need to deal with value/reference through the use of the mutating keyword (because protocols can be implemented by structures, enumerations or classes).
- you can combine protocols at any point using "Protocol Composition". This replaces the older swift
protocol<A, B>
way of protocol composition. For example, declaring a function parameter that must adhere to protocolNamed
andAged
as:
func wishHappyBirthday(to celebrator: Named & Aged) {}
These are the immediately apparent differences for a Java developer (or at least what I've spotted so far). There's more info here.
Solution 2 - Java
Complementing @Thomas Schar's answer. The Swift protocol magic comes from the extension.
- Swift protocols can get implementations via the extension (Swift
2). Java 8 interface can have default implementations, but it cannot be done "retroactively." - In Swift, you can "retroactively" add protocol requirements (and
its implementations if needed) to any class or structure. - Swift protocols do not follow the generic (i.e <..>) customization pattern,
but a typealias scheme (i.e. Associated Types). Can be confusing at the start, but can avoid
"angle bracket blindness" in some cases. - Swift has an advanced type pattern matching, allowing to be very specific on where and how protocol requirements and extensions get applied. It can be confusing when coming from Java, but it has a lot of power.
- A swift protocol can be composed for a property/param (i.e. celebrator:
protocol
)
One thing that got me scratching my head for a couple of hours is that not all protocols can be used as property types. For example, if you have a protocol with typealias, you cannot directly use it as a type of property (it makes sense when you think about it, but coming from Java we really want to have a property like userDao: IDao
Solution 3 - Java
Just adding one thing because I've been checking protocols combining: > you can combine protocols at any point with the protocol<> keyword.
This is no longer true. Based on this: https://github.com/apple/swift/blob/master/test/type/protocol_composition.swift
This is correct:
func foo ( var1 : A & B ){}