Scala - Klassen & Objekte

In diesem Kapitel erfahren Sie, wie Sie Klassen und Objekte in der Scala-Programmierung verwenden. Eine Klasse ist eine Blaupause für Objekte. Sobald Sie eine Klasse definiert haben, können Sie mit dem Schlüsselwort Objekte aus dem Klassenplan erstellennew. Über das Objekt können Sie alle Funktionen der definierten Klasse nutzen.

Das folgende Diagramm zeigt die Klasse und das Objekt anhand eines Beispiels für einen Klassenschüler, das die Elementvariablen (Name und Rollennummer) und die Elementmethoden (setName () und setRollNo ()) enthält. Schließlich sind alle Mitglieder der Klasse. Klasse ist eine Blaupause und Objekte sind hier echt. In der folgenden Abbildung ist Student eine Klasse und Harini, John und Maria sind die Objekte der Student-Klasse. Diese haben Namen und Rollennummer.

Grundklasse

Es folgt eine einfache Syntax zum Definieren einer Basisklasse in Scala. Diese Klasse definiert zwei Variablenx und y und eine Methode: move, die keinen Wert zurückgibt. Klassenvariablen werden aufgerufen, Felder der Klasse und Methoden werden Klassenmethoden genannt.

Der Klassenname fungiert als Klassenkonstruktor, der eine Reihe von Parametern annehmen kann. Der obige Code definiert zwei Konstruktorargumente:xc und yc;; Sie sind beide im ganzen Körper der Klasse sichtbar.

Syntax

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

Wie bereits in diesem Kapitel erwähnt, können Sie Objekte mit einem Schlüsselwort erstellen new und dann können Sie auf Klassenfelder und Methoden zugreifen, wie unten im Beispiel gezeigt -

Beispiel

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 20
Point y location : 30

Eine Klasse erweitern

Sie können eine Scala-Basisklasse erweitern und eine geerbte Klasse auf dieselbe Weise wie in Java entwerfen (verwenden) extends Schlüsselwort), aber es gibt zwei Einschränkungen: Das Überschreiben von Methoden erfordert die override Schlüsselwort und nur die primaryDer Konstruktor kann Parameter an den Basiskonstruktor übergeben. Lassen Sie uns unsere obige Klasse erweitern und eine weitere Klassenmethode hinzufügen.

Beispiel

Nehmen wir ein Beispiel für zwei Klassen. Point-Klasse (wie oben) und Location-Klasse ist eine geerbte Klasse mit dem Schlüsselwort extens. So ein 'extendsDie '-Klausel hat zwei Auswirkungen: Sie bewirkt, dass die Location-Klasse alle nicht privaten Mitglieder von der Point-Klasse erbt, und der Typ Location wird zu einem Subtyp des Typs Point- Klasse. Hier heißt also die Point-Klassesuperclassund die Klasse Location wird aufgerufensubclass. Das Erweitern einer Klasse und das Erben aller Funktionen einer übergeordneten Klasse wird aufgerufeninheritance Scala erlaubt jedoch die Vererbung nur von einer Klasse.

Note - Methoden move () -Methode in der Punktklasse und move() method in Location class Überschreiben Sie nicht die entsprechenden Definitionen von move, da es sich um unterschiedliche Definitionen handelt (z. B. verwenden erstere zwei Argumente, während letztere drei Argumente verwenden).

Versuchen Sie das folgende Beispielprogramm, um die Vererbung zu implementieren.

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 20
Point y location : 30
Point z location : 20

Implizite Klassen

Implizite Klassen ermöglichen implizite Konversationen mit dem primären Konstruktor der Klasse, wenn sich die Klasse im Gültigkeitsbereich befindet. Implizite Klasse ist eine Klasse, die mit dem Schlüsselwort 'implizit' gekennzeichnet ist. Diese Funktion wird in Scala 2.10 eingeführt.

Syntax- Das Folgende ist die Syntax für implizite Klassen. Hier befindet sich die implizite Klasse immer im Objektbereich, in dem alle Methodendefinitionen zulässig sind, da die implizite Klasse keine Klasse der obersten Ebene sein kann.

Syntax

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

Beispiel

Nehmen wir ein Beispiel für eine implizite Klasse mit dem Namen IntTimesmit der Methode times (). Dies bedeutet, dass times () eine Schleifentransaktion enthält, die die angegebene Anweisung so oft ausführt, wie wir sie angeben. Nehmen wir an, die angegebene Anweisung lautet "4 mal println (" Hallo ")", was bedeutet, dass die println ("" Hallo ") - Anweisung 4 mal ausgeführt wird.

Das folgende ist das Programm für das gegebene Beispiel. In diesem Beispiel werden zwei Objektklassen verwendet (Ausführen und Demo), sodass wir diese beiden Klassen wie folgt in verschiedenen Dateien mit ihren jeweiligen Namen speichern müssen.

Run.scala - Speichern Sie das folgende Programm in Run.scala.

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala - Speichern Sie das folgende Programm in Demo.scala.

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

Die folgenden Befehle werden zum Kompilieren und Ausführen dieser beiden Programme verwendet.

Befehl

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

Ausgabe

Hello
Hello
Hello
Hello

Note - -

Implizite Klassen müssen in einer anderen Klasse / einem anderen Objekt / einer anderen Eigenschaft definiert werden (nicht in der obersten Ebene).
Implizite Klassen dürfen in ihrem Konstruktor nur ein nicht implizites Argument verwenden.
Implizite Klassen dürfen keine Methoden, Elemente oder Objekte im Gültigkeitsbereich mit demselben Namen wie die implizite Klasse sein.

Singleton-Objekte

Scala ist objektorientierter als Java, da wir in Scala keine statischen Mitglieder haben können. Stattdessen hat Scalasingleton objects. Ein Singleton ist eine Klasse, die nur eine Instanz haben kann, dh Object. Sie erstellen Singleton mit dem Schlüsselwortobjectanstelle des Klassenschlüsselworts. Da Sie ein Singleton-Objekt nicht instanziieren können, können Sie keine Parameter an den primären Konstruktor übergeben. Sie haben bereits alle Beispiele mit Singleton-Objekten gesehen, bei denen Sie die Hauptmethode von Scala aufgerufen haben.

Es folgt dasselbe Beispielprogramm zum Implementieren von Singleton.

Beispiel

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.

Befehl

\>scalac Demo.scala
\>scala Demo

Ausgabe

Point x location : 10
Point y location : 20

Scala - Klassen &amp; Objekte

Grundklasse

Syntax

Beispiel

Befehl

Ausgabe

Eine Klasse erweitern

Beispiel

Befehl

Ausgabe

Implizite Klassen

Syntax

Beispiel

Befehl

Ausgabe

Singleton-Objekte

Beispiel

Befehl

Ausgabe

Scala - Klassen & Objekte