Abstract Classes in Scala - GeeksforGeeks

31 Oct, 2019
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:
// Scala program to illustrate how to // create an abstract class  // Abstract classabstract class myauthor{          // abstract method    def details()}  // GFG class extends abstract classclass 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()    }}
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:// Scala program to illustrate // the concept of abstract class  // Abstract classabstract class myauthor{          // abstract method    def details()}    object Main {          // Main method    def main(args: Array[String]) {                  // Object of myauthor class    var obj = new myauthor()    }}Output:prog.scala:18: error: class myauthor is abstract; cannot be instantiatedvar obj = new myauthor()^one error found
// Scala program to illustrate // the concept of abstract class  // Abstract classabstract class myauthor{          // abstract method    def details()}    object Main {          // Main method    def main(args: Array[String]) {                  // Object of myauthor class    var obj = new myauthor()    }}
Output:
prog.scala:18: error: class myauthor is abstract; cannot be instantiatedvar 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:// Scala program to illustrate // the concept of abstract class  // Abstract class with fieldsabstract class Geek{    var name : String = "GeeksforGeeks"    var tutorial: String = "Scala"    def portal()}  // GFG class extends abstract classclass 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()    }}Output:Portal name: GeeksforGeeks
Tutorial name: Scala
// Scala program to illustrate // the concept of abstract class  // Abstract class with fieldsabstract class Geek{    var name : String = "GeeksforGeeks"    var tutorial: String = "Scala"    def portal()}  // GFG class extends abstract classclass 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()    }}
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:// Scala program to illustrate // the concept of abstract class  // Abstract class with constructor// And the constructor contain two argumentsabstract class myauthor(name: String,                        topic: String){    def details()}  // GFG class extends abstract classclass 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()    }}Output:Author name: Ankita
Topic name: Abstract class

// Scala program to illustrate // the concept of abstract class  // Abstract class with constructor// And the constructor contain two argumentsabstract class myauthor(name: String,                        topic: String){    def details()}  // GFG class extends abstract classclass 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()    }}
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:// Scala program to illustrate // the concept of abstract class  // Abstract class with // non-abstract methodabstract class myauthor{          // Non-abstract method    def details()    {        println("Welcome to GeeksforGeeks")    }}  // GFG class extends abstract classclass GFG extends myauthor{}  object Main {          // Main method    def main(args: Array[String])    {                  // objects of GFG class        var obj = new GFG()        obj.details()    }}Output:Welcome to GeeksforGeeks

// Scala program to illustrate // the concept of abstract class  // Abstract class with // non-abstract methodabstract class myauthor{          // Non-abstract method    def details()    {        println("Welcome to GeeksforGeeks")    }}  // GFG class extends abstract classclass GFG extends myauthor{}  object Main {          // Main method    def main(args: Array[String])    {                  // objects of GFG class        var obj = new GFG()        obj.details()    }}
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:// Scala program to illustrate // the concept of abstract class  // Abstract class with the final methodabstract class myauthor{    final def mymethod()    {        println("Final method")    }}  // GFG class extends abstract classclass GFG extends myauthor{}  object Main {          // Main method    def main(args: Array[String])     {                  // objects of GFG class        var obj = new GFG()        obj.mymethod()    }}Output:Final method

// Scala program to illustrate // the concept of abstract class  // Abstract class with the final methodabstract class myauthor{    final def mymethod()    {        println("Final method")    }}  // GFG class extends abstract classclass GFG extends myauthor{}  object Main {          // Main method    def main(args: Array[String])     {                  // objects of GFG class        var obj = new GFG()        obj.mymethod()    }}
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.
ManasChhabra2
Scala
Scala-OOPS
Scala
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Throw Keyword in Scala
Scala Map
Scala List filter() method with example
How to install Scala on Windows?
Scala List exists() method with example
Scala | Arrays
Scala Tutorial – Learn Scala with Step By Step Guide
Scala Lists
HashMap in Scala
Scala | Functions Call-by-Name