Tutorial Scala: Contoh & Kode Bahasa Pemrograman Scala

Ringkasan Tutorial Scala

Tutorial scala ini mencakup semua aspek dan topik scala. Anda akan mempelajari semua dasar-dasar dari awal seperti Apa itu scala, proses Instalasi scala, program Scala, Fungsi Scala, Evaluasi Malas, Jenis antarmuka, kelas dan objek, Warisan, Abstraksi, Java dan perbedaan skala, dll.

Scala adalah Bahasa Scalable yang digunakan untuk menulis Perangkat Lunak untuk berbagai platform. Oleh karena itu, ia mendapat nama “Scala”. Bahasa ini dimaksudkan untuk memecahkan masalah Java sekaligus lebih ringkas. Awalnya dirancang oleh Martin Odersky, dirilis pada tahun 2003.

Mengapa belajar Scala

Berikut adalah alasan utama untuk mempelajari Bahasa Pemrograman Scala:

• Scala mudah dipelajari oleh pemrogram berorientasi objek, Java pengembang. Ini menjadi salah satu bahasa populer dalam beberapa tahun terakhir.
• Scala menawarkan fungsi kelas satu bagi pengguna
• Scala dapat dijalankan FMV, sehingga membuka jalan bagi interoperabilitas dengan bahasa lain.
• Ini dirancang untuk aplikasi yang berbasis pesan secara bersamaan, terdistribusi, dan tangguh. Ini adalah salah satu bahasa yang paling menuntut pada dekade ini.
• Bahasanya ringkas, kuat, dan dapat berkembang dengan cepat sesuai permintaan penggunanya.
• Ini berorientasi objek dan memiliki banyak fitur pemrograman fungsional yang memberikan banyak fleksibilitas kepada pengembang untuk membuat kode sesuai keinginan mereka.
• Scala menawarkan banyak Jenis Bebek
• Ini memiliki lebih sedikit boilerplate jika Anda berasal Java
• Kerangka kerja Lift and Play yang ditulis dalam Scala berada dalam kurva pertumbuhan.

Bagaimana cara menginstal Scala

Untuk mulai menulis program Scala, Anda harus menginstalnya di komputer Anda. Untuk melakukan ini, Anda perlu mengunjungi situs mereka https://www.scala-lang.org/download/ untuk mengunduh Scala versi terbaru.

Dengan mengikuti tautan tersebut, kita akan diarahkan ke dua pilihan yang dapat kita pilih untuk menginstal Scala di komputer kita. Untuk tutorial Scala ini, kita akan mengunduh IntelliJ IDEA.

Setelah Anda mengunjungi tautan unduhan, Anda akan menemukan dua versi IntelliJ IDE.

Untuk tutorial Scala ini, kita akan mengunduh Edisi Komunitas, yang gratis dan dilengkapi semua yang Anda butuhkan untuk menulis program Scala.

Langkah 1) Pilih Edisi Komunitas
Di halaman tersebut, klik menu dropdown pada Edisi Komunitas.

Ini memberi kita opsi untuk mengunduh IntelliJ IDE bersama dengan JBR yang berisi implementasi JDK (Java Development Kit) OpenJDK yang Scala perlukan untuk mengkompilasi dan menjalankan kodenya.

Langkah 2) Jalankan instalasi
Setelah Anda mengunduh IntelliJ, klik dua kali untuk menjalankan panduan instalasi dan ikuti dialognya.

Langkah 3) Pilih lokasi
Pilih lokasi untuk menginstal IDE.

Jika kebetulan Anda tidak mengunduh yang disertai JDK, kami tetap mendapat perintah di mana kami dapat memeriksa untuk mengunduhnya dengan memilih kotak centang.

Langkah 4) Klik selanjutnya
Biarkan default lainnya apa adanya dan klik berikutnya.

Langkah 5) Klik pada ikon permulaan
Setelah instalasi selesai, jalankan IntelliJ IDE dengan mengklik ikon startup di menu startup seperti aplikasi biasa.

