{"id":606,"date":"2011-10-25T10:46:00","date_gmt":"2011-10-25T10:46:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/scala-tutorial-objects-classes-inheritance-traits-lists-with-multiple-related-types-apply.html"},"modified":"2012-10-21T20:24:44","modified_gmt":"2012-10-21T20:24:44","slug":"scala-tutorial-objects-classes","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/scala-tutorial-objects-classes.html","title":{"rendered":"Scala Tutorial – objects, classes, inheritance, traits, Lists with multiple related types, apply"},"content":{"rendered":"
\n

Preface<\/h2>\n

This is part 9 of tutorials for first-time programmers getting into Scala. Other posts are on this blog, and you can get links to those and other resources on the links page of the Computational Linguistics course<\/a> I\u2019m creating these for. Additionally you can find this and other tutorial series on the JCG Java Tutorials page<\/a>.<\/p>\n

This tutorial is about object-oriented programming with Scala. Most of what we\u2019ve seen so far has been programming with functions and using basic types, like Int, Double, and String, and with predefined types like List and Map. As it turns out, these are all classes, or types of Scala data structures that allow one to create objects, or instances of the type. This tutorial will not give a broad introduction to object-oriented programming, but it will give some practical examples of classes and objects and how to use them. I apologize in advance for some sloppiness in the presentation of object-oriented concepts; the intent is to get across the ideas for beginners mainly through intuitive examples without being mired in lots of technical details. See the Wikipedia page on object-oriented programming<\/a> for more detail.<\/p>\n

Note that the definitions of objects and classes in this tutorial are most easily viewed as plain text, out of the REPL. So, I\u2019ll put a piece of code into the text, and you should add it to your own REPL (by simply cutting and pasting) in order to be able to follow along.<\/p>\n

Objects<\/h2>\n

At its core, an object can be thought of as a structure that encapsulates some data and functions. Let\u2019s start with an an example of an object representing a person and some of their possible attributes.<\/p>\n

object JohnSmith {\r\n  val firstName = \"John\"\r\n  val lastName = \"Smith\"\r\n  val age = 37\r\n  val occupation = \"linguist\"\r\n\r\n  def fullName: String = firstName + \" \" + lastName\r\n\r\n  def greet (formal: Boolean): String = {\r\n    if (formal)\r\n      \"Hello, my name is \" + fullName + \". I'm a \" + occupation + \".\"\r\n    else\r\n      \"Hi, I'm \" + firstName + \"!\"\r\n  }\r\n\r\n}\r\n<\/pre>\n
If you put this into the Scala REPL, you\u2019ll be able to access the fields (firstName<\/strong>, lastName<\/strong>, age<\/strong>, and occupation<\/strong>) and the functions (fullName<\/strong> and greet<\/strong>).<\/p>\n
scala> JohnSmith.firstName\r\nres0: java.lang.String = John\r\n\r\nscala> JohnSmith.fullName\r\nres1: String = John Smith\r\n\r\nscala> JohnSmith.greet(true)\r\nres2: String = Hello, my name is John Smith. I'm a linguist.\r\n\r\nscala> JohnSmith.greet(false)\r\nres3: String = Hi, I'm John!\r\n<\/pre>\n
So, at its most basic level, an object is just that: a collection of values and functions (also often called methods). You can access any of those values or functions by giving the name of the object followed by a period followed by the value or function you want to use. This can be useful for organizing such collections, but it also leads to many more possibilities, as we\u2019ll see.<\/p>\n
We might of course be interested in having the information about another person encapsulated in this way. We could do this by mimicking the definition for John Smith.<\/p>\n
object JaneDoe {\r\n  val firstName = \"Jane\"\r\n  val lastName = \"Doe\"\r\n  val age = 34\r\n  val occupation = \"computer scientist\"\r\n\r\n  def fullName: String = firstName + \" \" + lastName\r\n\r\n  def greet (formal: Boolean): String = {\r\n    if (formal)\r\n      \"Hello, my name is \" + fullName + \". I'm a \" + occupation + \".\"\r\n    else\r\n      \"Hi, I'm \" + firstName + \"!\"\r\n  }\r\n\r\n}\r\n<\/pre>\n
After adding the above code to the REPL, now Jane Doe can greet us.<\/p>\n
scala> JaneDoe.greet(true)\r\nres4: String = Hello, my name is Jane Doe. I'm a computer scientist.\r\n\r\nscala> JaneDoe.greet(false)\r\nres5: String = Hi, I'm Jane!\r\n<\/pre>\n
Of course, I created the JaneDoe<\/strong> object by doing a copy-and-paste and then replacing the fields with Jane Doe\u2019s information. This leads to a lot of wasted effort: the fields are the same, but the values are different, and the functions are completely identical. If you want to change something about the way greetings are made, you\u2019d have to update it across all of the objects.<\/p>\n
More importantly, these two objects are completely distinct from one another: one cannot put them in a list and map a function over that list. Consider the following failed attempt.<\/p>\n
scala> val people = List(JohnSmith, JaneDoe)\r\npeople: List[ScalaObject] = List(JohnSmith$@698fcb66, JaneDoe$@5f72cbae)\r\n\r\nscala> people.map(person => person.firstName)\r\n<console>:11: error: value firstName is not a member of ScalaObject\r\npeople.map(person => person.firstName)\r\n                                          ^\r\n<\/pre>\n
The only thing that Scala knowns about JohnSmith<\/strong> and JaneDoe<\/strong> is that they are ScalaObjects<\/strong>. That means that a list of such objects can basically just contain them and allow you to move them around as a group. So, something more is needed to make these collections more useful and more general.<\/p>\n
   Classes<\/h2>\n
With the list above, what we\u2019d like to have is a List[Person]<\/strong>, where Person<\/strong> is a type that has known fields and functions. We can accomplish this by defining a Person<\/strong> class and then defining John and Jane as members of that class. This also reduces the cut-and-paste duplication problem noted earlier. Here\u2019s what it looks like.<\/p>\n
class Person (\r\n  val firstName: String,\r\n  val lastName: String,\r\n  val age: Int,\r\n  val occupation: String\r\n) {\r\n\r\n  def fullName: String = firstName + \" \" + lastName\r\n\r\n  def greet (formal: Boolean): String = {\r\n    if (formal)\r\n      \"Hello, my name is \" + fullName + \". I'm a \" + occupation + \".\"\r\n    else\r\n      \"Hi, I'm \" + firstName + \"!\"\r\n  }\r\n\r\n}\r\n<\/pre>\n
The class<\/em> keyword indicates that this is a class definition and Person<\/strong> is the name of the class. The next part of the definition is a set of parameters to the class that allow us to construct objects that are instances of the class \u2014 in other words, they are placeholders that allow us to use the Person<\/strong> class as a factory for creating Person<\/strong> objects. We do this by using the new<\/em> keyword, giving the name of the class and supplying the values for each of the parameters. For example, here\u2019s how we can create John Smith now.<\/p>\n
scala> val johnSmith = new Person(\"John\", \"Smith\", 37, \"linguist\")\r\njohnSmith: Person = Person@1979d4fb\r\n<\/pre>\n
Just as we could with the one-off standalone JohnSmith<\/strong> object previously, we can now access the fields and functions.<\/p>\n
scala> johnSmith.age\r\nres8: Int = 37\r\n\r\nscala> johnSmith.greet(true)\r\nres9: String = Hello, my name is John Smith. I'm a linguist.\r\n<\/pre>\n
Defining other people is now easy, and doesn\u2019t require any cutting-and-pasting.<\/p>\n
scala> val janeDoe = new Person(\"Jane\", \"Doe\", 34, \"computer scientist\")\r\njaneDoe: Person = Person@7ff5376c\r\n\r\nscala> val johnDoe = new Person(\"John\", \"Doe\", 43, \"philosopher\")\r\njohnDoe: Person = Person@6544c984\r\n\r\nscala> val johnBrown = new Person(\"John\", \"Brown\", 28, \"mathematician\")\r\njohnBrown: Person = Person@4076a247\r\n<\/pre>\n
These Person<\/strong> objects can now be put into a list together, giving us a List[Person]<\/strong> that allows mapping to retrieve specific values, like first names and ages, and performing computations like calculating the average age of the individuals in the list.<\/p>\n
scala> val people = List(johnSmith, janeDoe, johnDoe, johnBrown)\r\npeople: List[Person] = List(Person@1979d4fb, Person@7ff5376c, Person@6544c984, Person@4076a247)\r\n\r\nscala> people.map(person => person.firstName)\r\nres10: List[String] = List(John, Jane, John, John)\r\n\r\nscala> people.map(person => person.age)\r\nres11: List[Int] = List(37, 34, 43, 28)\r\n\r\nscala> people.map(person => person.age).sum\/people.length.toDouble\r\nres12: Double = 35.5\r\n<\/pre>\n
We can sort them according to age.<\/p>\n
scala> val ageSortedPeople = people.sortBy(_.age)\r\nageSortedPeople: List[Person] = List(Person@4076a247, Person@7ff5376c, Person@1979d4fb, Person@6544c984)\r\n\r\nscala> ageSortedPeople.map(person => person.fullName + \":\" + person.age)\r\nres13: List[java.lang.String] = List(John Brown:28, Jane Doe:34, John Smith:37, John Doe:43)\r\n<\/pre>\n
We can also group people by first name, last name, etc.
 
<\/div> <\/div><\/p>\n
scala> people.groupBy(person => person.firstName)\r\nres14: scala.collection.immutable.Map[String,List[Person]] = Map(Jane -> List(Person@7ff5376c), John -> List(Person@1979d4fb, Person@6544c984, Person@4076a247))\r\n\r\nscala> people.groupBy(person => person.lastName)\r\nres15: scala.collection.immutable.Map[String,List[Person]] = Map(Brown -> List(Person@4076a247), Smith -> List(Person@1979d4fb), Doe -> List(Person@7ff5376c, Person@6544c984))\r\n<\/pre>\n
With this, we can have all the Johns greet us.<\/p>\n
scala> people.groupBy(person => person.firstName)(\"John\").foreach(john => println(john.greet(true)))\r\nHello, my name is John Smith. I'm a linguist.\r\nHello, my name is John Doe. I'm a philosopher.\r\nHello, my name is John Brown. I'm a mathematician.\r\n<\/pre>\n
   Standalone objects<\/h2>\n
Above, we saw how to create instances of the Person<\/strong> class by using the new<\/em> keyword and assigning the resulting object to a variable. We can come back full circle to the first JohnSmith<\/strong> object we created, which was a standalone ScalaObject<\/strong>. We can instead create such a standalone object by extending<\/em> the Person<\/strong> class.<\/p>\n
scala> object ThomYorke extends Person(\"Thom\", \"Yorke\", 43, \"musician\")\r\ndefined module ThomYorke\r\n\r\nscala> ThomYorke.greet(true)\r\nres25: String = Hello, my name is Thom Yorke. I'm a musician.\r\n<\/pre>\n
By extending the Person class to create the object, we are saying that the object is a kind of Person<\/strong> \u2014 see more on inheritance below. So, ThomYorke<\/strong> is a Person<\/strong> object, like the others we created, but it is for a different use case that we\u2019ll see more of in the next tutorial. For now, I\u2019ll summarize, very roughly, by saying that the ThomYorke<\/strong> object can be made more accessible by other code that might be using my code, while the johnSmith<\/strong> and janeDoe<\/strong> objects are going to be more locally contained.<\/p>\n
   Inheritance<\/h2>\n
The standalone objects lead us naturally to the idea of inheritance. In many domains, there are natural hierachies of types, such that properties of a super type are inherited by its subtypes (e.g. fish have gills and swim, so salmon have gills and swim). For example, we could have a Linguist<\/strong> type that is a kind of Person<\/strong>, a ComputerScientist<\/strong> type that is a kind of Person<\/strong>, and so on. To model this, we create one class that extends another and possibly provides some additional parameters, such as the following definition of a Linguist<\/strong> sub-type of Person<\/strong>.<\/p>\n
class Linguist (\r\n  firstName: String,\r\n  lastName: String,\r\n  age: Int,\r\n  val speciality: String,\r\n  val favoriteLanguage: String\r\n) extends Person(firstName, lastName, age, \"linguist\") {\r\n\r\n  def workGreeting =\r\n    \"As a \" + occupation + \", I am a \" + speciality + \" who likes to study the language \" + favoriteLanguage + \".\"\r\n\r\n}\r\n<\/pre>\n
The Linguist<\/strong> class has its own parameter list: some of these, like firstName<\/strong>, lastName<\/strong>, and age<\/strong>, are passed on to Person<\/strong>, and there are new parameter fields speciality<\/strong> and favoriteLanguage<\/strong>. The extends<\/em> portion of the definition passes on the relevant parameters needed to construct all the information to make a Person<\/strong>, and for a Linguist<\/strong>, it directly sets the occupation parameter to be \u201clinguist\u201d \u2014 thus, we don\u2019t need to provide that when we construct a Linguist<\/strong>, such as Noam Chomsky.<\/p>\n
scala> val noamChomsky = new Linguist(\"Noam\", \"Chomsky\", 83, \"syntactician\", \"English\")noamChomsky: Linguist = Linguist@54c0627f\r\n<\/pre>\n
Having defined a Linguist<\/strong> object in this way, we can ask it to give its work greeting.<\/p>\n
scala> noamChomsky.workGreeting\r\nres26: java.lang.String = As a linguist, I am a syntactician who likes to study the language English.\r\n<\/pre>\n
We can also access fields and functions of Person<\/strong> objects, like age<\/strong> and greet<\/strong>.<\/p>\n
scala> noamChomsky.age\r\nres27: Int = 83\r\n\r\nscala> noamChomsky.greet(true)\r\nres28: String = Hello, my name is Noam Chomsky. I'm a linguist.\r\n<\/pre>\n
Of course, the Linguist-specific fields like favoriteLanguage<\/strong> are accessible too.<\/p>\n
scala> noamChomsky.favoriteLanguage\r\nres29: String = English\r\n<\/pre>\n
The observant reader will have noticed that some of the parameters are prefaced with val<\/em> and others are not. We\u2019ll get back to that distinction a bit later.<\/p>\n
   Traits<\/h2>\n
We could of course now go on to define a ComputerScientist<\/strong> class that would also have  workGreeting<\/strong> function, but the Linguist.workGreeting<\/strong> and ComputerScientist.workGreeting<\/strong> would be entirely separate. To enable this, we can use traits, which are like classes, but which define an interface of functions and fields that classes can supply concrete values and implementations for.  (Note: traits can also define concrete fields and functions, so they aren\u2019t limited to placeholder functions as we show below.)<\/p>\n
As an example, here\u2019s a Worker<\/strong> trait, which simply defines a function workGreeting<\/strong> and declares that it must return a String<\/strong>.<\/p>\n
trait Worker {\r\n  def workGreeting: String\r\n}\r\n<\/pre>\n
The Linguist<\/strong> class defined earlier already provides an implementation of that function. To allow a Linguist<\/strong> to be considered as a type of Worker<\/strong>, we add with Worker<\/em> after extending Person<\/strong>.<\/p>\n
class Linguist (\r\n  firstName: String,\r\n  lastName: String,\r\n  age: Int,\r\n  val speciality: String,\r\n  val favoriteLanguage: String\r\n) extends Person(firstName, lastName, age, \"linguist\") with Worker {\r\n\r\n  def workGreeting =\r\n    \"As a \" + occupation + \", I am a \" + speciality + \" who likes to study the language \" + favoriteLanguage + \".\"\r\n\r\n}\r\n<\/pre>\n
This is called \u201cmixing in\u201d the trait Worker<\/strong>, because the Linguist<\/strong> class mixes in the fields and functions of Worker<\/strong> with those of Person<\/strong>.<\/p>\n
Note that we can also create classes that simply extend a trait like Worker<\/strong>.<\/p>\n
class Student (school: String, subject: String) extends Worker {\r\n  def workGreeting = \"I'm studying \" + subject + \" at \" + school + \"!\"\r\n}\r\n<\/pre>\n
We can now create a Student<\/strong> object and request their greeting.<\/p>\n
scala> val anonymousStudent = new Student(\"The University of Texas at Austin\", \"history\")\r\nanonymousStudent: Student = Student@734445b5\r\n\r\nscala> anonymousStudent.workGreeting\r\nres32: java.lang.String = I'm studying history at The University of Texas at Austin!\r\n<\/pre>\n
Notice that the parameters school and subject were not preceded by val<\/em> in the definition of Student<\/strong>. That means that they are not member fields of the Student<\/strong> class, which means that they cannot be accessed externally. For example, attempting to access the value provided for school<\/strong> for anonymousStudent<\/strong> fails.<\/p>\n
scala> anonymousStudent.school\r\n<console>:11: error: value school is not a member of Student\r\nanonymousStudent.school\r\n<\/pre>\n
Of course, internally, Student<\/strong> can use the values provided to such parameters, for example in defining the result of workGreeting<\/strong>. This sort of encapsulation hides properties of the objects of a class from code that is outside the class; this strategy can help reduce the degrees of freedom available to users of your code so that they only use what you want them to. In general, if others don\u2019t need to use it, you shouldn\u2019t make it available to them.<\/p>\n
Returning to classes that are both Persons<\/strong> and Workers<\/strong>, when we define a ComputerScientist<\/strong>, we do a similar extends \u2026 with<\/em> declaration as we did for Linguist<\/strong>.<\/p>\n
class ComputerScientist (\r\n  firstName: String,\r\n  lastName: String,\r\n  age: Int,\r\n  val speciality: String,\r\n  favoriteProgrammingLanguage: String\r\n) extends Person(firstName, lastName, age, \"computer scientist\") with Worker {\r\n\r\n  def workGreeting =\r\n    \"As a \" + occupation + \", I work on \" + speciality + \". Much of my code is written in \" + favoriteProgrammingLanguage + \".\"\r\n\r\n}\r\n<\/pre>\n
Let\u2019s create Andrew McCallum<\/a> as a ComputerScientist<\/strong> object.<\/p>\n
scala> val andrewMcCallum = new ComputerScientist(\"Andrew\", \"McCallum\", 44, \"machine learning\", \"Scala\")\r\nandrewMcCallum: ComputerScientist = ComputerScientist@493cd5ba\r\n\r\nscala> andrewMcCallum.workGreeting\r\nres31: java.lang.String = As a computer scientist, I work on machine learning. Much of my code is written in Scala.\r\n<\/pre>\n
Because we redefined Linguist<\/strong> to be a Worker<\/strong>, we need to recreate Noam Chomsky using the new definition. (The creation looks the same as before, but it uses the new class definition that has been updated in the REPL.)<\/p>\n
scala> val noamChomsky = new Linguist(\"Noam\", \"Chomsky\", 83, \"syntactician\", \"English\")\r\nnoamChomsky: Linguist = Linguist@6fccaf14\r\n<\/pre>\n
A minor thing to note: the speciality<\/strong> field of ComputerScientist<\/strong> is disconnected from that of Linguist<\/strong>, so there is no particular expectation of consistency of use across the two: for Linguist<\/strong> it is a description of a person working in a sub-area but for ComputerScientist<\/strong> is a description of a sub-area.<\/p>\n
So, what happens if we put noamChomsky and andrewMcCallum in a List together?<\/p>\n
scala> val professors = List(noamChomsky, andrewMcCallum)\r\nprofessors: List[Person with Worker] = List(Linguist@6fccaf14, ComputerScientist@493cd5ba)\r\n<\/pre>\n
Scala has created a list with type List[Person with Worker]<\/strong>; this is the most specific type that is valid for all elements of the list. It means we can treat all of the elements as Persons<\/strong>, e.g. accessing their occupation<\/strong> (which is a member field of Person<\/strong>).<\/p>\n
scala> professors.map(prof => prof.occupation)\r\nres34: List[String] = List(linguist, computer scientist)\r\n<\/pre>\n
And we can treat each element of the list as a Person<\/strong> and a Worker<\/strong>, e.g. printing out their fullName<\/strong> (from Person<\/strong>) and their workGreeting<\/strong> (from Worker<\/strong>).<\/p>\n
scala> professors.foreach(prof => println(prof.fullName + \": \" + prof.workGreeting))\r\nNoam Chomsky: As a linguist, I am a syntactician who likes to study the language English.\r\nAndrew McCallum: As a computer scientist, I work on machine learning. Much of my code is written in Scala.\r\n<\/pre>\n
We cannot, however, access fields and functions that are specific to Linguists<\/strong> or ComputerScientists<\/strong>, such as favoriteLanguage<\/strong> from Linguist<\/strong>.<\/p>\n
scala> professors.map(prof => prof.favoriteLanguage)\r\n<console>:15: error: value favoriteLanguage is not a member of Person with Worker\r\nprofessors.map(prof => prof.favoriteLanguage)\r\n<\/pre>\n
It is easy to see why Scala has this behavior: even though that would have been valid for noamChomsky<\/strong>, it would not be for andrewMcCallum<\/strong> (according to the way we defined Linguist<\/strong> and ComputerScientist<\/strong>).<\/p>\n
   Matching on types in polymorphic Lists<\/h2>\n
Consider what happens when the anonymousStudent<\/strong> is in a list with the professors.<\/p>\n
scala> val workers = List(noamChomsky, andrewMcCallum, anonymousStudent)\r\nworkers: List[ScalaObject with Worker] = List(Linguist@6fccaf14, ComputerScientist@493cd5ba, Student@734445b5)\r\n<\/pre>\n
The Person<\/strong> type is gone, and we now have a list of a more general type ScalaObject with Worker<\/strong>. Now we can only use the workGreeting<\/strong> method from Worker<\/strong>.<\/p>\n
However, it is worth pointing out that match<\/em> statements come in handy when you have collections of heterogenous objects. For example, put the following code into the REPL.<\/p>\n
val people = List(johnSmith, noamChomsky, andrewMcCallum, anonymousStudent)\r\n\r\npeople.foreach { person =>\r\n  person match {\r\n    case x: Person with Worker => println(x.fullName + \": \" + x.workGreeting)\r\n    case x: Person => println(x.fullName + \": \" + x.greet(true))\r\n    case x: Worker => println(\"Anonymous:\" + x.workGreeting)\r\n  }\r\n}\r\n<\/pre>\n
The result is the following (remember that johnSmith<\/strong> was never defined as a Linguist<\/strong> \u2014 he was defined as a Person<\/strong> whose occupation is \u201clinguist\u201d).<\/p>\n
John Smith: Hello, my name is John Smith. I'm a linguist.\r\nNoam Chomsky: As a linguist, I am a syntactician who likes to study the language English.\r\nAndrew McCallum: As a computer scientist, I work on machine learning. Much of my code is written in Scala.\r\nAnonymous:I'm studying history at The University of Texas at Austin!\r\n<\/pre>\n
So, we can switch our behavior by matching to more specific types using Scala\u2019s pattern matching.<\/p>\n
   The apply function<\/h2>\n
Scala provides a simple but incredibly nice feature: if you define an apply<\/strong> function in a class or object, you don\u2019t actually need to write \u201capply\u201d in order to use it. As an example, the following object adds one to an argument supplied to its apply<\/strong> method.<\/p>\n
object AddOne {\r\n  def apply (x: Int): Int = x+1\r\n}\r\n<\/pre>\n
So, we can use it just like you\u2019d normally expect.<\/p>\n
scala> AddOne.apply(3)\r\nres41: Int = 4\r\n<\/pre>\n
But, we can also do without the \u201c.apply\u201d portion and get the same result.<\/p>\n
scala> AddOne(3)\r\nres42: Int = 4\r\n<\/pre>\n
If a class has an apply<\/strong> method, then we can do the same trick with any object of that class.<\/p>\n
class AddN (amountToAdd: Int) {\r\n  def apply (x: Int): Int = x + amountToAdd\r\n}\r\n\r\nscala> val add2 = new AddN(2)\r\nadd2: AddN = AddN@43ca04a1\r\n\r\nscala> add2(5)\r\nres43: Int = 7\r\n\r\nscala> val add42 = new AddN(42)\r\nadd42: AddN = AddN@83e591f\r\n\r\nscala> add42(8)\r\nres44: Int = 50\r\n<\/pre>\n
As it turns out, you\u2019ve been using apply<\/strong> methods quite often, without knowing it! When you have a List<\/strong> and you access an element by index, you\u2019ve used the apply<\/strong> method of the List<\/strong> class.<\/p>\n
scala> val numbers = 10 to 20 toList\r\nnumbers: List[Int] = List(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)\r\n\r\nscala> numbers(3)\r\nres46: Int = 13\r\n\r\nscala> numbers.apply(3)\r\nres47: Int = 13\r\n<\/pre>\n
Same thing for accessing values using keys in a Map<\/strong>, and similarly for many other of the classes you\u2019ve been using in Scala so far.<\/p>\n
   Wrap-up<\/h2>\n
This tutorial has covered the basics of object-oriented programming in Scala. Hopefully, it is enough to give a decent sense of what objects and classes are and how you can do things with them. There is much much more to be learned about them, but this should be sufficient to get you started so that further study can be done meaningfully. It is important to understand these concepts since Scala is object-oriented from the ground up. In fact, in many of the previous tutorials, I\u2019ve at times gone through some extra hoops to try to describe what is going on without having to talk about object-orientation. But now you can see things like Int, Double, List, Map, and so on for what they are: classes that contain particular fields and functions that you can use to get things done. You can now start coding your own classes to enable your own custom behaviors in your applications.<\/p>\n
Reference: <\/i><\/strong>First steps in Scala for beginning programmers, Part 9<\/a> from our JCG partner<\/a> Jason Baldridge at the Bcomposes<\/a> blog.<\/p>\n
Related Articles :<\/i><\/strong><\/p>\n