{"id":183,"date":"2022-01-03T11:38:37","date_gmt":"2022-01-03T11:38:37","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/scala\/?p=183"},"modified":"2022-01-03T11:38:37","modified_gmt":"2022-01-03T11:38:37","slug":"scala-classes-and-objects","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/scala\/scala-classes-and-objects\/","title":{"rendered":"Scala – Classes and Objects"},"content":{"rendered":"

In this lesson, we would be learning about Object Oriented Programming(OOP) concepts in Scala.<\/p>\n

A Class<\/strong> is a template or blueprint for creating objects. Once you have defined a class, you can then create objects from the class using the new<\/strong><\/em> keyword.<\/p>\n

An Object<\/strong> is an instance of a class. Multiple objects can be created from a class.<\/p>\n

    \n
  1. Defining a Class<\/a><\/li>\n
  2. Extending a Class<\/a><\/li>\n
  3. Implicit Classes<\/a><\/li>\n
  4. Singleton Objects<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Defining a Class<\/strong><\/h4>\n

    Defining a class in Scala is similar to defining a class in Java. The code below defines a class called Square. The class has two variables: l and w. It also has a method called reSize() which takes two parameters.<\/p>\n

    By default, the class has an implicit constructor with is the name of the class. This constructor takes two arguments: length and width which are visible to the whole body of the class.<\/p>\n

    class<\/span> Square<\/span>(<\/span>length:<\/span> Int<\/span>,<\/span> width:<\/span> Int<\/span>)<\/span> {<\/span>\r\n  var<\/span> l:<\/span> Int<\/span> =<\/span> length;<\/span>\r\n  var<\/span> w:<\/span> Int<\/span> =<\/span> width;<\/span>\r\n\r\n  def<\/span> reSize(<\/span>l1:<\/span> Int<\/span>,<\/span> w1:<\/span> Int<\/span>)<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n    l =<\/span> l +<\/span> l1;<\/span>\r\n    w =<\/span> w +<\/span> w1;<\/span>\r\n    println(<\/span>\"New length: \"<\/span> +<\/span> l);<\/span>\r\n    println(<\/span>\"New width: \"<\/span> +<\/span> w);<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    Having defined this class, you can then use it in main program. I call the program, SquareDemo and it is of type, object as show below:<\/p>\n
    object<\/span> SquareDemo<\/span> {<\/span>\r\n\r\n  def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n    val<\/span> sq =<\/span> new<\/span> Square<\/span>(<\/span>43<\/span>,<\/span> 90<\/span>)<\/span>\r\n    sq.<\/span>reSize(<\/span>5<\/span>,<\/span>5<\/span>);<\/span>\r\n\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    2. Extending a Class<\/strong><\/h4>\n
    Just like in Java, you can extend a class in Scala as well. To achieve this, you need to use the extends<\/strong> keyword in the new class.<\/p>\n
    In the program below we have a parent class Shape<\/strong> which has two variables x<\/strong> and y<\/strong> as well as a method move(). Then we have a child class Square<\/strong> that inherits from shape.<\/p>\n
    The Square class has two variables l<\/strong> and w<\/strong> as well as a reSize()<\/strong><\/em> method.<\/p>\n
    \/\/Parent Class (SuperClass)<\/span>\r\nclass<\/span> Shape<\/span>(<\/span>val<\/span> posX:<\/span> Int<\/span>,<\/span> val<\/span> posY:<\/span> Int<\/span>)<\/span> {<\/span>\r\n  var<\/span> x:<\/span> Int<\/span> =<\/span> posX;<\/span>\r\n  var<\/span> y:<\/span> Int<\/span> =<\/span> posY;<\/span>\r\n\r\n  def<\/span> move(<\/span>dx:<\/span> Int<\/span>,<\/span> dy:<\/span> Int<\/span>)<\/span> {<\/span>\r\n    x =<\/span> x +<\/span> dx\r\n    y =<\/span> y +<\/span> dy\r\n    println (<\/span>\"New x position : \"<\/span> +<\/span> x);<\/span>\r\n    println (<\/span>\"New y position : \"<\/span> +<\/span> y);<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n\r\n\/\/Child Class (Subclass or Inherited Class)<\/span>\r\nclass<\/span> Square<\/span>(<\/span>length:<\/span> Int<\/span>,<\/span> width:<\/span> Int<\/span>)<\/span> extends<\/span> Shape<\/span>(<\/span>5<\/span>,<\/span> 6<\/span>){<\/span>\r\n  var<\/span> l:<\/span> Int<\/span> =<\/span> length;<\/span>\r\n  var<\/span> w:<\/span> Int<\/span> =<\/span> width;<\/span>\r\n\r\n  def<\/span> reSize(<\/span>l1:<\/span> Int<\/span>,<\/span> w1:<\/span> Int<\/span>)<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n    l =<\/span> l +<\/span> l1;<\/span>\r\n    w =<\/span> w +<\/span> w1;<\/span>\r\n    println(<\/span>\"New length: \"<\/span> +<\/span> l);<\/span>\r\n    println(<\/span>\"New width: \"<\/span> +<\/span> w);<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
     <\/p>\n
    The keyword extends used in the subclass:<\/p>\n
      \n
    • makes the Square class inherit all the members of the Shape class that are non-private. So the Square class also has members: x, y and move().<\/li>\n
    • makes the Square class a type of Shape<\/li>\n<\/ul>\n
       <\/p>\n
      3. Implicit Classes<\/strong><\/h4>\n
      Implicit class is a new feature introduced with Scala 2.10. It is achieved using the implicit keyword when creating the class. This keyword makes the class’ primary constructor available for implicit conversion if the class is in scope.<\/p>\n
      Example<\/strong><\/p>\n
      object<\/span> Helpers<\/span> {<\/span>\r\n  implicit<\/span> class<\/span> IntWithTimes<\/span>(<\/span>x:<\/span> Int<\/span>)<\/span> {<\/span>\r\n    def<\/span> times[<\/span>A<\/span>](<\/span>f:<\/span> =><\/span> A)<\/span>:<\/span> Unit<\/span> =<\/span> {<\/span>\r\n      def<\/span> loop(<\/span>current:<\/span> Int<\/span>)<\/span>:<\/span> Unit<\/span> =<\/span>\r\n        if<\/span>(<\/span>current ><\/span> 0<\/span>)<\/span> {<\/span>\r\n          f\r\n          loop(<\/span>current -<\/span> 1<\/span>)<\/span>\r\n        }<\/span>\r\n      loop(<\/span>x)<\/span>\r\n    }<\/span>\r\n  }<\/span>\r\n}<\/span>\r\n<\/pre>\n
      In this example, we create an implicit class IntWithTimes. This class then wraps an Int value and give a\u00a0 new method times().<\/p>\n
      To use this class, we simply need to import it into the scope and call it’s times method as shown below:<\/p>\n
      object<\/span> Demo<\/span> {<\/span>\r\n   def<\/span> main(<\/span>args:<\/span> Array<\/span>[<\/span>String<\/span>])<\/span> {<\/span>\r\n      6<\/span> times println(<\/span>\"Welcome!\"<\/span>)<\/span>\r\n   }<\/span>\r\n}<\/span>\r\n<\/pre>\n
      This would print\u00a0 the text “Welcome” 6 times to the output.<\/p>\n
      Restrictions on Implicit Classes<\/strong><\/p>\n
        \n
      • they must be defined inside another class, object or trait<\/li>\n
      • they can only take one non-implicit argument in their constructor<\/li>\n
      • they cannot be any method, member or object in scope with the same name as the implicit class<\/li>\n<\/ul>\n
         <\/p>\n
        4. Singleton Objects in Scala<\/strong><\/h4>\n
        The Singleton Pattern is a software engineering pattern that specifies that a class should only have on single instance.<\/p>\n
        Therefore in Scala, a singleton class is a class that allows instantiation of just one object. So you cannot have static members. And since you cannot instantiate a singleton object, you cannot also pass parameters to the primary constructor.<\/p>\n
        The examples we’ve considered previously are all singleton classes.<\/p>\n","protected":false},"excerpt":{"rendered":"
        In this lesson, we would be learning about Object Oriented Programming(OOP) concepts in Scala. A Class is a template or blueprint for creating objects. Once … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-183","post","type-post","status-publish","format-standard","hentry","category-scala-programming"],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/183","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/comments?post=183"}],"version-history":[{"count":2,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/183\/revisions"}],"predecessor-version":[{"id":185,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/posts\/183\/revisions\/185"}],"wp:attachment":[{"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/media?parent=183"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/categories?post=183"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kindsonthegenius.com\/scala\/wp-json\/wp\/v2\/tags?post=183"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}