Abstract Classes in Scala

Abstraction is the process to hide the internal details and showing only the functionality. In Scala, abstraction is achieved by using an abstract class. The working of the Scala abstract class is similar to Java abstract class. In Scala, an abstract class is constructed using the abstract keyword. It contains both abstract and non-abstract methods and cannot support multiple inheritances. A class can extend only one abstract class.
Syntax:

abstract class class_name
{
// code..
}

The abstract methods of abstract class are those methods which do not contain any implementation. Or in other words, the method which does not contain body is known as an abstract method.
Syntax:

def function_name()

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Scala program to illustrate how to 
// create an abstract class
  
// Abstract class
abstract class myauthor
{
      
    // abstract method
    def details()
}
  
// GFG class extends abstract class
class GFG extends myauthor
{
    def details()
    {
        println("Author name: Ankita Saini")
        println("Topic name: Abstract class in Scala")
    }
}
  
object Main 
{
    // Main method
    def main(args: Array[String]) 
    {
        // objects of GFG class
        var obj = new GFG()
        obj.details()
    }
}

chevron_right


Output:

Author name: Ankita Saini
Topic name: Abstract class in Scala

Following are some important observations about abstract classes in Scala.

  • Like Java, in Scala, we are not allowed to create the instance of the abstract class. If we try to create objects of the abstract class, then the compiler will give an error as shown in the below program.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Scala program to illustrate 
    // the concept of abstract class
      
    // Abstract class
    abstract class myauthor{
          
        // abstract method
        def details()
    }
      
      
    object Main {
          
        // Main method
        def main(args: Array[String]) {
              
            // Object of myauthor class
        var obj = new myauthor()
        }
    }

    chevron_right

    
    

    Output:

    prog.scala:18: error: class myauthor is abstract; cannot be instantiated
    var obj = new myauthor()
    ^
    one error found

  • In Scala, an abstract class can also contain fields. These fields are accessed by the abstract class methods and by the methods of the class which inherit abstract class. As shown in the below program.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Scala program to illustrate 
    // the concept of abstract class
      
    // Abstract class with fields
    abstract class Geek
    {
        var name : String = "GeeksforGeeks"
        var tutorial: String = "Scala"
        def portal()
    }
      
    // GFG class extends abstract class
    class GFG extends Geek
    {
          
        // Abstract class method accessing
        // fields of the abstract class
        def portal()
        {
            println("Portal name: " + name)
              
        }
          
        // GFG class method accessing 
        // fields of the abstract class
        def tutdetails()
        {
            println("Tutorial name: " + tutorial) 
        }
    }
      
    object Main 
    {
          
        // Main method
        def main(args: Array[String]) 
        {
              
            // objects of GFG class
            var obj = new GFG()
            obj.portal()
            obj.tutdetails()
        }
    }

    chevron_right

    
    

    Output:

    Portal name: GeeksforGeeks
    Tutorial name: Scala
  • Like Java, In Scala, an abstract class can also contain a constructor and a constructor of an abstract class is called when an instance of a inherited class is created. As shown in the below program.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Scala program to illustrate 
    // the concept of abstract class
      
    // Abstract class with constructor
    // And the constructor conatin two arguments
    abstract class myauthor(name: String,
                            topic: String)
    {
        def details()
    }
      
    // GFG class extends abstract class
    class GFG(name: String, topic: String) extends
                                myauthor(name, topic)
    {
        def details()
        {
            println("Author name: " + name)
            println("Topic name: " + topic)
        }
    }
      
    object Main 
    {
          
        // Main method
        def main(args: Array[String])
        {
              
            // objects of GFG class
            var obj = new GFG("Ankita", "Abstract class")
            obj.details()
        }
    }

    chevron_right

    
    

    Output:

    Author name: Ankita
    Topic name: Abstract class
    
  • An abstract class can also contain only non- abstract method. This allows us to create classes that cannot be instantiated, but can only be inherited. As shown in the below program.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Scala program to illustrate 
    // the concept of abstract class
      
    // Abstract class with 
    // non-abstract method
    abstract class myauthor
    {
          
        // Non-abstract method
        def details()
        {
            println("Welcome to GeeksforGeeks")
        }
    }
      
    // GFG class extends abstract class
    class GFG extends myauthor{}
      
    object Main 
    {
          
        // Main method
        def main(args: Array[String])
        {
              
            // objects of GFG class
            var obj = new GFG()
            obj.details()
        }
    }

    chevron_right

    
    

    Output:

    Welcome to GeeksforGeeks
    
  • In Scala, an abstract class can contain final methods (methods that cannot be overridden). For example, the following program compiles and runs without an error. In Scala, final method is created using final keyword.
    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Scala program to illustrate 
    // the concept of abstract class
      
    // Abstract class with the final method
    abstract class myauthor
    {
        final def mymethod()
        {
            println("Final method")
        }
    }
      
    // GFG class extends abstract class
    class GFG extends myauthor{}
      
    object Main 
    {
          
        // Main method
        def main(args: Array[String]) 
        {
              
            // objects of GFG class
            var obj = new GFG()
            obj.mymethod()
        }
    }

    chevron_right

    
    

    Output:

    Final method
    

When to use abstract class in Scala:

An abstract class is useful:

  • When we want to construct a base class which needs constructor arguments.
  • When our code will be called from Java code.

Note:Traits are also used to achieve abstraction.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.