Anda masih harus melalui langkah tambahan untuk menambahkan plugin Scala ke IntelliJ; Anda melakukannya dengan mengklik dropdown pada menu konfigurasi yang terletak di kanan bawah layar dan memilih opsi plugin.

Pada tab Marketplace, pencarian Scala akan menampilkan plugin sebagai hasil pertama di bawah tag Bahasa.

Langkah 6) Pasang Plugin
Klik instal, yang akan mengarahkan plugin untuk memulai pengunduhan.

Langkah 7) Mulai ulang IDEnya
Setelah pengunduhan selesai, Anda akan diminta untuk me-restart IDE agar plugin yang diinstal dapat mulai bekerja.

Setelah memulai ulang, Anda akan menemukan halaman yang sama seperti sebelumnya ketika kami menjalankan IDE, tetapi kali ini kami telah menginstal plugin Scala.

Program Scala Halo Dunia

Langkah 1) Pilih opsi Buat Proyek, yang akan mengarahkan kita ke halaman di mana kita dapat memilih jenis bahasa yang akan digunakan proyek kita.

Langkah 2) pilih Scala dengan memilih kotak centang Scala dan klik berikutnya.

Langkah 3) Pilih lokasi untuk menyimpan file proyek kita dan beri nama proyek kita.

Jika direktori tidak ada, IntelliJ akan meminta kami meminta izin untuk membuat folder tersebut. Terima dan klik selesai. Anda akan dibawa ke proyek Scala Anda, yang saat ini tidak memiliki kode Scala apa pun.

Dibutuhkan beberapa waktu untuk memuat beberapa indeks jadi jangan khawatir jika Anda tidak dapat segera melakukan apa pun saat ada bilah kemajuan di bagian bawah IDE Anda, itu berarti IDE Anda sedang memuat beberapa file yang diperlukan untuk menjalankan Scala dan bantuan dengan pelengkapan otomatis IDE.

Langkah 4) Selanjutnya, kita akan mengklik tab proyek di sebelah kiri IDE dan memperluas sehingga kita dapat melihat isi proyek kita.

Saat ini proyek tersebut kosong dan hanya berisi folder .idea dan file hello-world.iml yang dihasilkan oleh IDE. Tempat menarik kami adalah folder src. Src adalah tempat kami menyimpan kode sumber untuk proyek kami. Di sinilah kita akan membuat file Scala pertama kita.

Langkah 5) Klik kanan pada src untuk membuka menu untuk membuat file Scala baru.

Kami kemudian akan membuat nama untuk file tersebut, dalam tutorial Scala ini kami akan menggunakan hello dan kemudian memilih dari dropdown apa yang akan dimasukkan sebagai konten file Scala. Pilih “Objek”

Setelah kita melakukan ini, kita akan memiliki file Scala yang memiliki objek Singleton yang akan kita gunakan untuk menjalankan kode kita.

Sekarang Anda memiliki file Scala dengan objek Hello. Anda akan menulis program pertama Anda dengan memperluas objek yang Anda buat menggunakan kata kunci App.

Memperluas objek kita dengan App memberi tahu kompiler kode mana yang harus dijalankan ketika memulai program Anda. Segera setelah memperluas Aplikasi, panah hijau muncul di sisi kiri, menunjukkan bahwa Anda sekarang dapat menjalankan program Anda.

Di dalam objek Hello, kita menulis satu fungsi println() yang digunakan untuk mencetak teks di dalamnya ke konsol. Kami akan menjalankan kode kami dengan mengklik panah hijau.

Mengklik panah memberi kita pilihan Jalankan, halo, setelah mengkliknya, kode kita akan mulai dikompilasi dan setelah beberapa detik kita akan melihat hasil program kita dicetak dari konsol yang ada di dalam IntelliJ IDE.

Dan ini dia, kita telah berhasil menginstal Scala dan menjalankan program pertama kita.

Apa yang dapat Anda lakukan dengan Scala

