Lesson 3 - Classes and Objects

Lesson 3:
Classes and
objects
Android Development with Kotlin v1.0 This work is licensed under the Apache 2 license. 1
About this lesson
Lesson 3: Classes and objects
○ Classes
○ Inheritance
○ Extension functions
○ Special classes
○ Organizing your code
○ Summary
Android Development with Kotlin This work is licensed under the Apache 2 license. 2
Classes
Class
Object
● Classes are blueprints for objects
instances
● Classes define methods that operate
on their object instances
Class
Class versus object instance
House Class Object Instances
Data
● House color (String)
● Number of windows (Int)
● Is for sale (Boolean)
Behavior
● updateColor()
● putOnSale() FOR SALE
Define and use a class
Class Definition Create New Object Instance
Constructors
When a constructor is defined in the class header, it can contain:
● No parameters
class A
● Parameters
○ Not marked with var or val → copy exists only within scope of the
constructor
class B(x: Int)
○ Marked var or val → copy exists in all instances of the class
class C(val y: Int)
Constructor examples
Default parameters
Class instances can have default values.
● Use default values to reduce the number of constructors needed
● Default parameters can be mixed with required parameters
● More concise (don’t need to have multiple constructor versions)
Primary constructor
Declare the primary constructor within the class header.
This is technically equivalent to:
Initializer block
● Any required initialization code is run in a special init block

● Multiple init blocks are allowed
● init blocks become the body of the primary constructor
Initializer block example
Use the init keyword:
Multiple constructors
● Use the constructor keyword to define secondary constructors

● Secondary constructors must call:
○ The primary constructor using this keyword
OR
○ Another secondary constructor that calls the primary constructor

● Secondary constructor body is not required
Multiple constructors example
Properties
● Define properties in a class using val or var

● Access these properties using
dot . notation with property name
● Set these properties using
dot . notation with property name (only if declared a var)
Person class with name property
Access with <property name>

Set with <property name>
Custom getters and setters
If you don’t want the default get/set behavior:
● Override get() for a property

● Override set() for a property (if defined as a var)
Format:
Custom getter
Custom setter
Member functions
● Classes can also contain functions

● Declare functions as shown in Functions in Lesson 2
○ fun keyword
○ Can have default or required parameters
○ Specify return type (if not Unit)
Inheritance
Inheritance
● Kotlin has single-parent class inheritance

● Each class has exactly one parent class, called a superclass
● Each subclass inherits all members of its superclass including
ones that the superclass itself has inherited
If you don't want to be limited by only inheriting a single class, you can define an
interface since you can implement as many of those as you want.
Interfaces
● Provide a contract all implementing classes must adhere to
● Can contain method signatures and property names
● Can derive from other interfaces
Format:
Interface example
Extending classes
To extend a class:
● Create a new class that uses an existing class as its core
(subclass)
● Add functionality to a class without creating a new one
(extension functions)
Creating a new class
● Kotlin classes by default are not subclassable
● Use open keyword to allow subclassing
● Properties and functions are redefined with the override

keyword
Classes are final by default
Declare a class
Try to subclass
Use keyword
Use open to declare a class so that it can be subclassed.
Declare a class
Subclass from C
Overriding
● Must use open for properties and methods that can be overridden
(otherwise you get compiler error)
● Must use override when overriding properties and methods
● Something marked override can be overridden in subclasses

(unless marked final)
Abstract classes
● Class is marked as abstract
● Cannot be instantiated, must be subclassed
● Similar to an interface with the added the ability to store state
● Properties and functions marked with abstract must be
overridden
● Can include non-abstract properties and functions
Example abstract classes
abstract class Food {
abstract val kcal : Int
abstract val name : String
fun consume() = println("I'm eating ${name}")
}
class Pizza() : Food() {
override val kcal = 600
override val name = "Pizza"
}
fun main() {
Pizza().consume() // "I'm eating Pizza"
}
When to use each
● Defining a broad spectrum of behavior or types? Consider an interface.
● Will the behavior be specific to that type? Consider a class.
● Need to inherit from multiple classes? Consider refactoring code to see

if some behavior can be isolated into an interface.
● Want to leave some properties / methods abstract to be defined by

subclasses? Consider an abstract class.
● You can extend only one class, but implement one or more interfaces.
Extension functions
Extension functions
Add functions to an existing class that you cannot modify directly.
● Appears as if the implementer added it
● Not actually modifying the existing class
● Cannot access private instance variables
Format:
Why use extension functions?
● Add functionality to classes that are not
● Add functionality to classes you don’t own
● Separate out core API from helper methods for classes you
own
Define extension functions in an easily discoverable place such as in the same file
as the class, or a well-named function.
Extension function example
Add isOdd() to Int class:
Call isOdd() on an Int:
Extension functions are very powerful in Kotlin!
Special classes
Data class
● Special class that exists just to store a set of data
● Mark the class with the data keyword
● Generates getters for each property (and setters for vars too)
● Generates toString(), equals(), hashCode(), copy()

