This article is part of the Scala knowledge bits Series.
Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.
It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.
This episode will teach you about Scala Objects.
Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.
After this Bit, I would love to hear your feedback in the comments down below.
Feel free to join the Discord server as well if you would like some help and support from the rest of our community.
What are we learning today?
Today we are going to learn about Scala Objects !
After seeing about
, we are going to learn about
I know, it is confusing, because we learned that an
is what we create when we instantiate a
, but this term can also be used to talk about a
that do not need to be instantiated. I know, confusing…
To make it clearer, let’s just focus on those
. If you know other programming languages, you might have heard of
, it means that the
can be accessed without instantiating the
. Let’s talk about it more in the section after the exercise.
Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.
Here is an exercise to complete today.
If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.
But if you get stuck, scroll down to get more information.
The goal of the exercise is to replace the
by a piece of code so that the exercise compiles and that’s how you win! Good luck!
You can fill the exercise right in here:
Or, if it does not load, go on to Scastie (1b36QjJlRVi02lvrXSLrgw).
More information about Scala Objects
In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Objects.
Did you notice how the
are being accessed ?
You use the name of the
, for instance:
that is defined inside of
, you just have to do:
. No need for
or anything special, you can just call the
are most commonly used when you want to defined constants values that are common for several systems or
, like the
one we have here.
are also used to stored “utility methods” or also called “helper methods“.
This helper methods are common tools for several systems that do not have dependencies defined at runtime. That means that you can define the behavior of this
only based on the input parameters, no need to know any more parameters. For instance, a method to sum two numbers
a + b
, you do not need to know more than the two inputs:
. They are self contained systems and can often be reused from one project to another as a library.
Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Objects.
I hope you have learned something new or had fun during this Scala Knowledge Bit.
Please ask questions or post feedback in the comments below.
Feel free to try on the next Scala Knowledege Bit.
If you are curious about the previous Scala knowledge Bits, go check it out! 🙂