The Path to Becoming a Data Engineer

Interested in learning more about Scala? Take DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-scala">Introduction to Scala</a> course.
Scala is a functional programming language where it contains both functions as first-class values and methods and has both similarities and dissimilarities.
Both the functions and methods are a block of the reusable code also used to store the repeated code in one place, which makes a function call to performs a particular specific task. They also make code easier to debug and modify.
However, functions are an object which is initialized in a variable, but methods start with the &#39;def&#39; keyword followed by the method name, parameter list, method body with the return value.
You&#39;ll be learning the following topics:
<ol>
<li>Method declaration and definition</li>
<li>Method Call</li>
<li>A method with named arguments</li>
<li>Default Parameter Values</li>
<li>Variable-length Arguments</li>
<li>Recursion Function</li>
<li>Anonymous Function</li>
</ol>
<h2 id="method-declaration-and-definition">Method declaration and definition</h2>
The syntax for method declaration and definition in Scala is below:
<pre><code>def &#39;method_name&#39; (&#39;parameters&#39;:&#39;return_type_parameters&#39;) : (&#39;return_type_of_method&#39;) = {
 &#39;method_body&#39;
 return &#39;value&#39;
}
</code></pre>The method in Scala starts with the following parts:
<ol>
<li>&#39;def&#39;: keyword which is used to declare methods.</li>
<li>&#39;method_name&#39;: is the name of your method, which is in lower camel case.</li>
<li>&#39;parameters&#39;: is method parameters that may have no parameter or one parameter only but are separated by a comma when there is more than one parameter.</li>
<li>&#39;return_type_of_parameters&#39;: need to match according to the data type of &#39;parameters_list&#39; and is compulsory</li>
<li>&#39;return_type_of_method&#39;: is optional, but in default, &#39;Unit&#39; is returned, but the value can be returned with &#39;return&#39; keyword.</li>
<li>Assignment Symbol(&#39;=&#39;): is optional, and if used will assign the return value and not using it will make the method not to return anything.</li>
<li>&#39;method_body&#39;: is the block of code enclosed inside curly braces &#39;{}&#39; and consists of the required logic or certain task or operations.</li>
<li>return: is the keyword used to return the required values and also terminate the program but is rarely used in Scala.</li>
</ol>
<h2 id="method-call">Method call</h2>
The syntax for Method call in Scala is below:
<pre><code> method_name(arguments)
</code></pre>The Method call can be quickly done by &#39;method_name&#39;, which is the name of the corresponding method that you want to call with the arguments is passed.
<h2 id="a-method-with-named-arguments">A method with named arguments</h2>
The method with named arguments will allow passing the argument to the methods&#39; parameter during the method call where each of the arguments is matched one by one to the method parameters.
You will see the example below of passing the arguments with Function declaration and definition along with the method call in action:
<pre><code class="lang-python">object calculateResult {
 def funSub(x:Int, y:Int) : Int =
 {

 var diff:Int = 0
 diff = x - y

 // return value
 return diff
 }
 def main(args: Array[String]) {

 // Function call
 println(&quot;Difference of the value is: &quot; + funSub(8,6));
 println(&quot;Difference of the value is &quot; + funSub(y=6,x=8));
 }
}
</code></pre>
The above program gives the output as: 
Difference of the value is: 2 
Difference of the value is: 2
The above program contains an object &#39;calculateResult&#39;, and inside it contains a method named as &#39;funSub&#39; with both the parameters x and y having return type as &#39;Int,&#39; the overall return type of the method is &#39;Int&#39;. It is followed by an assignment statement to assign the return value. The curly braces indicate the start of the method body, where the variable &#39;diff&#39; is initialized with the initial value of 0.
The Method call &#39;funSub(8,6)&#39; done in the main method matches 8 to &#39;x&#39; and 6 to &#39;y,&#39; and the subtraction operation is carried out, and the value of &#39;diff&#39; is returned and finally gets printed. Similarly, the &#39;funSub(x=8,y=6)&#39; matches 6 to &#39;y&#39; and 8 to &#39;x&#39; to parameters in the method during method call where the order doesn&#39;t matter where a similar operation is done and is return and result gets printed out.
<h2 id="default-parameter-values">Default Parameter Values</h2>
You can specify the default values for the method parameters through the initialization of corresponding values and can leave the method call empty by not passing the argument.
<pre><code class="lang-python">object calculateResult {
 def funSub(x:Int=9, y:Int=6) : Int =
 {

 var diff:Int = 0
 diff = x - y

 // return value
 return diff
 }
 def main(args: Array[String]) {

 // Function call
 print( &quot;The final value is: &quot; + funSub() );

 }
}
</code></pre>
The above program gives the output as: 
The final value is: 3 
You can see the above program contains object defined as &#39;calculateResult&#39; and inside that there is a method named as &#39;funSub&#39; with the parameters x and y with both having return type as &#39;Int&#39; and the overall return type of the method is &#39;Int&#39; and is followed by assignment statement which will assign the return value. The curly braces indicate the start of the method body, where the variable &#39;diff&#39; is initialized with the initial value of 0.
The Method call is done inside from the main method where &#39;funSub()&#39; calls and initialize the x to 9 and y to 6, and the operation is carried out, which makes the value &#39;diff&#39; to be returned and printed.
<h2 id="variable-length-arguments">Variable-length Arguments</h2>
Variable-length Arguments are the arguments that take any variable number of arguments and can be passed by the user or client. The last parameter in the method is declared using &#39;*&#39; which needs to be repeated.
<pre><code class="lang-python">object variableArgument {
 def main(args: Array[String]) {
 printAll(&quot;Scala&quot;, &quot;is&quot;, &quot;great&quot;)
 }

 def printAll(strings: String*) {
 var i : Int = 0;

 for( value &lt;- strings ){
 println(value);
 i = i + 1;
 }
 }
}
</code></pre>
The above program gives the output as: 
Scala 
is 
great 
You can see the above program contains an object &#39;variableArgument&#39; with &#39;printAll&#39; methods where variable-length argument &#39;String*&#39; is defined at the end and during the call of a method a list of strings can be passed. The passed list of strings is looped over and shown as output inside the primary function.
<h2 id="recursion-function">Recursion Function</h2>
Recursion is the technique used in functional programming where the problem is solved by repeatedly breaking it into smaller subproblems, which are similar to the original problem. The more minor problems are solved, and their solutions are applied to get the solutions for the original problem. So, it is called a divide-and-conquer or decrease-and-conquer problem, which makes the code to be clean and elegant.
When writing a recursive function, the two points need to be considered strictly. They are:
<ul>
<li>Base case: There might be more than one base case in a function that needs to find out otherwise might lead to infinite recursion. It needs to have a solution, i.e., the simple form of output or solution that can be achieved without recursion.</li>
<li>Recursive case: The case where the recursive function is applied i.e.recursive call are being made.
The main crux of the problem is that in each recursive call, the size needs to decrease i.e.problem needs to be divided into smaller sub-problems until you reach the base case. At last, you combine the solution to get the main problem, which is called a divide-conquer approach.</li>
</ul>
The factorial of any given number is n! It can be mathematically expressed as follows:
<center>n! = n.(n-1).(n-2)...3.2.1</center>

Also, you can make the terms (n-1).(n-2)...3.2.1 to be (n-1)!
So, the factorial of any given number is always n. (n-1)!
Now you can see below the recursive way of solving the problem.
<pre><code class="lang-python">object factorialDemo {
 def main(args: Array[String]) {
 for (i &lt;- 1 to 5)
 println( &quot;Factorial of &quot; + i + &quot;: = &quot; + factorial(i) )
 }

 def factorial(n: Int): Int = { 
 if (n &lt;= 1)
 return 1 
 else 
 return n * factorial(n - 1)
 }
}
</code></pre>
The above program give the output as: 
Factorial of 1: = 1 
Factorial of 2: = 2 
Factorial of 3: = 6 
Factorial of 4: = 24 
Factorial of 5: = 120 
You can see above where there is an object called &#39;factorialDemo&#39; and inside it, there is a &#39;main&#39; function containing a loop which repeats over for five times and also includes a function call to &#39;factorial&#39; where recursive function makes a recursive call, i.e., n to five times. It stops at the base case when n becomes less than or equal to 1, and the result is returned and printed.
<h2 id="anonymous-function">Anonymous Function</h2>
Anonymous Function is those lightweight function definition which doesn&#39;t have a name and is known to be function literal in Scala.
Syntax with example for Anonymous Function are as follows: 
<li>The first syntax and an example for Anonymous function is: </li>

Syntax: 
<pre><code>(&#39;first_variable&#39;:&#39;data_type&#39;, &#39;second_variable&#39;:&#39;data_type&#39;) =&gt; &quot;certain_expression&quot;
</code></pre>Example: 
<pre><code>(var1:String:var2:String) =&gt; var1 + var2
</code></pre> OR 
 <li>The second syntax and an example for Anonymous function is:</li>
Syntax: 
<pre><code> (_:&#39;data_type&#39;)operator(_&#39;data_type&#39;)
</code></pre> Example: 
<pre><code> (_:String)+(_:String)
</code></pre>The first syntax shows that expression after &quot;=&gt;&quot; evaluates to a particular value whereas a list of the variable before &quot;=&gt;&quot; used for evaluating the expression.
The second syntax above works like a placeholder where it accepts the value as a &#39;wild card&#39; character only once, and then the operator is operated among them.
You&#39;ll see an example of anonymous function below:
<pre><code class="lang-python"> object anonymousDemo 
{
 def main(args: Array[String]) 
 {


 var function1 = (var1:Int, var2:Int) =&gt; var1 + var2
 var function2 = (_:Int) + (_:Int)

 // function call
 println(function1(5, 5))
 println(function2(7, 3))
 }
}
</code></pre>
<pre><code>Initializing Scala interpreter ...



Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as &#39;sc&#39; (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as &#39;spark&#39;




&lt;console&gt;:10: error: unbound placeholder parameter

 var function2 = {_:Int} + {_:Int}

 ^

&lt;console&gt;:10: error: unbound placeholder parameter

 var function2 = {_:Int} + {_:Int}

 ^
</code></pre>The above program gives the output as: 
10 
10 
You can see above the object named to be &#39;anonymousDemo&#39; with the &#39;main&#39; function containing two anonymous functions. They are syntactically different but can produce the same result, where &#39;function&#39;1 evaluates by taking parameters from a function call as it is being called—passing the values 5 and 5, which results in output to be printed as 10 whereas &#39;function2&#39; is also called passing 7 and 3 where it receives the value once, which accepts any valid &#39;Integer&#39;. In your case, do the addition operation and output the result.
<h2 id="conclusion">Conclusion</h2>
Congratulation, you&#39;ve finished reading this tutorial.
There are many advanced topics in Scala such as higher-order functions, nested function, currying function, etc.
Reference: 
<a href="https://docs.scala-lang.org/tour/basics.html">TOUR OF SCALA BASICS</a> 
<a href="https://www.geeksforgeeks.org/scala-functions-basics/">Scala | Functions – Basics</a> 
<a href="https://www.tutorialspoint.com/scala/scala_functions.htm">Scala - Functions</a> 
<a href="https://www.geeksforgeeks.org/anonymous-functions-in-scala/">Anonymous Functions in Scala</a>
Check out DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-scala">Introduction to Scala</a> course.

https://www.datacamp.com/community/tutorials/basic-functions-methods-scala

Learn about the basics of methods, named arguments, default parameter values, variable arguments in addition to different kinds of functions.

(Tutorial) Basics of FUNCTIONS and METHODS in Scala

Basics of Functions and Methods in Scala

DataCamp has recently launched there first Scala course: <a href="https://www.datacamp.com/courses/introduction-to-scala">Introduction to Scala</a>. Check it out!
You may also be interested in reading the following tutorials:
<ul>
<li><a href="https://www.datacamp.com/community/tutorials/beginners-guide-to-scala">Beginners Guide to Scala</a> </li>
<li><a href="https://www.datacamp.com/community/tutorials/if-else-in-scala">IF ELSE in Scala</a> </li>
<li><a href="https://www.datacamp.com/community/tutorials/operators-in-scala">Operators in Scala</a> </li>
<li><a href="https://www.datacamp.com/community/tutorials/scala-lists">Lists in Scala</a> </li>
<li><a href="https://www.datacamp.com/community/tutorials/scala-classes-objects">Scala Classes and Objects</a></li>
</ul>
<h2 id="introduction">Introduction</h2>
A Trait is a concept pre-dominantly used in object-oriented programming, which can extend the functionality of a class using a set of methods.
<a id='intro'></a>
Traits are similar in spirit to <a href="https://en.wikipedia.org/wiki/Interface_(Java)">interfaces</a> in Java programming language. Unlike a class, Scala traits cannot be instantiated and have no arguments or parameters. However, you can inherit (extend) them using classes and objects. Having said that, traits provide a specific set of methods/functions that execute behavior to a class and expect that the class implements a set of methods that then parameterize the provided behavior.
A trait that is used to define an object is created as a mixture of methods that can be used by different classes without requiring multiple inheritances. However, there can be outliers wherein two traits have a method with the same name (naming collision), which have to be used by a class, in which case the ambiguity has to be resolved explicitly.
Traits can have both abstract and non-abstract methods, fields as its members. When you do not initialize a method in a trait, then they are abstract, while the ones that are initialized are called non-abstract. In the abstract methods, the class that implements the trait takes care of the initialization.
Now, let&#39;s quickly understand Scala traits with the help of some examples!
<h4 id="scala-trait-syntax">Scala Trait Syntax</h4>
The syntax for the Scala trait is straightforward, it is defined by the keyword <code>trait</code> followed by the name of the trait.
<pre><code>trait Trait_Name{
// Variables
// Methods
}
</code></pre><center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1572904473/traits1_n5mvla.png" />
</figure>
</center>

 As you can see from the above trait definition, a trait named <code>DataCamp</code> was defined, which has no variables and methods defined inside it.
Let&#39;s move onto a simple example of Scala traits, which will give you much more clarity on how they work programmatically.
As discussed in the <a href="#intro">introduction</a>, the Scala Traits are inherited by a class using the <code>extends</code> keyword.
<pre><code>class Scala_Tutorial extends DataCamp{
// Variables
// Methods
}
</code></pre><a id='same'></a>
Let&#39;s define a trait named <code>Scala_Course</code>, which will be inherited by the class <code>DataCamp</code>. Inside the <code>trait</code>, you will define an abstract method called <code>scala()</code>, which will be defined in the <code>DataCamp</code> class.
<pre><code>trait Scala_Course{ 
 def scala() 
} 

class DataCamp extends Scala_Course{ 
 def scala(){ 
 println(&quot;DataCamp has recently launched there first Scala course&quot;) 
 } 
} 

object Main{ 
 def main(args:Array[String]){ 
 var a = new DataCamp() 
 a.scala() 
 } 
}
</code></pre>Now let us run the above code.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1572904473/traits2_nstrfl.png" />
</figure>
</center> 

 In the above example, the method <code>scala()</code> was an abstract method, and hence, the declaration was made in the class that inherited that trait.
But what if you have a method (non-abstract) which is already implemented in the trait? Well, in that case, the class which extends this trait need not implement the method which is already implemented in a trait.
Let&#39;s understand this with the help of a small example.
<pre><code>trait BMW{

 // trait variables
 var make: String = &quot;BMW&quot;
 var model: String = &quot;X7&quot;
 var fuel: Int = 40

 // trait method: NON-ABSTRACT
 def Display()
 {
 println(&quot;Make of the Car : &quot; + make);
 println(&quot;Model of the Car : &quot; + model);
 println(&quot;Fuel capacity of the Car : &quot; + fuel);
 }
}


class Car extends BMW{
 // class variables
 var make1: String = &quot;Mercedes Benz&quot;
 var model1: String = &quot;S350D&quot;
 var fuel1: Int = 50

 // Class method
 def Merc_Specs()
 {
 println(&quot;Make of the Car : &quot; + make1);
 println(&quot;Model of the Car : &quot; + model1);
 println(&quot;Fuel capacity of the Car : &quot; + fuel1);
 }
}

object Main 
{

 // Main method
 def main(args: Array[String]) 
 {

 // Class object
 var obj = new Car();
 println(&quot;Calling the Class Method&quot;)
 obj.Merc_Specs();
 println(&quot;Calling the Trait Method&quot;)
 obj.Display();
 }
}
</code></pre>Let&#39;s run the above code:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1572904473/traits3_dbgbmr.png" />
</figure>
</center> 

 Now that you have understood the difference between <code>abstract</code> and <code>non-abstract</code> methods, let&#39;s see what can go wrong when an <code>abstract</code> method is not implemented in the class that <code>inherits</code> or <code>extends</code> it.
Let us use the <a href="#same">same</a> example to understand this concept.
<pre><code>trait Scala_Course{ 
 def scala() 
} 

class DataCamp extends Scala_Course{ 
 def print(){ 
 println(&quot;Error: Class DataCamp needs to be Abstract&quot;) 
 } 
} 

object Main{ 
 def main(args:Array[String]){ 
 var a = new DataCamp() 
 a.print() 
 } 
}
</code></pre>Running the above code results in an error, as shown below, since you did not define the trait method <code>scala()</code> (abstract) in the class that inherited it.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1572904473/traits4_r9hfvw.png" />
</figure>
</center> 

 To make the above code work, there could be two possible solutions:
<ul>
<li>Define the <code>scala()</code> method in the class <code>DataCamp</code> or</li>
<li>Define the DataCamp class as <code>abstract</code>.</li>
</ul>
The last topic for today&#39;s tutorial is how you can inherit multiple traits in one class. So, let&#39;s quickly finish it up.
<pre><code>trait A{
// methods
}
trait B{
// methods
}
class C extends A with B{
}
</code></pre><pre><code>trait BMW{


 var make: String = &quot;BMW&quot;
 var model: String = &quot;X7&quot;
 var fuel: Int = 40
}

trait Merc{


 var make1: String = &quot;Mercedes Benz&quot;
 var model1: String = &quot;S350D&quot;
 var fuel1: Int = 50


}



class Car extends BMW with Merc{

 def BMW_Specs()
 {
 println(&quot;Make of the Car : &quot; + make);
 println(&quot;Model of the Car : &quot; + model);
 println(&quot;Fuel capacity of the Car : &quot; + fuel);
 }


 def Merc_Specs()
 {
 println(&quot;Make of the Car : &quot; + make1);
 println(&quot;Model of the Car : &quot; + model1);
 println(&quot;Fuel capacity of the Car : &quot; + fuel1);
 }

}


object Main 
{

 // Main method
 def main(args: Array[String]) 
 {

 // Class object
 var obj = new Car();
 println(&quot;Calling the BMW Trait&quot;)
 obj.BMW_Specs();
 println();
 println(&quot;Calling the Merc Trait&quot;)
 obj.Merc_Specs();
 }
}
</code></pre>Finally, let us run the above code.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1572904473/traits5_osfhse.png" />
</figure>
</center> 

<h1 id="congratulations-">Congratulations!</h1>
Congratulations on finishing this tutorial.
You now know what are Traits in programming and how to make use of it in Scala. One good exercise for you would be to find a solution for the abstract method when not defined in the class that inherited it. Try writing code for the same and see if the code runs without any compilation error. A small tip, you might want to look at Abstract Classes in Scala.
Please feel free to ask any questions related to this tutorial in the comments section below.
Finally, don&#39;t forget to take the new Scala course on DataCamp, <a href="https://www.datacamp.com/courses/introduction-to-scala">Introduction to Scala</a>.

https://www.datacamp.com/community/tutorials/scala-traits

Learn about the use of traits in Scala with the help of syntactic examples.

community

datacamp

scala

News (0)

Tutorials (8)

Basics of Functions and Methods in Scala

Scala Traits

Cheat Sheets (0)

Open Courses (0)

Podcast (0)

Blog Posts (1)

The Path to Becoming a Data Engineer

Tech Thoughts (0)