Basic Kotlin Syntax: Functions, Objects and Classes – Day 3 Android 14 Masterclass

Welcome to Day 3 of our Android 14 Masterclass, where we delve into the essential Kotlin programming concepts of functions, objects, and classes. Through our detailed exploration of basic Kotlin syntax and practical coding conventions, you’ll learn the intricacies of building solid and reusable code using functions, and you’ll get acquainted with object-oriented principles by creating robust classes and objects. Whether you are starting your journey in Android development or looking to refine your Kotlin expertise, this post is your one-stop reference for understanding how Kotlin’s features can be employed to develop cutting-edge Android applications.

 

 

1. Functions

Functions are the building blocks of a Kotlin program. They carry out specific tasks and can be reused throughout the code. In this section, we’ll learn how to define and call functions in Kotlin, making your journey in Kotlin programming smoother and more efficient.

Key Concepts and Terminologies: Exploring Basic Kotlin Syntax

• Function: A self-contained module that you can reuse and run as many times as needed. It can receive input data and return an output.
• Parameter: Data that you pass into a function. It’s used within the function to accomplish a task.
• Return Type: The type of value that a function gives back when it’s called.

Syntax Explanation:

A function is declared using the fun keyword followed by a name that describes its task. The function might take parameters as input enclosed in parentheses () and return a value.

Naming Conventions: Exploring Basic Kotlin Syntax

Functions’ names

• Camel Case: Function names should be written in camelCase, starting with a lowercase letter, and then capitalizing each subsequent word without spaces.
• Descriptive: Names should be verbs and precisely describe the function’s behavior, indicating the action that the function performs.
• Avoid Abbreviations: Try to avoid abbreviations unless they are universally accepted.

Parameter Names:

• Camel Case: Similar to function names, parameter names should also follow the camelCase convention.
• Descriptive: Parameter names should be descriptive enough to indicate the kind of value expected.

Boolean Functions and Properties:

• Prefixed: Boolean functions and properties often start with prefixes like is, has, are, etc., to make them clearly understandable as returning a boolean value.

General Tips:

• Consistency: Maintain consistency in naming across the whole project to keep the codebase clean and understandable.
• Clarity: The name should convey the function’s purpose or the result it will achieve.
• Brevity: While names should be descriptive, they also need to be concise. Find a balance that maintains clarity without being overly verbose.

Examples:

• Function without parameters and return value

Here, displayMessage is a simple function that takes no parameters and has no return value. It prints a message when called.

• Function with parameters and without return value

In this example, greet is a function that takes a String parameter name. It prints a personalized greeting.

• Function with parameters and a return value

Here, addNumbers is a function that takes two Int parameters and returns their sum as an Int.

 

Print vs. Return

Print Statement:

print or println (print line) is a function used to display information to the console. When you use print, it displays the text or data you put inside the parentheses immediately. It’s mainly used for debugging purposes or to give information about the program’s state.

Key Points:

• Display Output: It shows the output immediately on the console.
• No Effect on Function Flow: Using print does not affect the flow of a function. The function continues to execute subsequent lines of code.
• Debugging: Helps in tracking the flow and state of a program during development.

In this example, calling showMessage() displays “Hello, Kotlin Learner!” on the console.

 

Return Statement:

return is used inside a function to exit it and pass back a value to where the function was called. A function that has a return type must use the return statement to give back a value.

Key Points about return:

• Value Returning: It passes a value back to where the function was called.
• Exits Function: Once a return statement is executed, the function stops running, and control is returned to the caller.
• Specifies Output: Defines the outcome of a function that can be used elsewhere in the program.

Here, add(2, 3) returns 5, which is stored in the variable result and then printed.

In a Nutshell:

• Use print when you want to see the output or state of the program on the console.
• Use return when you want your function to produce a value that will be used later in the code.

2. Classes and Objects: Exploring Basic Kotlin Syntax

A class is like a blueprint or a template for creating objects.

Objects are instances of classes, where the class defines certain attributes (properties) and behaviors (functions/methods) that its objects will have.

Syntax Explanation

A basic class definition looks like this:

 

Key Concepts and Terminologies: Exploring Basic Kotlin Syntax

• Constructor: A special function used to initialize the properties of an object when it’s created. It’s declared in the class header.
• Properties: Variables that are defined in the class to hold some data. They represent the state of an object.
• Initializers: Code blocks that run when an object is instantiated, used to set up initial states.
• Objects/Instance: An individual instance created from the class, holding specific data in its properties.

Detailed Breakdown with Examples:

• Constructor and Properties

Here, Person has a constructor that takes name and age as parameters, and it initializes the properties with the same names.

• Initializer Block

In this example, the init block will run as soon as an object of Person class is created, printing a message to the console.

• Default Values

Here, the properties name and age have default values. If no values are provided when creating an object, these defaults will be used.

• Creating Objects/Instances

person1 is an object of Person, created with specific values, while person2 uses the default values.

 

Property vs. Parameter

• Parameter: A value you pass into the constructor when creating an object. E.g., "Alice" and 25 in Person("Alice", 25).
• Property: A variable within the class where the passed or default values are stored. E.g., val name and val age in the Person class.

 

Data Classes: Exploring Basic Kotlin Syntax

Data classes are concise ways to create classes used mainly for holding data.

Data classes automatically generate useful functions like toString(), equals(), and hashCode().

 

Key Features of Data Classes:

• Immutability: Data classes encourage the use of immutable properties, making them excellent choices for representing simple immutable data.
• Standard Methods: Kotlin automatically provides implementations of fundamental methods.
• Destructuring Declarations: They allow you to decompose the data class into its properties.

 

Conclusion: Basic Kotlin Syntax: Functions, Objects and Classes – Day 3 Android 14 Masterclass

In wrapping up Day 3 of our Android development masterclass, we’ve demystified the uses of functions, print and return statements, as well as the principles behind classes and objects in Kotlin. This article served as a practical guide for mastering these fundamental concepts of basic Kotlin syntax. By now, you should feel confident in defining functions with various parameters, recognizing the power of constructors in class creation, and appreciating the simplicity of data classes for managing state.

 

If you want to skyrocket your Android career, check out our  The Complete Android 14 & Kotlin Development Masterclass. Learn Android 14 App Development From Beginner to Advanced Developer.

Master Jetpack Compose to harness the cutting-edge of Android development, gain proficiency in XML — an essential skill for numerous development roles, and acquire practical expertise by constructing real-world applications.

 

Check out Day 2 of this course here.

Check out Day 4 of this course here.