Given the following example:
class ProfileTab: Identifiable {
let id = UUID()
let name: String
init(name: String) {
self.name = name
}
}
class ProfileQuoteTab: ProfileTab {
let answer: String
let prompt: String
init(name: String, answer: String, prompt: String) {
self.answer = answer
self.prompt = prompt
super.init(name: name)
}
}
class ProfileImageTab: ProfileTab {
let image: Image
init(name: String, image: Image) {
self.image = image
super.init(name: name)
}
}
struct ContentView: View {
let tabs: [ProfileTab] = [
ProfileQuoteTab(name: "This is a quote tab", answer: "This is an answer", prompt: "This is a prompt"),
ProfileImageTab(name: "This is an image tab", image: Image(systemName: "faceid"))
]
var body: some View {
List(self.tabs) { tab in
VStack {
if tab is ProfileQuoteTab {
Text((tab as! ProfileQuoteTab).answer)
}
if tab is ProfileImageTab {
(tab as! ProfileImageTab).image
}
}
}
}
}
Is there a better/recommended way of accessing properties on different classes within my ProfileTab
array?
I know doing this will result in:
Closure containing control flow statement cannot be used with function builder 'ViewBuilder'
if let profileImage = tab as? ProfileImage {
...
}
Is there a cleaner way rather than doing the following?
(tab as! ProfileImageTab).image
polymorphism is about provisioning a single interface to entities of different types. Although it is usually underestimated, it is one of the most powerful concepts in software engineering that lets you define different behaviors for different objects while you are still using a shared interface among them.
The short answer: no.
Polymorphism (in Swift) In the context of Object Oriented Programming, this means the provision of a single interface to entities of different types. The interface provided by the objects is the same, but what’s going on under the hood might vary depending on, perhaps, the message sent, or the type passed to a particular function for example.
Polymorphism is the method in an object-oriented programming language that performs different things as per the object’s class, which calls it. With Polymorphism, a message is sent to multiple class objects, and every object responds appropriately according to the properties of the class.
Polymorphism is a mechanism to dynamically decide what form of a function should be invoked. Polymorphism allows the expression of common behavior between types of objects which have similar traits. Inheritance can be thought of as one of the mechanisms we can use to achieve polymorphism in our code via the use...
In Object-Oriented Programming (OOPS) language, there are two types of polymorphism as below: 1. Compile Time or Static Polymorphism With Method Overloading, static polymorphism is achieved in Object-Oriented Programming languages that allow the programmer to implement various methods.
In the described use-case the polymorphism would look like the following (or in some variations):
class ProfileTab: Identifiable {
let id = UUID()
let name: String
init(name: String) {
self.name = name
}
func view() -> AnyView {
AnyView(EmptyView())
}
}
class ProfileQuoteTab: ProfileTab {
let answer: String
let prompt: String
init(name: String, answer: String, prompt: String) {
self.answer = answer
self.prompt = prompt
super.init(name: name)
}
override func view() -> AnyView {
AnyView(Text(self.answer))
}
}
class ProfileImageTab: ProfileTab {
let image: Image
init(name: String, image: Image) {
self.image = image
super.init(name: name)
}
override func view() -> AnyView {
AnyView(self.image)
}
}
struct ContentView: View {
let tabs: [ProfileTab] = [
ProfileQuoteTab(name: "This is a quote tab", answer: "This is an answer", prompt: "This is a prompt"),
ProfileImageTab(name: "This is an image tab", image: Image(systemName: "faceid"))
]
var body: some View {
List(self.tabs) { tab in
VStack {
tab.view()
}
}
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With