• Pengembangan web frontend dengan ScalaJS
• Pengembangan seluler, keduanya Android Pengembangan dan IOS – dengan Scala Native
• Pustaka sisi server seperti HTTP4S, Akka-Http, Play Framework
• Internet hal menggunakan
• Pengembangan game
• NLP – Pemrosesan Bahasa Alami menggunakan rangkaian perpustakaan ScalaNLP
• Menguji teknik pemrograman tingkat lanjut seperti Pemrograman Fungsional dan Pemrograman Berorientasi Objek
• Bangun aplikasi komunikasi serentak tinggi menggunakan pustaka aktor untuk JVM yang terinspirasi oleh Erlang
• Gunakan untuk pembelajaran mesin menggunakan perpustakaan seperti Figaro yang melakukan pemrograman probabilistik dan Apache Spark bahwa

Fungsi Anonim

Bahasa Scala memiliki fungsi anonim, yang disebut juga literal fungsi. Scala sebagai bahasa fungsional sering kali berarti pengembang memecah masalah besar menjadi banyak tugas kecil dan membuat banyak fungsi untuk memecahkan masalah tersebut. Untuk memudahkan pembuatan fungsi, Scala berisi fungsi-fungsi berikut ini dipakai tanpa nama. Kita dapat menetapkannya langsung ke variabel atau definisi 'def' seperti yang ditunjukkan pada contoh Scala di bawah ini:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n *3

Kita kemudian dapat menggunakan cara biasa kita menggunakan fungsi dengan meneruskan parameter ke fungsi berikut.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Metode ini berguna ketika kita ingin memiliki kode yang bersih dan ringkas. Kita dapat menggunakan fungsi anonim ketika mendefinisikan metode yang tidak besar dan tidak memerlukan banyak kode di dalamnya. Mereka sangat sederhana dan tidak memerlukan upacara untuk membuatnya.

Metode ini tidak terbatas pada fungsi dengan argumen dan dapat digunakan untuk membuat instance metode yang tidak menggunakan argumen apa pun.

val sayHello = ()=>{ println("hello") }

Sebagian besar fungsi anonim ini digunakan di bagian lain kode kita di mana kita perlu membuat fungsi cepat.

Alasan lain mengapa fungsi-fungsi ini juga disebut sebagai fungsi sebaris. Menggunakan fungsi anonim adalah pola umum yang digunakan secara luas di perpustakaan koleksi untuk melakukan tindakan cepat terhadap suatu koleksi.

Misalnya, kita memiliki metode filter yang menggunakan fungsi inline/fungsi anonim untuk membuat koleksi lain hanya dengan elemen yang memenuhi kriteria yang kita tentukan dalam fungsi anonim.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Di sini metode yang kita miliki sebagai fungsi anonim adalah metode yang memeriksa apakah nilai yang kita peroleh dari daftar ganjil atau genap dan mengembalikan item tersebut.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

Di Scala, dimungkinkan juga untuk menggunakan wildcard jika parameter fungsi anonim kita tidak diberi nama. Misalnya

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Dalam skenario ini, kami tidak memberi nama pada parameter yang kami lewati. Satu-satunya hal yang kami gunakan adalah garis bawah untuk mewakilinya.

Evaluasi Malas

Kebanyakan bahasa mengevaluasi variabel dan parameter fungsi secara berurutan, satu demi satu. Di Scala, kami memiliki kata kunci yang disebut malas, yang membantu menangani nilai yang tidak ingin kami evaluasi sampai nilai tersebut direferensikan.

Variabel yang ditandai sebagai lazy tidak akan dievaluasi pada tempat ia didefinisikan, hal tersebut umumnya dikenal sebagai eager evaluation (evaluasi yang tergesa-gesa), variabel tersebut hanya akan dievaluasi saat dirujuk di bagian tertentu dalam kode.

Hal ini dapat berguna ketika mengevaluasi suatu nilai mungkin merupakan perhitungan yang mahal, jika nilai tersebut tidak selalu dibutuhkan, kita dapat menyelamatkan diri dari menjalankan perhitungan yang mahal yang dapat memperlambat perangkat lunak kita dengan membuat variabel kita menjadi malas.

lazy val myExpensiveValue = expensiveComputation

def runMethod()={
    if(settings == true){
        use(myExpensiveValue)
    }else{
        use(otherValue)
    }
}

