OOP Principles & Data Models

But programming it is not just a way of giving instructions to a computer. It can also be a means of communication between humans, particularly in the context of team development, code reviews, and future maintenance of the software. Here are few points to keep in mind ...

Code Clarity

Code is more often read than it is written. Therefore, it is important to keep it clean and easily understood.

Code Consistency

Keeping your code consistent in terms of syntax, programming style and design patterns makes it easier to understand.

Documentation and Comments

Some code can become hard to understand despite our best effort. In these cases, comments and code documentation should be used to clarify the programmer's intent or communicate unintuitive information.

• Class name - should begin with an initial letter (capitalized by convention).
• Class header - class type parameters, the primary constructor, and other things, such as its superclass or interfaces it implements.
• Class properties - are defined in the class header and are used to hold the state of the class and its objects.
• Class body - containing properties, methods, constructors, initializer blocks, inner classes, and interfaces enclosed in curly braces.
  • Properties - additional properties that hold the state of the class and its objects.
  • Methods - functions that are part of the class and contain the executable code.
  • Constructors - special methods used to initialize the state of an object.
  • Initializer blocks - unnamed code blocks used for initializing shared variables and executing code that needs to run every time an instance of the class is created.
  • Inner classes and interfaces - class or interface definitions nested within the outer class body.
  • Companion objects - special objects that are tied to a class, rather than to an instance of a class.

• The process that creates an object from class is called instantiation
• Instantiation is done by calling a special constructor method
• Class may have one or more constructors
• If constructor is not explicitly defined, then the class will default constructor with no arguments
• Instantiation can be used to set initial values for the object

								
									class KotlinCourse {
										val subject: String = "Kotlin"
									}


									val kotlinCourse = KotlinCourse()
								
							

								
									class Course(val subject: String)


									val kotlinCourse = Course("Kotlin")
								
							

								
									class Course(
										val subject: String,
										val startDate: LocalDate,
										val endDate: LocalDate
									)


									val kotlinCourse = Course(
										"Kotlin",
										LocalDate.parse("2024-02-03"),
										LocalDate.parse("2024-02-21")
									)
								
							

• Every class has a constructor, even if it is not explicitly defined.
• Class may have multiple constructors (primary and secondary constructors).
• Constructor may have zero, one, or many arguments
• Class constructors support named arguments just like functions.

						
							// primary constructor defined by class header
							class UniversityCourse(
								val subject: String,
								val startDate: LocalDate,
								val endDate: LocalDate
							) {

								// alternate constructor
								constructor(
									subject: String,
									startDate: String,
									endDate: String,
								) : this(subject, LocalDate.parse(startDate), LocalDate.parse(endDate))
							}
						
					

						
							val kotlinCourse1 = UniversityCourse("Kotlin", LocalDate.parse("2024-02-03"), LocalDate.parse("2024-02-21"))
						
					

						
							val kotlinCourse3 = UniversityCourse("Kotlin", "2024-02-03", "2024-02-21")
						
					

						
							class UniversityCourse(
								val subject: String,
								val startDate: LocalDate,
								val endDate: LocalDate = startDate.plusDays(30),    // default date
								val students: MutableList<String> = mutableListOf() // default value of empty list
							) {
								// class body
							}
						
					

								
									UniversityCourse("Kotlin", LocalDate.parse("2024-02-03"))
								
							

								
									UniversityCourse(
										"Kotlin",
										LocalDate.parse("2024-02-03"),
										students = mutableListOf("Alice", "Bob")
									)
								
							

								
									UniversityCourse(
										subject = "Kotlin",
										startDate = LocalDate.parse("2024-02-03"),
										endDate = LocalDate.parse("2024-02-21"),
										students = mutableListOf("Alice", "Bob")
									)
								
							

