Class and Object in Scala
Last Updated :
19 Aug, 2021
Classes and Objects are basic concepts of Object Oriented Programming which revolve around the real-life entities.
Class
A class is a user-defined blueprint or prototype from which objects are created. Or in other words, a class combines the fields and methods(member function which defines actions) into a single unit. Basically, in a class constructor is used for initializing new objects, fields are variables that provide the state of the class and its objects, and methods are used to implement the behavior of the class and its objects.
Declaration of class
In Scala, a class declaration contains the class keyword, followed by an identifier(name) of the class. But there are some optional attributes which can be used with class declaration according to the application requirement. In general, class declarations can include these components, in order:
- Keyword class: A class keyword is used to declare the type class.
- Class name: The name should begin with a initial letter (capitalized by convention).
- Superclass(if any):The name of the class’s parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
- Traits(if any): A comma-separated list of traits implemented by the class, if any, preceded by the keyword extends. A class can implement more than one trait.
- Body: The class body is surrounded by { } (curly braces).
Syntax:
class Class_name{
// methods and fields
}
Note: The default modifier of the class is public.
Example:
Scala
class Smartphone
{
var number: Int = 16
var nameofcompany: String = "Apple"
def Display()
{
println("Name of the company : " + nameofcompany);
println("Total number of Smartphone generation: " + number);
}
}
object Main
{
def main(args: Array[String])
{
var obj = new Smartphone();
obj.Display();
}
}
|
Output:
Name of the company : Apple
Total number of Smartphone generation: 16
Objects
It is a basic unit of Object Oriented Programming and represents the real-life entities. A typical Scala program creates many objects, which as you know, interact by invoking methods. An object consists of :
- State: It is represented by attributes of an object. It also reflects the properties of an object.
- Behavior: It is represented by methods of an object. It also reflects the response of an object with other objects.
- Identity: It gives a unique name to an object and enables one object to interact with other objects.
Consider Dog as an object and see the below diagram for its identity, state, and behavior.
Objects correspond to things found in the real world. For example, a graphics program may have objects such as “circle”, “square”, “menu”. An online shopping system might have objects such as “shopping cart”, “customer”, and “product”.
Declaring Objects (Also called instantiating a class)
When an object of a class is created, the class is said to be instantiated. All the instances share the attributes and the behavior of the class. But the values of those attributes, i.e. the state are unique for each object. A single class may have any number of instances.
In Scala, an object of a class is created using the new keyword. The syntax of creating object in Scala is:
Syntax:
var obj = new Dog();
Scala also provides a feature named as companion objects in which you are allowed to create an object without using the new keyword.
Initializing an object
The new operator instantiates a class by allocating memory for a new object and returning a reference to that memory. The new operator also invokes the class constructor.
Example:
Scala
class Dog(name:String, breed:String, age:Int, color:String )
{
println("My name is:" + name + " my breed is:" + breed);
println("I am: " + age + " and my color is :" + color);
}
object Main
{
def main(args: Array[String])
{
var obj = new Dog("tuffy", "papillon", 5, "white");
}
}
|
Output:
My name is:tuffy my breed is:papillon
I am: 5 and my color is :white
Explanation: This class contains a single constructor. We can recognize a constructor because in Scala the body of a class is the body of the constructor and parameter-list follows the class name. The constructor in the Dog class takes four arguments. The following statement provides “tuffy”, ”papillon”, 5, ”white” as values for those arguments:
var obj = new Dog("tuffy", "papillon", 5, "white");
The result of executing this statement can be illustrated as :
Anonymous object
Anonymous objects are the objects that are instantiated but does not contain any reference, you can create an anonymous object when you do not want to reuse it.
Example:
Scala
class GFG
{
def display()
{
println("Welcome! GeeksforGeeks");
}
}
object Main
{
def main(args: Array[String])
{
new GFG().display();
}
}
|
Output:
Welcome! GeeksforGeeks
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...