Ini bukan satu-satunya kasus penggunaan variabel malas. Mereka juga membantu mengatasi masalah ketergantungan melingkar pada kode.

Jika pengaturannya salah, kita mungkin tidak perlu menggunakan myExpensiveValue, yang dapat menyelamatkan kita dari melakukan komputasi mahal yang membantu memastikan bahwa pengguna bersenang-senang menggunakan aplikasi kita karena kebutuhan mereka yang lain dapat dihitung dengan benar tanpa berlebihan. RAMnya.

Jika pengaturannya salah, kita mungkin tidak perlu menggunakan myExpensiveValue, yang dapat menyelamatkan kita dari melakukan komputasi mahal yang membantu memastikan bahwa pengguna bersenang-senang menggunakan aplikasi kita karena kebutuhan mereka yang lain dapat dihitung dengan tepat tanpa berlebihan. RAMnya.

Kemalasan juga membantu argumen fungsi, di mana argumen hanya digunakan ketika direferensikan di dalam fungsi. Konsep ini disebut parameter panggilan berdasarkan nama.

def sometimesUsedString(someValue:String, defaultValue:=> String)={
 if(someValue != null){
   use(defaultValue)
 }else{
   use(someValue)
   }
 }

Banyak bahasa menggunakan metode call-by-value untuk mengevaluasi argumen. Parameter yang dilewatkan melalui call-by-name hanya akan dievaluasi saat dibutuhkan dalam badan fungsi dan tidak akan dievaluasi sebelum itu. Setelah nilai dievaluasi, nilai tersebut disimpan dan dapat digunakan kembali nanti tanpa harus dievaluasi ulang. Konsep ini dikenal sebagai memoization.

Ketik Inferensi

Di Scala, Anda tidak perlu mendeklarasikan tipe untuk setiap variabel yang Anda buat. Ini karena kompiler Scala dapat melakukan inferensi tipe pada tipe berdasarkan evaluasi sisi kanan. Hal ini memungkinkan kode Anda menjadi lebih ringkas – ini membebaskan kita dari penulisan boilerplate jika tipe yang diharapkan sudah jelas

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compile infers that third is of type String

Fungsi Tingkat Tinggi

Fungsi tingkat tinggi adalah fungsi yang dapat menggunakan fungsi sebagai argumen dan dapat mengembalikan fungsi sebagai tipe kembalian. Di Scala, fungsi dianggap sebagai warga negara kelas satu. Menggunakan fungsi-fungsi ini dengan cara ini memungkinkan kita menjadi sangat fleksibel dalam jenis program yang dapat kita buat. Kita dapat membuat fungsi secara dinamis dan memasukkan fungsionalitas secara dinamis ke fungsi lainnya.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={
    myMathFunction(n)
}

Dalam fungsi di atas, kita meneruskan int dan fungsi yang mengambil int dan mengembalikan int. Kita dapat meneruskan fungsi apa pun dari tanda tangan itu. Yang kami maksud dengan tanda tangan adalah masukan dan keluaran suatu fungsi. Tanda tangan Int=>Int berarti suatu fungsi mengambil Int sebagai masukan dan mengembalikan Int sebagai keluarannya.

Tanda Tangan ()=>Int berarti suatu fungsi tidak mengambil apa pun sebagai masukannya dan mengembalikan Int sebagai keluarannya. Contoh fungsi seperti itu adalah fungsi yang menghasilkan int acak untuk kita.

def generateRandomInt()={
 return scala.util.Random.nextInt()
}

Fungsi di atas memiliki tanda tangan ()=>Int

Kita dapat memiliki fungsi yang memiliki tanda tangan scala ()=>Unit. Ini berarti fungsinya tidak mengambil apa pun dan tidak mengembalikan tipe. Fungsinya bisa melakukan semacam komputasi dengan mengubah sesuatu menjadi melakukan sesuatu yang telah ditentukan.

Metode semacam ini tidak dianjurkan, karena tampaknya seperti kotak hitam yang dapat memengaruhi sistem dengan cara yang tidak diketahui. Metode ini juga tidak dapat diuji. Dengan memiliki tipe input dan output yang eksplisit, kita dapat bernalar tentang apa yang dilakukan fungsi kita.

