Klasse in Scala erweitern
In diesem Artikel erfahren Sie, wie Sie Klassen in Scala erweitern.
Klasse in Scala erweitern
In Scala erweitern wir eine Klasse, um einen der wichtigsten Teile der objektorientierten Programmierung (OOP) zu erreichen: Vererbung. Um eine Klasse in Scala zu erweitern, müssen wir ein extend-Schlüsselwort verwenden.
Syntax:
derived_class_name extends base_class_name
{
}
Sehen wir uns ein Beispiel an, um es besser zu verstehen.
Beispielcode:
class Parent
{
var child1: String = "Tony"
var child2: String = "Nat"
}
class childOne extends Parent
{
var age = 23
var gender = "Male"
def display()
{
println("Name : " +child1)
println("Age : "+age)
println("Gender : "+gender)
}
}
class childTwo extends Parent
{
var age = 18
var gender = "Female"
def display()
{
println("Name : " +child2)
println("Age : "+age)
println("Gender : "+gender)
}
}
object myClass{
def main(args: Array[String])
{
val obj1 = new childOne()
val obj2 = new childTwo()
obj1.display()
obj2.display()
}
}
Ausgang:
Name : Tony
Age : 23
Gender : Male
Name : Nat
Age : 18
Gender : Female
Im obigen Code können wir die Klassen childOne und childTwo beobachten, die Daten von der Basisklasse parent geerbt haben.
Fallklassen in Scala erweitern
Die Case-Klasse von Scala ist eine spezielle Art von Klasse, die sich gut für die Modellierung unveränderlicher Daten eignet. Sie sind sehr nützlich beim Musterabgleich.
Wir fügen ein Schlüsselwort case vor der class hinzu, um daraus eine case-Klasse zu machen.
Beispielcode eins:
case class student (name:String, rollNo:Int)
object myClass
{
def main(args: Array[String])
{
var st = student("Tony", 33)
println("Name of the student is: " + st.name);
println("Roll number of the student is: " + st.rollNo);
}
}
Ausgang:
Name of the student is: Tony
Roll number of the student is: 33
Sehen wir uns nun an, wie diese Fallklassen erweitert oder geerbt werden. Im Gegensatz zum normalen Unterricht haben wir hier einige Einschränkungen.
Beispielcode zwei:
case class records(schoolID: Int)
case class student (name:String, rollNo:Int) extends records
object myClass
{
def main(args: Array[String])
{
var st = student("Tony", 33)
}
}
Ausgang:
error: case class student has case ancestor records, but case-to-case inheritance is prohibited
Der obige Code gibt einen Fehler aus, da die Fall-zu-Fall-Klassenvererbung in Scala verboten ist. Laut Scala kann die Fallklasse nur eine normale Klasse, eine abstrakte Klasse oder ein trait erweitern.
Beispielcode drei:
Hier versuchen wir, eine abstrakte Klasse zu erweitern.
abstract class records(schoolName: String)
{
def name:Unit
}
case class student (schoolName:String) extends records(schoolName)
{
override def name:Unit = println(schoolName)
}
object myClass
{
def main(args: Array[String])
{
var st = student("delhi public school")
st.name
}
}
Ausgang:
delhi public school
Beispielcode vier:
Hier versuchen wir, ein trait zu erweitern.
trait information
{
def id: Int
def name: String
}
case class student (id:Int,name:String) extends information
{
println(id+" "+name)
}
object myClass
{
def main(args: Array[String])
{
val temp: information = student(230,"Tony")
}
}
Ausgang:
230 Tony
Abschluss
In diesem Artikel haben wir gelernt, wie man eine Klasse in Scala erweitert; Wir haben auch gesehen, wie man case-Klassen erweitert und ihre Einschränkungen beim Erben einer anderen Klasse beachtet.
