Scala - Kelas & Objek

Bab ini memandu Anda mempelajari cara menggunakan kelas dan objek dalam pemrograman Scala. Kelas adalah cetak biru untuk objek. Setelah Anda menentukan kelas, Anda dapat membuat objek dari cetak biru kelas dengan kata kuncinew. Melalui objek, Anda dapat menggunakan semua fungsi kelas yang ditentukan.

Diagram berikut memperagakan kelas dan objek dengan mengambil contoh siswa kelas, yang berisi variabel anggota (nama dan no roll) dan metode anggota (setName () dan setRollNo ()). Akhirnya semuanya adalah anggota kelas. Kelas adalah cetak biru dan objek nyata di sini. Pada diagram berikut, Siswa adalah kelas dan Harini, John, dan Maria adalah objek dari kelas Siswa yang memiliki nama dan nomor putar.

Kelas Dasar

Berikut ini adalah sintaks sederhana untuk mendefinisikan kelas dasar di Scala. Kelas ini mendefinisikan dua variabelx dan y dan metode: move, yang tidak mengembalikan nilai. Variabel kelas disebut, bidang kelas dan metode disebut metode kelas.

Nama kelas berfungsi sebagai konstruktor kelas yang dapat mengambil sejumlah parameter. Kode di atas mendefinisikan dua argumen konstruktor,xc dan yc; keduanya terlihat di seluruh tubuh kelas.

Sintaksis

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);
   }
}

Seperti yang disebutkan sebelumnya dalam bab ini, Anda dapat membuat objek menggunakan kata kunci new dan kemudian Anda dapat mengakses bidang kelas dan metode seperti yang ditunjukkan di bawah ini dalam contoh -

Contoh

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);
   }
}

Simpan program di atas dalam Demo.scala. Perintah berikut digunakan untuk mengkompilasi dan menjalankan program ini.

Perintah

\>scalac Demo.scala
\>scala Demo

Keluaran

Point x location : 20
Point y location : 30

Memperluas Kelas

Anda dapat memperluas kelas Scala dasar dan Anda dapat mendesain kelas yang diwariskan dengan cara yang sama seperti yang Anda lakukan di Java (gunakan extends kata kunci), tetapi ada dua batasan: penggantian metode memerlukan override kata kunci, dan hanya primarykonstruktor dapat mengirimkan parameter ke konstruktor dasar. Mari kita memperluas kelas kita di atas dan menambahkan satu metode kelas lagi.

Contoh

Mari kita ambil contoh dua kelas kelas Point (seperti contoh yang sama seperti di atas) dan kelas Lokasi adalah kelas warisan menggunakan kata kunci extends. Seperti 'extends'klausa memiliki dua efek: itu membuat kelas Lokasi mewarisi semua anggota non-pribadi dari kelas Point, dan itu membuat jenis Lokasi subtipe dari jenis kelas Point . Jadi di sini kelas Point disebutsuperclassdan kelas Lokasi dipanggilsubclass. Memperluas kelas dan mewarisi semua fitur dari kelas induk disebutinheritance tetapi Scala mengizinkan pewarisan hanya dari satu kelas saja.

Note - Metode move () metode di kelas Point dan move() method in Location class jangan menimpa definisi yang terkait dengan move karena keduanya merupakan definisi yang berbeda (misalnya, definisi sebelumnya menggunakan dua argumen sedangkan yang terakhir menggunakan tiga argumen).

Coba program contoh berikut untuk mengimplementasikan pewarisan.

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);
   }
}

Simpan program di atas dalam Demo.scala. Perintah berikut digunakan untuk mengkompilasi dan menjalankan program ini.

Perintah

\>scalac Demo.scala
\>scala Demo

Keluaran

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

Kelas Implisit

Kelas implisit memungkinkan percakapan implisit dengan konstruktor utama kelas saat kelas berada dalam cakupan. Kelas implisit adalah kelas yang ditandai dengan kata kunci 'implisit'. Fitur ini diperkenalkan di Scala 2.10.

Syntax- Berikut ini adalah sintaks untuk kelas implisit. Di sini kelas implisit selalu dalam lingkup objek di mana semua definisi metode diperbolehkan karena kelas implisit tidak bisa menjadi kelas tingkat atas.

Sintaksis

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

Contoh

Mari kita ambil contoh kelas implisit bernama IntTimesdengan metode times (). Ini berarti times () berisi transaksi loop yang akan mengeksekusi pernyataan yang diberikan dalam beberapa kali yang kita berikan. Mari kita asumsikan pernyataan yang diberikan adalah "4 kali println (" Hello ")" berarti pernyataan println ("" Hello ") akan dieksekusi 4 kali.

Berikut ini adalah program untuk contoh yang diberikan. Dalam contoh ini digunakan dua kelas objek (Run dan Demo) sehingga kita harus menyimpan kedua kelas tersebut dalam file yang berbeda dengan nama masing-masing sebagai berikut.

Run.scala - Simpan program berikut di 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 - Simpan program berikut di Demo.scala.

import Run._

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

Perintah berikut digunakan untuk mengkompilasi dan menjalankan kedua program ini.

Perintah

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

Keluaran

Hello
Hello
Hello
Hello

Note -

• Kelas implisit harus didefinisikan di dalam kelas / objek / sifat lain (bukan di tingkat atas).

• Kelas implisit hanya dapat mengambil satu argumen non-implisit dalam konstruktornya.

• Kelas implisit tidak boleh berupa metode, anggota, atau objek dalam cakupan dengan nama yang sama dengan kelas implisit.

Objek Tunggal

Scala lebih berorientasi objek daripada Java karena di Scala, kita tidak dapat memiliki anggota statis. Sebaliknya, Scala punyasingleton objects. Singleton adalah kelas yang hanya dapat memiliki satu instance, yaitu Object. Anda membuat singleton menggunakan kata kunciobjectalih-alih kata kunci kelas. Karena Anda tidak dapat membuat instance objek tunggal, Anda tidak dapat meneruskan parameter ke konstruktor utama. Anda sudah melihat semua contoh menggunakan objek tunggal yang Anda panggil metode utama Scala.

Berikut ini adalah contoh program yang sama untuk mengimplementasikan singleton.

Contoh

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);
      }
   }
}

Simpan program di atas dalam Demo.scala. Perintah berikut digunakan untuk mengkompilasi dan menjalankan program ini.

Perintah

\>scalac Demo.scala
\>scala Demo

Keluaran

Point x location : 10
Point y location : 20