Same rules and possibilities apply to methods as to functions not associated with a class.

						
							class UniversityCourse(
								val subject: String,
								val startDate: LocalDate,
								val endDate: LocalDate = startDate.plusDays(30),
								val students: MutableList<String> = mutableListOf()
							) {

								fun addStudent(studentName: String) {
									students.add(studentName)
								}

								fun removeStudent(studentName: String) {
									students.remove(studentName)
								}

								fun printStudents() {
									students.forEach { println(it) }
								}
							}
						
					

The only difference is that methods are called on an instance of object.

						
							val kotlinCourse = UniversityCourse("Kotlin", LocalDate.parse("2024-02-03"))
							kotlinCourse.addStudent("Alice")
							kotlinCourse.addStudent("Bob")
							kotlinCourse.printStudents()
						
					

For example, this can be used for additional argument validation or to set up some initial state.

Class may have one or more initializer blocks, which are executed in the order they are defined.

						
							class UniversityCourse(
								val subject: String,
								val startDate: LocalDate,
								val endDate: LocalDate = startDate.plusDays(30),
								val students: MutableList<String> = mutableListOf()
							) {

								init {
									require(startDate < endDate) { "End date must be after start date" }
								}

								init {
									println("Course $subject created")
								}

							}
						
					

						
							class Person(val name: String) {

								fun introduce(name: String) {
									println("${this.name} also goes by $name")
								}

							}
						
					

						
							fun main() {
								val person = Person("Monika")
								person.introduce("Moni") // prints "Monika also goes by Moni"
							}
						
					

						
							class A {
								inner class B {
									fun Int.foo() {
										val a = this@A // refers to the instance of A
										val b = this@B // refers to the instance of B
										val c = this // refers to the receiver Int
										println("a: $a, b: $b, c: $c")
									}
								}
							}
						
					

						
							fun main() {
								val a = A()
								val b = a.B()
								b.run { 42.foo() }
							}
						
					

						
							class OuterClass {

								private val outerVariable: String = "Outer Variable"

								// Inner class
								inner class InnerClass {
									fun accessOuterVariable(): String {
										return outerVariable
									}
								}
							}
							
					

						
							fun main() {
								val outer = OuterClass()
								val inner = outer.InnerClass()
								println(inner.accessOuterVariable()) // prints "Outer Variable"
							}
						
					

Logical Grouping

Encapsulation & Access Control

Increased Readability and Maintainability

Since it has no name, we have no way to instantiate such class.
Thus, an anonymous class must be declared and instantiated with a single expression.

An anonymous class must either implement an interface or extend an existing class (abstract or concrete).

Anonymous classes are useful for creating quick, one-off implementations of interfaces or abstract classes.

					
						fun main() {

							val runnable = object : Runnable {
								override fun run() {
									println("Running in an anonymous class!")
								}
							}

							val thread = Thread(runnable)

							thread.start()
						}
					
				

In Java and other languages, we used so called singleton pattern to create a class that can have only one instance.

Kotlin provides a convenient way to create singleton objects using the object keyword.

						
							object StringUtils {

								val DECIMAL_PLACES = 2

								fun formatNumber(number: Double): String {
									// code to format number
								}

							}
						
					

						
							fun main() {
								val formattedNumber = StringUtils.formatNumber(3.14159)
								println(formattedNumber) // prints "3.14"
							}
						
					

Some key features:

• Singleton - Only one instance of the object is created.
• Utility Methods - Commonly used for utility methods and constants.
• Initialization - The object is initialized when it is first accessed.
• No Constructors - Objects cannot have constructors.

Utility or Helper Classes

Sometimes we need some methods to be globally available in the application without needing to create class instance every time. Example of such is utility classs with static methods is String.valueOf() or Integer.toBinaryString().

Global Constants and Variables

Static keyword can be used to define class level variables hat are accessible throughout our application.

Singleton Pattern

Kotlin object is equivalent to Java's singleton pattern, but with the convenience of a simpler, error-proof syntax. Singleton class is a design pattern that restricts the instantiation of a class to a single instance.

