Scala Constructs
Last Updated :
22 Jul, 2020
Some of the basic Scala constructs are expressions, blocks, classes, objects, functions, methods, traits, Main methods, fields, and closures.
1. Scala Expression: A computable statement in Scala is known as expression. For example, the following is an expression: 3 + 4. To print the output of an expression println() is used.
Syntax
println(expression)
Examples
object Main
{
def main(args : Array[String])
{
println( 3 )
println( 3 + 4 )
println( "Scala" )
println( "How " + "are" + " you?" )
}
}
|
Output:
3
7
Scala
How are you?
2. Values: We can name it using the ‘val’ keyword. This expression returns a result.
Syntax
val variable_name = 'Result to be printed'
Examples
object Main
{
def main(args : Array[String])
{
val name 1 = "Arjun"
println(name 1 )
val name 2 = "Sheena"
println(name 2 )
}
}
|
Output
Arjun
Sheena
Here, this type of entity can have only one value. If we try to reassign the value, then it will give error.
3. Scala Variables: Variables are simply a storage location and it is known by its name and stores some known and unknown piece of information called a value. To declare a variable, we use the ‘var’ keyword.
Syntax
var variable_name = Any_number
Example
object Main
{
def main(args : Array[String])
{
var p = 3
p = 4
println(p * p)
}
}
|
Output
16
4. Scala Block: A group of expressions that are delimited by curly braces({}) is called a block.
Syntax
println({// Expression})
Example
object Main
{
def main(args : Array[String])
{
println({ val p = 10 * 2
p + 1 })
}
}
|
Output
21
5. Scala Class: A class is a user-defined blueprint or prototype from which objects are created. It contains values, variables, types, classes, functions, methods, objects, and traits that are collectively called members. To declare a class, we use the ‘class’ keyword and an identifier.
Syntax
{
class class_name{}
val variable_name = new class_name
}
Example
class Geeks
{
var name : String = "GeeksforGeeks"
def Show()
{
println( "Company's name : " + name);
}
}
object Main
{
def main(args : Array[String])
{
var obj = new Geeks();
obj.Show();
}
}
|
Output:
Company's name : GeeksforGeeks
6. Object: Object is a singleton of its own class i.e., it is a single instance of its own definition.
Strong:
object MyObject{
def method_name() = {
// Expression
}
}
Example:
object Main extends App
{
object MyObject
{
def plusthree() = {
val x = 2 + 2
x + 3
}
}
println(MyObject.plusthree)
}
|
Output:
7
7. Scala Function: An expression that takes parameters are called functions. Or in other words, it is a collection of statements that perform a certain task. It can be assigned to a variable such type of function is known as an anonymous function. On the left of => is the list of parameters, and on the right is an expression it will return.
Syntax
(y:Int)=>y+y
This function takes an Integer argument y, and returns its addition. We can give the name to the value also.
Example:
object Main
{
def main(args : Array[String])
{
val addition = (y : Int) => y + y
println(addition( 4 ))
}
}
|
Output:
8
8. Scala Method: We define method using the keyword “def”. It is almost similar to a function. It follows is an identifier, parameter lists, a return type, and a body. Or in other words, it is a collection of statements that perform a certain task.
Syntax
def method_name ([parameter_list]) : [return_type] = {
// Method body
}
Example
object Main
{
def display()
{
println( "Welcome to GFG" )
}
def main(args : Array[String])
{
display()
}
}
|
Output
Welcome to GFG
9. Scala Trait: Traits are like interfaces in Java. But traits allow you to implement the members. It can have methods(both abstract and non-abstract), and fields as its members. It is defined using a keyword “trait”.
Syntax
trait trait_name
{
// Fields
// Methods
}
Example
trait MyTrait
{
def show
}
class MyGfg extends MyTrait
{
def show()
{
println( "Hey Geeks" )
}
}
object Main
{
def main(args : Array[String])
{
val ob = new MyGfg();
ob.show();
}
}
|
Output:
Hey Geeks
10. Scala Main Method: The entry point of any program is the main method. JVM needs a method with an argument which is an array of strings.
11. Fields: These fields help to define the object state. It is a unique set of instance variables that belong to each object.
12. Closure: Closure is a function whose return value depends on variables declared outside it.
Share your thoughts in the comments
Please Login to comment...