Classes 04 Jan22 Classes and objects n Scala

Classes 04 -Jan-22

Classes and objects n Scala is an Object-Oriented (O-O), functional language n n Object-Oriented (O-O) means it’s built around “objects” Functional means that functions, like numbers, are values n n Every value, such as 27. 3 or "Hello", is an object n You can “talk” to objects, using dot notation: n n We’ll talk more about the functional aspects later scala> res 12: scala> res 13: "Hello". to. Lower. Case String = hello "Hello". starts. With("He") Boolean = true Every program you write starts with an object you define A class (or type) is a description of a set of objects n n The type of "Hello" is String Most of your programs will use several classes and objects

Objects n If you want just one object of a certain type (a singleton), you can define it like this: object Name. Of. Object { …code… } n The code is executed the first time you refer to the object n n You can refer to the fields (variables) and methods of the object using dot notation n Variables (val and var) are declared Methods (def) are defined “Loose” code (not contained in a method) is executed Name. Of. Object. variable Name. Of. Object. method(arg 1, …, arg. N) Within the object definition, you don’t need to use dot notation to refer to the fields and methods of “this” object

Example object n n n object USA { val number. Of. Contiguous. States = 48 val number. Of. States = number. Of. Contiguous. States var president = "George W. Bush" def is. Contiguous(state: String) = state != "Alaska" && state != "Hawaii" def is. Not. Contiguous(state: String) = !is. Contiguous(state) } + 2 println("The USA has " = USA. number. Of. States + " states. ") USA. president = "Barack Hussein Obama" val here = "Pennsylvania“ println(here + (if (is. Contiguous(here) " is " else " is not ") + " a continental state. ")

Simple programs n n The simplest complete program consists of one object containing a main method The main method looks exactly like n n A “Hello World” program looks like this: n n def main(args: Array[String]) { … code in main method… } object Simple. Program { def main(args: Array[String]) = { println("Hello from a Scala program. ") } } To run the program, put it on a file with the extension. scala (for example, simple. scala), then say n scala simple. scala

Order of execution n When you run a Scala program, things happen in approximately this order: 1. Scala figures out the types of everything, and gives default values to variables (0 for numbers, false for booleans, null for most other kinds of object) 2. Working from top to bottom, Scala evaluates all the vals and vars and defines all the methods (defs) 3. If there is a main method, Scala executes (runs) it n The detailed rules are quite complicated 1. 2. C and C++ require definitions to be in a certain order Scala gives you a lot of freedom in ordering your definitions and variables

About args: Array[String] n n Array[String] means “an array of Strings” When you run the program, you can give it some Strings as input Arrays are covered elsewhere in this course, so you don’t need to worry about them right now Just for completeness, here’s a simple example n object Simple. Program. With. Arguments { def main(args: Array[String]) { println("Here are my arguments: ") for (word <- args) { println(word) } } }

Classes n n When you want more than one object of a given kind, you use a class Because these objects will differ in some respects, a class is usually defined with parameters: class Name. Of. Class(parameters) { …code… } n The code is evaluated each time you create a new object n n n Variables (val and var) are declared Methods (def) are defined (not called) “Loose” code (not contained in a method) is executed The type of each parameter must be specified Each parameter may be marked as val or var n n n val means you can read the value from outside the class definition var means you can read or write the value from outside neither means you can only access the variable from inside the class

Example class n class Planet(val name: String, val order. From. Sun: Int, population. In 2011: Long) { def population(year: Int) = { require(year >= 2011) var pop = population. In 2011. to. Double for (y <- 2012 to year) { pop = 1. 008 * pop } pop. to. Long } } val earth = new Planet("Earth", 3, 700000 L) val mars = new Planet("Mars", 4, 0) val planet = earth println("Population of " + planet. name + " in 2050 will be " + planet. population(2050))

Example class with object n n class Planet is exactly as defined on previous slide Add this object: n n object Solar. System { def main(args: Array[String]) { val earth = new Planet("Earth", 3, 700000 L) val mars = new Planet("Mars", 4, 0) val planet = earth println("Population of " + planet. name + " in 2050 will be " + planet. population(2050)) } } Now we have to run the main method explicitly: n Solar. System. main(Array())

Running from the command line n If your program consists of just one object, you can run it by specifying the name of the file it is on: n n scala Solar. System. scala It is conventional to give the file the same name as the object (plus the. scala extension), but this is not required If you just say scala without a file name, this starts the REPL If your program contains classes or additional objects, you have to compile it (with scalac) and then run it (with scala) n n n dave$ scalac Solar. System. scala dave$ scala Solar. System Population of Earth in 2050 will be 9551218761 Macintosh: Scala_programs When you compile a program, you get some number of. class files, many with a $ in their name. class files are binary files, runnable on the Java Virtual Machine (JVM)

Arguments to a program n Here’s a program from an earlier slide: n n object Simple. Program. With. Arguments { def main(args: Array[String]) { println("Here are my arguments: ") for (word <- args) { println(word) } } } When you run it, everything after the file name is treated as a space-separated array of Strings n dave$ scala Simple. Program. With. Arguments. scala This is CIS 591 Here are my arguments: This is CIS 591

The End 13