• There can be only one companion object per class, and it is defined using the companion keyword.
• It may have a name, but it is optional. Otherwise, it is referred to as a default companion object.
• It is often used to define static methods and constants.
• Other than that, it is just like any other object.
• Companion objects are by convention placed at the bottom of the class.

						
							class UniversityCourse(
								val subject: String,
								val startDate: LocalDate,
								val endDate: LocalDate
							) {

								// regular class methods

								companion object UniversityCourseFactory { // companion object name is optional
									const val KOTLIN = "Kotlin"

									fun kotlinCourse(startDate: String, endDate: String): UniversityCourse {
										return UniversityCourse(KOTLIN, LocalDate.parse(startDate), LocalDate.parse(endDate))
									}
								}
							}
						
					

						
							fun main() {

								val kotlinCourse = UniversityCourse.kotlinCourse("2024-02-03", "2024-02-21")

								println(UniversityCourse.KOTLIN) // prints "Kotlin"

							}
						
					

A data model defines the shape and structure of data in terms of classes, properties, and relationships.

• In object-oriented programming, data models are typically expressed using classes that reflect real-world entities (e.g., User, User, Product).
• A good data model serves as a bridge between:
  • the business logic (how the system behaves),
  • the data storage (like a database),
  • and the API layer (how other systems communicate with it).

• In Java/Kotlin, this is typically achieved using access modifiers (private, protected, internal) and getter/setter methods.
• By using getter/setter methods, the class can enforce its own data validation rules to ensure it's internal state remains valid and consistent.

						
							data class Assignment(
								val dueDate: LocalDate,
								val assignee: String,
							) {
								private var finalGrade: Int? = null

								fun getFinalGrade(): Int? {
									return finalGrade
								}

								fun setFinalGrade(finalGrade: Int) {
									require(finalGrade in 0..100) { "Final grade must be between 0 and 100" }
									this.finalGrade = finalGrade
								}
							}
						
					

						
							fun main() {
								val assignment = Assignment(LocalDate.now(), "John Doe")
								assignment.setFinalGrade(90)
								println(assignment.getFinalGrade())
							}
						
					

The class that inherits is called subclass and the class inherited from is called superclass.

• The class to be inherited from must be marked as open.
• To define inheritance, the : symbol is used followed by the superclass name, for example class Dog : Animal().
• If a superclass has a non-default constructor, you must call super() method in the subclass constructor.
• You can mark methods and attributes of a superclass as protected. This will make them only accessible within the same package or within subclass.
• You can reference fields and methods in the superclass class using the super keyword.
• To prevent inheritance, you can mark the class with final modifier.

Let's have a look at this in detail ...

						
							fun main() {
								val cat = Cat("meow")
								cat.makeSound()

								val dog = Dog()
								dog.makeSound()

								// this would not compile, because makeRawSound is protected
								// dog.makeRawSound();

								val bird = Bird("tweet")
								bird.makeSound()
							}
						
					

						
							open class Cat {

								final fun meow() {
									System.out.println("meow");
								}

							}
						
					

We are trying to override the meow method, the compiler will throw an error.

						
							class MyCat: Cat() {


								// This will not compile
								override fun meow() { }

							}
						
					

Promotes code reuse Inheritance allows subclasses to inherit methods and fields from superclasses which leads to a reduction in code duplication.

Promotes polymorphism Subclasses can redefine certain methods based on their requirement.

Hierarchy and organization Inheritance helps to design the software in a hierarchical manner where classes with general characteristics are at a higher level and classes with specific characteristics are at lower level.

Tight coupling A subclass is tightly coupled with its superclass. If the superclass is modified, subclasses could be affected, as they inherit methods and fields from the superclass.

Inheritance chain Inheritance often leads to long chains which could make tracking down errors in the code difficult.

Issues with multiple inheritance Kotlin does not support multiple inheritance (a class can’t extend more than one class).
However, it supports multiple interface implementation, which is a partial workaround for this issue.

Memory overhead When a subclass object is created, a separate memory space is reserved for it in addition to the separate memory space reserved for the superclass object. This might result in memory wastage if the subclass makes limited use of the superclass's features.

Pros

• Results in loose coupling and improves encapsulation, because the contained objects can be easily swapped without changing the code that uses them.
• Can be used to overcome lack of multiple inheritance in Kotlin.
• Usually allows for better testability as well.

Cons

• It can result in bloated classes if overused, and requires more code setup than inheritance.
• it can be more difficult to use when requests must be delegated to the appropriate class.

						
							fun main() {
								val cat = Cat("Garfield")
								cat.meow()
							}
						
					

Both inheritance and composition have their strengths and weaknesses. Deciding when to use each can be instrumental for designing cleaner and more effective code.

The two techniques can be, and often are, combined.

						
							fun main() {
								val cat = Cat("Garfield", Sound("meow"))
								cat.makeSound()
							}
						
					

									
										open class Animal(private val sound: Sound) {
											fun makeSound() {
												sound.makeSound()
											}
										}
									
								

									
										class Sound(private val sound: String) {
											fun makeSound() {
												println(sound)
											}
										}
									
								

									
										class Cat(val name: String, sound: Sound) : Animal(sound)
									
								

Compile-time polymorphism is achieved through method overloading. The correct method to call is determined by the compiler at compile time based on the method signature.

						
						fun main() {

							val result1 = Calculator.add(10, 20)
							val result2 = Calculator.add(10, 20, 30)

							println(result1)    // prints 30
							println(result2)    // prints 60
						}
						
					

						
						object Calculator {

							// method with 2 parameters
							fun add(a: Int, b: Int): Int {
								return a + b
							}

							// overloaded method with 3 parameters
							fun add(a: Int, b: Int, c: Int): Int {
								return a + b + c
							}
						}
						
					

Method overloading = defining two or more methods in a class with the same name but different signature.

Method signature = combination of the method name, return type and the parameters.

Runtime polymorphism is a process in which a call to an overridden method is resolved at runtime rather than at compile-time. This mechanism allows the Java Virtual Machine (JVM) to decide which method to invoke from the class hierarchy at runtime, based on the type of object.

						
							fun main() {
								val animal0 = Animal()

								val animal1: Animal = Dog() // Animal reference but Dog object
								val animal2: Animal = Cat() // Animal reference but Cat object

								animal0.makeSound() // prints "(silence)"
								animal1.makeSound() // prints "woof"
								animal2.makeSound() // prints "meow"
							}
						
					

									
										open class Animal {
											open fun makeSound() {
												println("(silence)")
											}
										}
									
								

									
										class Dog : Animal() {
											override fun makeSound() {
												println("woof")
											}
										}
									
								

									
										class Cat : Animal() {
											override fun makeSound() {
												println("meow")
											}
										}
									
								

Abstract class cannot be instantiated directly. The main purpose of an abstract class is encapsulating common behavior that can be shared among multiple subclasses, while allowing each subclass to implement its own behavior either by overriding abstract methods, adding new methods or fields, or overriding non-abstract methods.

• Abstract classes can have constructors, but they cannot be directly instantiated.
• They can contain both abstract and non-abstract methods.
• Abstract methods must be implemented by subclasses.
• Non-abstract methods can be optionally overridden by subclasses.

In Kotlin, an interface is a reference type similar to a class. It can contain abstract methods and properties, as well as default method implementations. Interfaces cannot store state and cannot have constructors. They are used to define a contract that classes can implement.

Therefore, interface cannot be directly instantiated, just like abstract class. You could say interface is a 100% abstract class.

• Interfaces are declared using the interface keyword.
• All methods in an interface are abstract by default, but they can also have default implementations.
• Interfaces can contain properties, but these properties must be abstract or have default implementations.
• A class implements an interface using the : symbol followed by the interface name.
• A class can implement multiple interfaces, allowing for a form of multiple inheritance.

We will cover:

• What is testing?
• Why do we test?
• Types of tests
• Levels of tests
• Test design techniques

We will also write some tests using Kotest.