Scribd
Upload
115 views27 pages

Scala

Scala is a multi-paradigm programming language that supports both functional and object-oriented programming. It runs on the Java Virtual Machine and has immutable variables defined with val and mutable variables defined with var. Scala has basic data types like Int, String, Boolean and others. Classes can extend other classes and objects can be defined to create singleton instances of classes. Functions are defined with def and can take parameters and return values.

Uploaded by

vaddeseetharamaiah
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
115 views27 pages

Scala

Scala is a multi-paradigm programming language that supports both functional and object-oriented programming. It runs on the Java Virtual Machine and has immutable variables defined with val and mutable variables defined with var. Scala has basic data types like Int, String, Boolean and others. Classes can extend other classes and objects can be defined to create singleton instances of classes. Functions are defined with def and can take parameters and return values.

Uploaded by

vaddeseetharamaiah
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 27

Scala

what is Scala programming language?


Scala is both a Functional
programming and Object Oriented
programming language that runs on the JVM
Immutable variables
val <Name of our variable>: <Scala type> =
<Some literal>
val donutsToBuy: Int = 5
• Mutable variables
var test: String = “hello"
test = "Vanilla Donut"
• lazy val test = "initialize”
Data type
• Byte
• Short
• Int
• Long
• Float
• Double
• Char
• String
• Boolean
• Unit : Corresponds to no value
• Null
• Nothing : Nothing is a subtype of all types, also called the bottom type.
• Any : any object is of type Any
• An object is a class that has exactly one
instance. It is created lazily when it is
referenced, like a lazy val.
• Methods are defined with the def keyword.
• Functions are expressions that take
parameters.
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int, val
zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}}
object Demo {
def main(args: Array[String])
{ val loc = new Location(10, 20, 15);
move(10, 10, 5);
}
}
Access Modifiers :
Private
Protected
Public
• Operator
• Loop
• If-else
• Nested if
def functionName ([list of parameters]) : [return type] = {
function body
return [expr] }
Functions in scala
Functions Call-by-Name
Functions with Named Arguments
Function with Variable Arguments
Default Parameter Values
Nested Functions
Partially Applied Functions
Recursion Functions
Higher-Order Functions
Anonymous Functions
Currying Functions
Functions Call-by-Name
object Demo {
def main(args: Array[String]) {
delayed(time());
}
def time() = {
println("Getting time in nano seconds") System.nanoTime
}
def delayed( t: => Long ) = {
println("In delayed method")
println("Param: " + t)
}
}
Functions with Named Arguments
object Demo {
def main(args: Array[String]) {
printInt(b = 5, a = 7);
}
def printInt( a:Int, b:Int ) = {
println("Value of a : " + a );
println("Value of b : " + b );
}
}
Function with Variable Arguments
object Demo {
def main(args: Array[String]) {
printStrings("Hello", "Scala", "Python");
}
def printStrings( args:String* ) = {
var i : Int = 0;
for( arg <- args ){
println("Arg value[" + i + "] = " + arg );
i = i + 1;
}
}
}
Recursion Functions
object Demo {
def main(args: Array[String]) {
for (i <- 1 to 10)
println( "Factorial of " + i + ": = " + factorial(i) )
}
def factorial(n: BigInt): BigInt = {
if (n <= 1) 1
else
n * factorial(n - 1)
}
}
Default Parameter Values
object Demo {
def main(args: Array[String]) {
println( "Returned Value : " + addInt() );
}
def addInt( a:Int = 5, b:Int = 7 ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Higher-Order Functions
These are functions that take other functions as
parameters, or whose result is a function.

object Demo {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]" }
Nested Functions
object Demo {
def main(args: Array[String]) {
println( factorial(0) )
println( factorial(1) )
println( factorial(2) )
println( factorial(3) )
}
def factorial(i: Int): Int = {
def fact(i: Int, accumulator: Int): Int = {
if (i <= 1) accumulator
else
fact(i - 1, i * accumulator) } fact(i, 1)
}
}
Anonymous Functions
var inc = (x:Int) => x+1
Partially Applied Functions
import java.util.Date object
Demo { def main(args: Array[String]) {
val date = new Date
val logWithDateBound = log(date, _ : String)
logWithDateBound("message1" )
Thread.sleep(1000)
logWithDateBound("message2" )
Thread.sleep(1000)
logWithDateBound("message3" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}
Currying Functions
Currying transforms a function that takes multiple
parameters into a chain of functions, each taking a
single parameter.

object Demo { def main(args: Array[String]) {


val str1:String = "Hello, "
val str2:String = "Scala!“
println( "str1 + str2 = " + strcat(str1)(str2) )
}
def strcat(s1: String)(s2: String) = { s1 + s2 } }
Pattern Matching & case function
object Demo {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many“
}
}
Pattern Matching & case function
object Demo {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy