Kotlin and Object Oriented Programming

A talk given at Gett regarding OOP in Kotlin with respects to the SOLID principles of design

Transcript

2. Agenda • Object-Oriented Introduction • Kotlin and OOP • SOLID Principles
3. What is Object Oriented Programming (OOP)? • A programming paradigm ◦ “Everything is an object” • Smalltalk (around 1970) • “Real-World” modeling and programming • Introduces ◦ Abstraction ◦ Encapsulation ◦ Inheritance ◦ Polymorphism
4. Why OOP • It’s well known and accepted • Allows for state organization • Flow of control through interfaces and abstractions
5. Flow Of Control Main Function High-Level Modules High-Level Modules Low-Level Modules Low-Level Modules Low-Level Modules Low-Level Modules
6. Main Function High-Level Modules High-Level Modules Low-Level Modules Low-Level Modules Low-Level Modules Low-Level Modules Flow Of Control With Abstractions High-Level Interface High-Level Interface Low-Level Interface Low-Level Interface Low-Level Interface Low-Level Interface
7. Agenda • Object-Oriented Introduction • Kotlin and OOP • SOLID Principles
8. Kotlin and OOP • Everything is an object • Primitives are boxed at compile time • Classes are derived from Any (Or Any?) • Not covered in this session ◦ Nullable classes are derived from Any? ◦ Nothing is also something but it’s not Any ◦ Generics
9. Kotlin and OOP - Basics • Classes class Person(val firstName: String, val lastName: String) { fun fullName(): String = "$firstName $lastName" } interface Person { val age: Int fun fullName(): String } abstract class Person(val firstName: String, val lastName: String) { abstract fun fullName(): String } • Interfaces • Abstract Classes
10. Kotlin and OOP - Basics • Enum Classes enum class Person { ALEX { override fun sayName() = "Alex" }, DOR { override fun sayName() = "Dor" }, IGOR { override fun sayName() = "Igor" }; abstract fun sayName(): String }
11. Kotlin and OOP - Inheritance • A class may only extend one class • A class may implement many interfaces • An interface may extend other interfaces • To do all of this - use a colon (:)
12. Inheritance Example interface Person { fun fullName(): String } abstract class Bob(open val firstName: String): Person { abstract fun fullName(): String //can be omitted fun sayName(): String = "My Name Is $firstName" }
13. Inheritance Example - Continued class BobDylan: Bob("Bob") { override fun fullName(): String = "${sayName()} Dylan" } class BobDole(override val firstName: String = "Bob", val lastName: String = "Dole"): Bob(firstName) { override fun fullName(): String = "I'm Bob Dole" } abstract class Bob(open val firstName: String): Person { abstract fun fullName(): String //can be omitted (from person) fun sayName(): String = "My Name Is $firstName" }
14. Kotlin and OOP - Not So Basic • Data Classes • Sealed Classes • Smart Casting
15. Data Classes data class Elvis(val firstName: String = "Elvis", val lastName: String = "Presley") open data class Elvis(val firstName: String = "Elvis", val lastName: String = "Presley") Compiler will complain!
16. Sealed Classes sealed class Person(val firstName: String, val lastName: String) { class Dor: Person("Dor", "Samet") class Alex(val age: Int, fName: String, lName: String) : Person(fName, lName) }
17. Sealed Classes - Since Kotlin 1.1 sealed class Person(val firstName: String, val lastName: String) class Dor: Person("Dor", "Samet") data class Alex(val age: Int, fName: String, lName: String) : Person(fName, lName)
18. Smart Casting fun translatePerson(person: Person): String = when (person) { is Person.Dor -> { "${person.firstName} ${person.lastName}" } is Person.Alex -> { "${person.fName} ${person.lName}, of age ${person.age}" } }
19. Questions
20. Agenda • Object-Oriented Introduction • Kotlin and OOP • SOLID Principles
21. SOLID Principles SRP - Single Responsibility Principle OCP - Open/Closed Principle LSP - Liskov Substitution Principle ISP - Interface Segregation Principle DIP - Dependency Inversion Principle
22. SOLID Kotlin Language Features SRP - Single Responsibility Principle - “by” keyword which will get its own talk OCP - Open/Closed Principle LSP - Liskov Substitution Principle ISP - Interface Segregation Principle DIP - Dependency Inversion Principle - named and default parameters
23. Open/Closed Principle “I am open to extensions and closed to modifications”
24. Open/Closed Principle Open/Override • Classes are final by default • Must explicitly write “open” for extendable classes and methods • Must explicitly write “override” for extending classes and methods
25. Open/Closed Principle Example open class Developer(val language: String) { open fun writeCode() = "I Write code in $language" } open class JavaDeveloper(otherLanguage: String) : Developer(otherLanguage) { open val version = "9" constructor(): this("Java") //Secondary Constructor override fun writeCode(): String = writeJavaCode() protected open fun writeJavaCode() = "public static void main(String[] args)" } class KotlinDeveloper: JavaDeveloper("Kotlin") { override val version: String = "1.1" override fun writeJavaCode(): String = writeKotlinCode() private fun writeKotlinCode(): String = "fun main(args: Array<String>)" }
26. Open/Closed Principle Example fun main(args: Array<String>) { val developerA = JavaDeveloper() val developerB = KotlinDeveloper() developerA.writeCode() // “public static void main(String[] args)” developerB.writeCode() // “fun main(args: Array<String>)” }
27. Liskov Substitution Principle “Replacing me with my parent should not break the system”
28. Liskov Substitution Principle Type Inference • Built-in type inference • Exchanging between items using type inference is not even a line • Sealed classes • When expressions • Smart casting
29. Type Inference - Revisited fun main(args: Array<String>) { val developerA = JavaDeveloper() // JavaDeveloper -> Developer val developerB = KotlinDeveloper() // KotlinDeveloper -> Developer developerA.writeCode() developerB.writeCode() } Can we do better?
30. Liskov Substitution Principle Example fun generateDeveloper(language: String): Developer = when(language) { "Java" -> JavaDeveloper() "Kotlin" -> KotlinDeveloper() else -> Developer(language) } fun doWork(developer: Developer) { developer.writeCode() }
31. Liskov Substitution Principle Example fun main(args: Array<String>) { val developer = generateDeveloper("Java") doWork(developer) }
32. Liskov Substitution Principle Example fun main(args: Array<String>) { val developer = generateDeveloper("Kotlin") doWork(developer) }
33. Liskov Substitution Principle Example fun main(args: Array<String>) { val developer = generateDeveloper("Python") doWork(developer) }
34. Interface Segregation Principle “I should not be forced to implement methods I do not need”
35. Interface Segregation Principle Interfaces are basically abstract classes with all abstract methods • A class may implement multiple interfaces • Interfaces may have default implementations of functions • Interfaces may have members
36. Interface Segregation Principle Example interface JavaProgrammer { fun writeJavaCode(): String } interface KotlinProgrammer { fun writeKotlinCode(): String }
37. Interface Segregation Principle Example open class JavaDeveloper(otherLanguage: String) : Developer(otherLanguage), JavaProgrammer { open val version = "9" constructor(): this("Java") override fun writeCode(): String = writeJavaCode() override fun writeJavaCode() = "public static void main(String[] args)" }
38. Interface Segregation Principle Example class KotlinDeveloper: JavaDeveloper("Kotlin"), KotlinProgrammer { override val version: String = "1.1" override fun writeJavaCode(): String = writeKotlinCode() override fun writeKotlinCode(): String = "fun main(args: Array<String>)" }
39. Interface Segregation Principle Example class KotlinDeveloper: Developer("Kotlin"), KotlinProgrammer { override val version: String = "1.1" override fun writeKotlinCode(): String = "fun main(args: Array<String>)" }
40. Questions
41. Thank You