Fungsi tingkat tinggi juga dapat mengembalikan suatu fungsi.

Misalnya, kita dapat membuat metode yang akan membuat fungsi pangkat, yaitu mengambil suatu bilangan dan menerapkan pangkat pada bilangan tersebut.

def powerByFunction(n:Int):Int=>Int = {
  return (x:Int)=> scala.math.pow(x,n).toInt
}

Fungsi di atas membutuhkan int. Tipe pengembalian kami adalah fungsi anonim yang menggunakan Int x, * kami menggunakan int x sebagai argumen untuk fungsi pangkat.

kari

Di Scala, kita bisa mengonversi fungsi yang mengambil dua argumen menjadi satu yang mengambil satu argumen dalam satu waktu. Saat kita meneruskan satu argumen, kita menerapkan sebagian argumen tersebut dan berakhir dengan fungsi yang memerlukan satu argumen untuk menyelesaikan fungsi tersebut. Currying memungkinkan kita membuat fungsi dengan menambahkan sebagian argumen.

Ini berguna untuk membuat fungsi secara dinamis sebelum kita memiliki serangkaian argumen lengkap

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Jika kita perlu membuat fungsi yang mengalikan suatu bilangan tertentu, kita tidak perlu membuat metode perkalian lain.

Kita cukup memanggil .curried pada fungsi kita di atas dan mendapatkan fungsi yang mengambil satu argumen terlebih dahulu dan mengembalikan fungsi yang diterapkan sebagian

