Latest web development tutorials

Scala Klassen und Objekte

Klasse ist eine abstrakte Objekt, und das Objekt eine bestimmte Instanz einer Klasse. Klasse ist abstrakt und nimmt nicht auf Speicher, und das Objekt ist Beton, nehmen Speicherplatz. Klasse ist eine Blaupause für die Erstellung eines Objekts, es ist eine softwaredefinierte Vorlagen umfassen Methoden und Variablen in bestimmten Arten von Objekten in der.

Wir können das neue Schlüsselwort verwenden, um Objekte der Klasse zu erstellen, Beispiele sind wie folgt: 

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 ("x 的坐标点: " + x);
      println ("y 的坐标点: " + y);
   }
}

Scala in der Klasse nicht als public deklariert, wird eine Datei Scala Quelle kann mehrere Klassen haben.

Beispiele für die oben Klasse definiert zwei Variablenx und y,einVerfahren:bewegen, wobei das Verfahren hat keinen Rückgabewert.

Klassendefinition Scala können Parameter, genannt Klassenparameter, wie beispielsweise die oben xc, yc, Klassenparameter in der ganzen Klasse zugreifen können.

Dann können wir neue verwenden, um die Klasse und Zugriffsklasse Methoden und Variablen instanziiert: 

import java.io._

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 ("x 的坐标点: " + x);
      println ("y 的坐标点: " + y);
   }
}

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

      // 移到一个新的位置
      pt.move(10, 10);
   }
}

Die Umsetzung des obigen Codes ist die Ausgabe: 

$ scalac Test.scala 
$ scala Test
x 的坐标点: 20
y 的坐标点: 30

Scala vererben

Scala erben eine Basisklasse mit Java sehr ähnlich ist, aber wir müssen die Aufmerksamkeit auf folgende Punkte zu achten:

  • 1, umschreiben eine nicht abstrakte Methode muss die Überschreibung Modifikator verwenden.
  • 2, ist es in der Vergangenheit nur die Haupt Konstruktor der Basisklasse Konstruktor Schreibparameter.
  • 3. Wenn in einer Unterklasse der abstrakten Oberklasse außer Kraft gesetzt, brauchen Sie nicht das Schlüsselwort override zu verwenden.

Lassen Sie uns ein Beispiel aussehen: 

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 ("x 的坐标点: " + x);
      println ("y 的坐标点: " + 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 ("x 的坐标点 : " + x);
      println ("y 的坐标点 : " + y);
      println ("z 的坐标点 : " + z);
   }
}

Scala Einsatz erstreckt Stichwort, eine Klasse zu erben. Instanzen Location-Klasse erbt Point-Klasse. Punkt genannt die übergeordnete Klasse (Basisklasse), Standort eine Unterklasse genannt wird.

außer Kraft setzen val xc die übergeordnete Klasse Feld umschreiben.

Alle Eigenschaften und Methoden erben die Eltern-Klasse erben, Scala erlaubt nur eine Elternklasse erben.

Beispiele sind wie folgt: 

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 ("x 的坐标点 : " + x);
      println ("y 的坐标点 : " + 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 ("x 的坐标点 : " + x);
      println ("y 的坐标点 : " + y);
      println ("z 的坐标点 : " + z);
   }
}

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

      // 移到一个新的位置
      loc.move(10, 10, 5);
   }
}

Die Umsetzung des obigen Codes ist die Ausgabe: 

$ scalac Test.scala 
$ scala Test
x 的坐标点 : 20
y 的坐标点 : 30
z 的坐标点 : 20

Scala umschreiben eine nicht-abstrakte Methode muss Modifikator außer Kraft setzen. 

class Person {
  var name = ""
  override def toString = getClass.getName + "[name=" + name + "]"
}

class Employee extends Person {
  var salary = 0.0
  override def toString = super.toString + "[salary=" + salary + "]"
}

object Test extends App {
  val fred = new Employee
  fred.name = "Fred"
  fred.salary = 50000
  println(fred)
}

Die Umsetzung des obigen Codes ist die Ausgabe: 

$ scalac Test.scala 
$ scala Test
Employee[name=Fred][salary=50000.0]

Scala Singleton-Objekt

In Scala, ist dieses Ding nicht statisch, sondern es gibt uns auch ein Verfahren Singleton-Muster zu erreichen, und das ist das Stichwort Objekt zu verwenden.

Scala, wenn im Einzelfall Modell, zusätzlich zu der Klassendefinition verwendet wird, sondern auch die Definition eines Zielobjekts mit dem gleichen Namen, ist der Unterschied zwischen ihm und der Klasse, können Objektobjektparameter nicht nehmen.

Begleitobjekt: Wenn Singleton-Objekte den gleichen Namen mit einer Klasse teilen, ist er Begleiter Objekte dieser Klasse genannt. Sie müssen die Klasse und die dazugehörigen Objekte in derselben Quelldatei definieren. Begleiter Klasse: Diese Klasse ist die Singleton-Objekt zugehörigen Klasse bezeichnet. Klasse und ihrer Begleitobjekt können einander ihre privaten Mitglieder zugreifen.

Singleton-Objekt-Instanzen 

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 Test {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("x 的坐标点 : " + point.x);
         println ("y 的坐标点 : " + point.y);
      }
   }
}

Die Umsetzung des obigen Codes ist die Ausgabe: 

$ scalac Test.scala 
$ scala Test
x 的坐标点 : 10
y 的坐标点 : 20

Assoziierte Objektinstanz 

/* 文件名：Marker.scala
 * author:本教程
 * url:www.w3big.com
 */

// 私有构造方法
class Marker private(val color:String) {

  println("创建" + this)
  
  override def toString(): String = "颜色标记："+ color
  
}

// 伴生对象，与类共享名字，可以访问类的私有属性和方法
object Marker{
  
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
    
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
  
    
    def getMarker(color:String) = { 
      if(markers.contains(color)) markers(color) else null
    }
    def main(args: Array[String]) { 
        println(Marker("red"))  
        // 单例函数调用，省略了.(点)符号  
		println(Marker getMarker "blue")  
    }
}

Die Umsetzung des obigen Codes ist die Ausgabe: 

$ scalac Marker.scala 
$ scala Marker
创建颜色标记：red
创建颜色标记：blue
创建颜色标记：green
颜色标记：red
颜色标记：blue