Recently I came to know how little many beginner software developers know about Class and Object Relations in Object Oriented Programming. That’s why, I decided to start writing short and manageable articles in regards to Relations Between Objects And Classes.
During my upcoming blog posts, I’ll be focusing on topics such as Dependency, Association, Aggregation, Composition, Implementation and Inheritance.
Starting with Dependency.
#1: What is Dependency?
We are speaking of a Dependency when changes in the definition of class A results to modifications in class B. A dependency between objects occurs when using concrete classes in another class.
For example, when instantiating objects via a constructor method, or specifying input types in method and function signatures.
Note: class B can be modified by changes in class A.
A dependency is considered to be the most basic and weakest relations between objects.
Pseudo Code
class Registration is
method signup( _: User): User is
Registration class has a dependency to class User, because its method uses User as input and as a return type.
Note: We can make a dependency even weaker, if we depend our code on Interfaces (protocols ) instead of concrete classes.
interface UserInterface is
name: String
userName: String
password: String
class User implements UserInterface is
name: String
userName: String
password: String
method constructor(String name, String userName, String password) is
this.name = name
this.userName = userName
this.password = password
class Registration is
method signup( _: UserInterface): UserInterface is
Notice how Registration class now has a weaker dependency to the User class because now it uses an interface / protocol .
Swift Code – Dependency Using Concrete Class Name
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import Foundation class User { let name: String let userName: String let password: String init( name: String, userName: String, password: String) { self.name = name self.userName = userName self.password = password } } class Registration { func signup( _ user: User ) -> User { let user = user return user } } |
Swift Code – Weaker Dependency Through Using An Interface / Protocol
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
import Foundation //Defines a blue print //for any class that implements this interface //Multiple class can implement this interface protocol UserInterface { var name: String { get set } var userName: String { get set } var password: String { get set } } //User class implements UserInterface Protocol class User: UserInterface { var name: String var userName: String var password: String init( name: String, userName: String, password: String) { self.name = name self.userName = userName self.password = password } } //Registration class has a weaker dependency //To User class class Registration { func signup( _ user: UserInterface ) -> UserInterface { let user = user return user } } let user = User(name: "Robert", userName: "rob", password: "yusiyd87434") let registration = Registration() let output = registration.signup(user) print(output.userName) //rob |