def multiplyTwoNumbers(n:Int)(m:Int): Unit ={
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Pencocokan Pola

Scala memiliki mekanisme bawaan yang kuat untuk membantu kita memeriksa apakah suatu variabel cocok dengan kriteria tertentu, seperti yang akan kita lakukan dalam pernyataan switch di Java atau dalam serangkaian pernyataan if/else. Bahasa ini memiliki pencocokan pola yang dapat kita gunakan untuk memeriksa apakah suatu variabel bertipe tertentu. Pencocokan pola di Scala sangat berguna dan dapat digunakan untuk mendestrukturisasi komponen yang memiliki metode yang tidak dapat diterapkan untuk mendapatkan bidang yang kami minati langsung dari variabel yang kami cocokkan.

Pencocokan pola Scala juga memberikan sintaks yang lebih menyenangkan dibandingkan dengan pernyataan switch.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Kita membandingkan variabel kita dengan sekumpulan opsi, dan ketika variabel yang kita cocokkan memenuhi kriteria, ekspresi di sisi kanan panah gemuk (=>) akan dievaluasi dan dikembalikan sebagai hasil pencocokan.

Kami menggunakan garis bawah untuk menangkap kasus yang tidak cocok dengan kode kami. Ini mencerminkan perilaku kasus default ketika berhadapan dengan pernyataan switch.

class Animal(var legs:Int,var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //case we have a type we don't recognize do sth else
}

Pada kode di atas, Anda dapat mengetahui jenis variabel myItem dan berdasarkan cabangnya ke beberapa kode tertentu.

Pencocokan pola memeriksa apakah variabel cocok

Garis bawah berfungsi sebagai pengganti yang cocok dengan kondisi lain yang tidak cocok dengan item lain dalam pernyataan kasus di atas. Kami mengambil variabel myItem dan memanggil metode pencocokan.

• kami memeriksa apakah myItem benar menggunakan dan melakukan logika di Sisi Kanan panah gemuk “=>.”
• kami menggunakan garis bawah untuk mencocokkan apa pun yang tidak cocok dengan pernyataan kasus mana pun yang telah kami definisikan dalam kode.

Dengan kelas Case, kita bahkan bisa melangkah lebih jauh dan merusak struktur kelas untuk mendapatkan field di dalam objek.

Dengan menggunakan kata kunci yang disegel untuk mendefinisikan kelas-kelas kita, kita mendapatkan keuntungan karena kompiler secara mendalam memeriksa kasus-kasus yang kita coba cocokkan dan memperingatkan kita jika kita lupa menangani kasus tertentu.

Kekekalan

Dimungkinkan untuk membuat nilai yang tidak dapat diubah oleh fungsi lain di Scala menggunakan kata kunci val. Hal ini dicapai dalam Java dengan menggunakan kata kunci terakhir. Di Scala, kita melakukannya dengan menggunakan kata kunci val saat membuat variabel alih-alih menggunakan var, yang merupakan alternatif yang akan kita gunakan untuk membuat variabel yang bisa diubah.

Variabel yang didefinisikan menggunakan kata kunci val bersifat read-only, sedangkan variabel yang didefinisikan dengan var dapat dibaca dan diubah oleh fungsi lain atau secara sewenang-wenang oleh pengguna dalam kode.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Mencoba memberikan nilai ke myNumber setelah kita mendeklarasikannya sebagai val akan menimbulkan kesalahan waktu kompilasi atau “penugasan ulang ke val.”

Mengapa menggunakan Kekekalan?

Kekekalan membantu kita mencegah kode dan pemrogram lain mengubah nilai kita secara tidak terduga, yang akan memberikan hasil yang tidak diharapkan jika mereka bermaksud menggunakan nilai yang kita simpan, mereka malah dapat membuat salinannya. Dengan cara ini, bug yang dapat disebabkan oleh banyak aktor yang mengubah variabel yang sama dapat dicegah.

Kelas dan Objek

Kita semua tahu bahwa objek adalah entitas dunia nyata, dan kelas adalah templat yang mendefinisikan objek. Kelas memiliki status dan perilaku. Status bisa berupa nilai atau variabel. Perilaku adalah metode di Scala.

Mari kita lihat bagaimana Anda dapat mendefinisikan kelas, membuat instance, dan menggunakannya menggunakan Scala.

Di sini, kelasnya disebut Rectangle, yang memiliki dua variabel dan dua fungsi. Anda juga dapat menggunakan parameter l dan b secara langsung sebagai kolom dalam program. Anda memiliki objek yang memiliki metode utama dan telah membuat instance kelas dengan dua nilai.

Contoh:

class Rectangle( l: Int,  b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Semua bidang dan metode secara default bersifat publik di Scala. Penting untuk menggunakan override karena metode toString didefinisikan untuk Objek di Scala.

Warisan

Scala memiliki beberapa jenis pewarisan (seperti tunggal, multi-level, jamak, hierarkis, hibrida,) yang memiliki banyak kesamaan dengan bentuk tradisional yang ditemukan di Java. Anda dapat mewarisi baik dari kelas maupun sifat. Anda dapat mewarisi anggota dari satu kelas ke kelas lain menggunakan kata kunci “extends”. Hal ini memungkinkan penggunaan kembali.

Dimungkinkan untuk mewarisi dari satu kelas atau beberapa kelas. Dimungkinkan juga untuk mewarisi dari subkelas yang memiliki superkelasnya sendiri, sehingga menciptakan hierarki warisan dalam prosesnya.

Dalam contoh Scala di bawah, kelas Dasarnya adalah Lingkaran, dan kelas turunannya adalah Sphere. Sebuah lingkaran memiliki nilai yang disebut radius, yang diwarisi dalam kelas Sphere. Metode calcArea diganti menggunakan kata kunci override.

Contoh:

class Circle {
  val radius = 5;
  def calcArea = {
    println(radius * radius )
  }
}
class Sphere extends Circle{
 override def calcArea = {
    println(radius * radius * radius )
  }
}
  object SphereObject{
    def main(args : Array[String]){
      new Sphere().calcArea 
    }
  }

Abstraksi

Di Scala, kita dapat membuat metode abstrak dan bidang anggota menggunakan kelas dan sifat abstrak. Di dalam kelas dan sifat abstrak, kita dapat mendefinisikan bidang abstrak tanpa harus mengimplementasikannya.

Contoh:

trait MakesSound{
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int){
    val creatureName:String

    def printLegs():String={
        return s"$creatureName has this number of legs: $legs"
    }
}

Bidang-bidang ini diimplementasikan oleh kelas-kelas yang memperluas sifat atau kelas abstrak. Anda dapat menggunakan sifat untuk membuat kontrak mengenai apa yang seharusnya dapat dilakukan oleh aplikasi kita dan kemudian mengimplementasikan metode-metode tersebut nanti.

trait DatabaseService{
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

Dengan cara ini, kita dapat merencanakan tampilan aplikasi kita tanpa menerapkan metode yang dapat membantu kita membayangkan tampilan berbagai metode. Ini mengikuti pola yang dikenal sebagai pemrograman untuk abstraksi dan bukan implementasi sebenarnya.

Kelas yang diawali dengan kata kunci abstract dapat berisi metode abstrak dan non-abstrak. Namun, pewarisan ganda tidak didukung di kelas abstrak. Jadi, Anda dapat memperluas paling banyak satu kelas abstrak.

Objek Tunggal

Singleton adalah kelas yang hanya dipakai satu kali dalam suatu program. Ini berasal dari pola pemrograman yang populer dan berguna yang dikenal sebagai “pola tunggal”. Ini berguna dalam membuat instance yang dimaksudkan untuk bertahan lama dan akan dapat diakses secara umum di seluruh program Anda yang statusnya merupakan bagian integral dalam mengoordinasikan kejadian di suatu sistem. Membuat kelas seperti itu di Scala sangatlah mudah karena Scala memberi kita cara sederhana untuk membuat singleton menggunakan kata kunci objek.

object UserProfile{
    var userName=""
    var isLoggedIn:Boolean = false
}

Kita kemudian dapat mereferensikan objek ini ke seluruh program kita dengan jaminan bahwa semua bagian program kita akan melihat data yang sama karena hanya ada satu contoh saja.

def getLoggedInStatus():Boolean={
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean={
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return  UserProfile.isLoggedIn
}

Konsep anggota statis tidak ada di Scala, itulah alasan Anda perlu menggunakan objek tunggal, yang bertindak seperti anggota statis suatu kelas.

Kelas Implisit

Kelas implisit adalah fungsionalitas baru yang ditambahkan setelah versi 2.1. Tujuan utamanya adalah untuk menambahkan fungsionalitas baru ke kelas tertutup.

Kata kunci implisit harus didefinisikan dalam kelas, objek, atau sifat. Konstruktor utama kelas implisit harus memiliki satu argumen dalam daftar parameter pertamanya. Ini mungkin juga mencakup daftar parameter implisit tambahan.

Dalam contoh Scala di bawah ini, fungsionalitas baru untuk mengganti vokal suatu String dengan * ditambahkan.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Anda perlu mengimpor di kelas tempat Anda menggunakannya.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Pemrograman Berorientasi Objek (OOP) vs. Pemrograman Fungsional (FP)

Dalam OOP, program dibangun dengan mengelompokkan data dan fungsi yang beroperasi pada data tersebut ke dalam unit-unit yang saling terhubung. Objek membawa datanya dalam bidang dan metode yang beroperasi padanya. Dalam gaya pemrograman ini, abstraksi utamanya adalah data karena metode yang dibuat dimaksudkan untuk beroperasi pada data tersebut.

Pemrograman fungsional, di sisi lain, memisahkan data dan fungsi yang beroperasi pada data tersebut. Hal ini memungkinkan pengembang untuk memperlakukan fungsi sebagai abstraksi dan kekuatan pendorong saat memodelkan program.

Scala memungkinkan pemrograman fungsional dengan menjadikan fungsi sebagai warga kelas satu, yang memungkinkan fungsi tersebut diteruskan sebagai nilai ke fungsi lain dan dikembalikan sebagai nilai juga. Kombinasi kedua paradigma ini menjadikan Scala pilihan yang tepat dalam membangun perangkat lunak kompleks di berbagai industri, seperti Ilmu Data.

Kerangka kerja penting pada Scala

Berikut adalah beberapa kerangka kerja penting Scala

• Bermain adalah kerangka aplikasi web sumber terbuka yang menggunakan arsitektur MVC. Dirilis pada tahun 2007 dan sekarang dilisensikan di bawah Apache, Ini menjadi kerangka kerja paling populer di GitHub pada tahun 2013. Perusahaan seperti LinkedIn, Walmart, Samsung, Eero menggunakan kerangka kerja ini.
• Mengangkat adalah kerangka web gratis lainnya yang ditulis dalam Scala yang diluncurkan pada tahun 2007. Foursquare menggunakan kerangka Lift. Ini berkinerja tinggi, lebih cepat untuk membangun kerangka kerja.
• Acre
• Kucing - Leecork
• Spark

Dukungan konkurensi

• Nilai-nilai di Scala secara default tidak dapat diubah. Hal ini membuatnya sangat adaptif terhadap lingkungan yang ada secara bersamaan.
• Ada banyak fitur di Scala yang menjadikannya yang terbaik untuk aplikasi bersamaan.
• Futures dan Promises mempermudah pemrosesan data secara asinkron, sehingga mendukung paralelisme.
• Akka – toolkit yang menggunakan model konkurensi Aktor. Ada sejumlah Aktor yang bertindak ketika mereka menerima pesan.
• Konkurensi menggunakan thread dari Java juga dapat didukung di Scala.
• Pemrosesan aliran adalah fitur hebat lainnya yang memungkinkan pemrosesan data secara terus-menerus dan real-time.

Scala memiliki beberapa perpustakaan konkurensi terbaik di Java ekosistem.

• Asli Java benang
• Serat dari perpustakaan seperti Vertex
• ZIO – sebuah pustaka yang memiliki primitif untuk membantu kita menangani konkurensi dan komputasi asinkron
• STM – Transaksi
• Masa Depan – bawaan dalam bahasa Scala

Java vs.Skala

Inilah yang utama perbedaan antara Java dan Scala.

Scala	Java
Lebih kompak dan ringkas	Potongan kode yang relatif lebih besar
Dirancang dan Dikembangkan untuk menjadi bahasa berorientasi objek dan fungsional. Mendukung berbagai fitur pemrograman fungsional seperti konkurensi, Kekekalan.	Awalnya dikembangkan sebagai bahasa berorientasi objek dan mulai mendukung fitur pemrograman fungsional dalam beberapa hari terakhir. Masih belum kuat sebagai bahasa pemrograman fungsional.
Menggunakan model aktor untuk mendukung konkurensi yang modern	Menggunakan model berbasis thread konvensional untuk konkurensi.
Mendukung kerangka kerja – Putar, Angkat	Mendukung Spring, Grails, dan banyak lagi
Mendukung evaluasi malas	Tidak mendukung evaluasi malas
Tidak ada anggota statis	Berisi anggota statis
Mendukung kelebihan beban operator	Tidak mendukung kelebihan operator
Kompilasi kode sumber relatif lambat	Kompilasi kode sumber lebih cepat dari Scala
Sifat – bertindak seperti Java 8 antarmuka	Java 8 antarmuka mencoba menjembatani kesenjangan antara kelas dan antarmuka
Penulisan ulang diperlukan	Menulis ulang tidak diperlukan
Tidak ada jaminan tentang kode bebas bug	Jaminan penuh atas cacat yang lebih kecil
Mendukung kompatibilitas ke belakang.	Scala tidak mendukung kompatibilitas ke belakang.
Operator diperlakukan berbeda di Java dan bukan pemanggilan metode.	Semua operator pada entri melalui metode yang disebut di Scala.
Mendukung banyak warisan menggunakan kelas tetapi tidak dengan kelas abstrak	Tidak mendukung banyak warisan menggunakan kelas, tetapi dengan antarmuka
Kode ditulis dalam bentuk yang ringkas.	Kode ditulis dalam bentuk panjang.
Scala tidak mengandung kata kunci statis.	Java berisi kata kunci statis.

Ringkasan

Dalam tutorial ini, Anda telah mempelajari cara memulai Scala. Anda juga telah mempelajari fitur fungsional dan berorientasi objek. Anda juga telah menemukan persamaan dan perbedaan di antara keduanya Java dan Scala. Tutorial ini seharusnya membantu Anda dengan berbagai macam contoh yang ditunjukkan dengan baik.