Cases and Classes and Case Classes And Other Miscellany 16-Dec-15

Classes and constructors, I Every class has a constructor, which you write (no “invisible” constructors, as in Java) scala> class Person(val firstName:String, var lastName: String, age: Int) defined class Person The above is complete; no braces are needed unless you want to add code, fields, or methods The above defines: firstName (immutable) with getter function firstName lastName (mutable) with getter function lastName and setter function lastName_= The method name uses an underscore, but you use it as an ordinary assignment, for example, lastName = "Smith" Nothing for age (it can be used as a val in the rest of the constructor) 2

Classes and constructors, II Syntax: class ClassName ( parameters ) { body } The ClassName should begin with a capital letter and be CamelCase This is the constructor, and it has parameters A var parameter will cause a field, getter, and setter to be included: var p: Int gives the methods p: () => Int and p_=: Int => () These methods can be redefined inside the method A val parameter will create a field and a getter, but no setter A parameter with neither val nor var does not create a field or any methods, but it can be used within the body of the class When a new object of this class is defined, the fields are created, the methods are defined, and any “loose” code (not within a def ) is executed

Classes and constructors, III scala> class Person(val firstName:String, var lastName: String, age: Int) defined class Person scala> val mary = new Person("Mary", "Smith", 23) mary: Person = scala> mary.firstName res22: String = Mary scala> mary.lastName res23: String = Smith scala> mary.firstName = "Sally" :7: error: reassignment to val scala> mary.lastName = "Jones" res24: String = Jones scala> mary.age :8: error: value age is not a member of Person scala> mary.lastName res25: String = Jones 4

Classes and constructors, IV Again, but this time with a method: scala> class Person(val firstName:String, var lastName: String, age: Int) { | override def toString = firstName + " " + lastName + ", age " + age | } defined class Person scala> val mary = new Person("Mary", "Smith", 23) mary: Person = Mary Smith, age 23 scala> println(mary) Mary Smith, age 23 5

Auxiliary constructors A class (as on the previous slide) defines its primary constructor You can have additional, auxiliary constructors The first statement within an auxiliary constructor must be a call to another auxiliary constructor, or to the primary constructor Thus, every object creation eventually ends up at the primary constructor Syntax: def this( parameters1 ) { this( parameters2 ) … more code… } Since these are overloaded constructors, parameters1 and parameters2 must be different

Pattern matching with match You have seen pattern matching with match and literals today match { case "Saturday" => println("Party! Party! Party!") case "Sunday" => println("Pray....") case day => println(day + " is a workday. :( ") } You can match with types something match { case x: Int => println("I'm the integer " + x) case x: String => println("I'm the String \"" + x + "\"") println("My length is " + x.length) case _ => println("I don't know what I am! :( ") }

Pattern matching in assignments You can pattern match on tuples: scala> val (a, b, c) = (3, 5, 7) a: Int = 3 b: Int = 5 c: Int = 7 But… scala> val a, b, c = (3, 5, 7) a: (Int, Int, Int) = (3,5,7) b: (Int, Int, Int) = (3,5,7) c: (Int, Int, Int) = (3,5,7) You can pattern match on lists: scala> val list = List("once", "upon", "a", "time") list: List[java.lang.String] = List(once, upon, a, time) scala> val first :: second :: rest = list first: java.lang.String = once second: java.lang.String = upon rest: List[java.lang.String] = List(a, time)

Case classes If you declare a class as a case class, you get some extra features: It adds a factory method with the name of the class, so you can omit the word new when you create a new object All constructor parameters are implicitly val You get reasonable implementations of toString, hashCode, and equals “for free” Example: scala> case class Person(firstName: String, lastName: String) defined class Person scala> val jane = new Person("Jane", "Eyre") jane: Person = Person(Jane,Eyre) scala> val Person(f, l) = jane f: String = Jane l: String = Eyre scala> println(jane) Person(Jane,Eyre)

Operations and methods 10 As operationAs method call Unary prefix scala> -5 res4: Int = -5 scala> 5 unary_- res5: Int = -5 Unary scala> " abc " trim res6: java.lang.String = abc scala> " abc ".trim() res7: java.lang.String = abc Binary scala> "abc" + "xyz" res8: java.lang.String = abcxyz scala> "abcdef" substring 2 res10: java.lang.String = cdef scala> "abc".+("xyz") res9: java.lang.String = abcxyz scala> "abcdef".substring(2) res11: java.lang.String = cdef >2 operands scala> "abcdef" substring (1, 3) res12: java.lang.String = bc scala> "abcdef".substring(1, 3) res13: java.lang.String = bc

Parameters in braces A block consists of any number of statements inside braces, { } The last value in the block is the value of the block Parentheses, ( ), can’t enclose multiple statements When a method takes just one parameter, you can put that parameter inside braces instead of parentheses scala> "abcdefg" substring { 2 } res0: java.lang.String = cdefg This example is pointless and looks silly Sometimes, you may want to compute that parameter by a series of statements scala> println { | var x = 2 | while (x < 1000) x *= 2 | x | } 1024 This isn’t a great example either, but it does make the point 11

Methods with no parameters You can define a “parameterless” method: scala> def hello = println("Hello!") hello: Unit scala> hello Hello! scala> hello() :7: error: hello of type Unit does not take parameters You can define an “empty paren” method: scala> def hi() = println("Hi!") hi: ()Unit scala> hi Hi! scala> hi() Hi! If you define a method without parentheses, you can’t call it with parentheses You can replace a parameterless method with an empty paren method, without affecting user code (but not vice versa) 12

Uniform access In Java, the length of an array is a field, so you have to say myArray.length ; but the length of a String is a field, so you have to say myString.length() This violates the principle of uniform access: The user shouldn’t have to know whether it’s a field or a method However, if I say foo = bar, or println(bar), I am using bar like a variable, so I expect bar to act like a variable: bar should not do I/O bar should not change mutable state bar should not depend on values in mutable state In other words, if bar is a function, it should be a pure function Scala convention: When you call a method that does one of the above (impure) things, use parentheses 13

The End