methods, and destructuring operators
Format:
Data class example
Define the data class:
Use the data class:
Data classes make your code much more concise!
Pair and Triple
● Pair and Triple are predefined data classes that store

2 or 3 pieces of data respectively
● Access variables with .first, .second, .third respectively
● Usually named data classes are a better option

(more meaningful names for your use case)
Pair and Triple examples
Pair
Pair's special to variant lets you omit parentheses and periods (infix function).
It allows for more readable code
Also used in collections like Map and HashMap
Enum class
User-defined data type for a set of named values
● Use this to require instances be one of several constant values

● The constant value is, by default, not visible to you
● Use enum before the class keyword
Format: …
Referenced via
Enum class example
Define an enum with red, green, and blue colors.
Object/singleton
● Sometimes you only want one instance of a class to ever exist
● Use the object keyword instead of the class keyword
● Accessed with NameOfObject.<function or variable>
Object/singleton example
Companion objects
● Lets all instances of a class share a single instance of a set of

variables or functions
● Use companion keyword
● Referenced via ClassName.PropertyOrFunction
Companion object example
Organizing your code
Single file, multiple entities
● Kotlin DOES NOT enforce a single entity (class/interface)

per file convention
● You can and should group related structures in the same file
● Be mindful of file length and clutter
Packages
● Provide means for organization
● Identifiers are generally lower case words separated by periods
● Declared in the first non-comment line of code in a file

following the package keyword
package org.example.game
Example class hierarchy
org.example.vehicle
Vehicle
org.example.vehicle.moped org.example.vehicle.car
Moped Car
Moped50cc Sedan
Moped100cc Hatchback
Visibility modifiers
Use visibility modifiers to limit what information you expose.
● public means visible outside the class. Everything is public by default,

including variables and methods of the class.
● private means it will only be visible in that class (or source file if you are
working with functions).
● protected is the same as private, but it will also be visible to any
subclasses.
Summary
Summary
In Lesson 3, you learned about:
● Classes, constructors, and getters and setters
● Inheritance, interfaces, and how to extend classes
● Extension functions
● Special classes: data classes, enums, object/singletons, companion
objects
● Packages
● Visibility modifiers
Pathway
Practice what you’ve learned by

completing the pathway:
Lesson 3: Classes and objects

Lesson 3 - Classes and Objects

Uploaded by

Copyright:

Available Formats

Lesson 3 - Classes and Objects

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lesson 3 - Classes and Objects

Uploaded by

Copyright:

Available Formats

Lesson 3:

This is technically equivalent to:

● Any required initialization code is run in a special init block

● Use the constructor keyword to deﬁne secondary constructors

○ Another secondary constructor that calls the primary constructor

● Deﬁne properties in a class using val or var

Access with <property name>

● Override get() for a property

● Classes can also contain functions

● Kotlin has single-parent class inheritance

● Provide a contract all implementing classes must adhere to

● Can contain method signatures and property names

● Can derive from other interfaces

● Kotlin classes by default are not subclassable

● Use open keyword to allow subclassing

● Properties and functions are redeﬁned with the override

● Must use override when overriding properties and methods

● Something marked override can be overridden in subclasses

● Will the behavior be speciﬁc to that type? Consider a class.

● Need to inherit from multiple classes? Consider refactoring code to see

● Want to leave some properties / methods abstract to be deﬁned by

● Appears as if the implementer added it

● Not actually modifying the existing class

● Cannot access private instance variables

● Add functionality to classes that are not

● Add functionality to classes you don’t own

Call isOdd() on an Int:

Extension functions are very powerful in Kotlin!

● Mark the class with the data keyword

● Generates toString(), equals(), hashCode(), copy()

Use the data class:

Data classes make your code much more concise!

● Pair and Triple are predeﬁned data classes that store

● Access variables with .first, .second, .third respectively

● Usually named data classes are a better option

It allows for more readable code

Also used in collections like Map and HashMap

● Use this to require instances be one of several constant values

● Sometimes you only want one instance of a class to ever exist

● Use the object keyword instead of the class keyword

● Accessed with NameOfObject.<function or variable>

● Lets all instances of a class share a single instance of a set of

● Use companion keyword

● Referenced via ClassName.PropertyOrFunction

● Kotlin DOES NOT enforce a single entity (class/interface)

● Be mindful of ﬁle length and clutter

● Provide means for organization

● Identiﬁers are generally lower case words separated by periods

● Declared in the ﬁrst non-comment line of code in a ﬁle

● public means visible outside the class. Everything is public by default,

Practice what you’ve learned by

You might also like