Scala Eğitimi

Skala nedir?

Scala Scala, uygulamaların ölçeklenebilirliğini artırmak için nesne yönelimli ve fonksiyonel programlamayı birleştiren, statik olarak tiplendirilmiş bir programlama dilidir. Scala öncelikle JVM platformunda çalışır ve geliştiriciler ayrıca Scala-Native aracılığıyla yerel platformlar için veya ScalaJs ve diğer araçlar aracılığıyla tarayıcı için yazılım yazmak için de kullanabilirler. JavaSenaryo Çalışma süresi.

Scala, adından da anlaşılacağı gibi, birden fazla platform için yazılım geliştirmek amacıyla kullanılan ölçeklenebilir bir dildir. Dil, karmaşık kod yapılarında karşılaşılan birçok gereksiz ayrıntı sorununu çözmek için tasarlanmıştır. Java Özlü kalmayı başarırken, Martin Odersky tarafından tasarlanan Scala'nın ilk halka açık sürümü 2004 yılında yayınlandı.

Neden Scala öğrenmelisiniz?

İşte Scala programlama dilini öğrenmenin başlıca nedenleri:

• Scala, nesne yönelimli programcılar için öğrenmesi kolay bir dildir ve Java Geliştiriciler arasında yaygın olarak kullanılan ve son yıllarda popüler dillerden biri haline gelen bir dildir.
• Scala, kullanıcılara birinci sınıf işlevler sunar.
• Scala, şu platformlarda çalıştırılabilir: JVMBu durum, diğer dillerle birlikte çalışabilirliğin önünü açıyor.
• Eş zamanlı, dağıtık ve dayanıklı mesaj odaklı uygulamalar için tasarlanmıştır; bu da onu bu on yılın en çok talep gören dillerinden biri yapmaktadır.
• Bu, kullanıcılarının talebine göre hızla gelişebilen, özlü ve güçlü bir dildir.
• Nesne yönelimli bir dildir ve birçok fonksiyonel programlama özelliğini içerir; bu da geliştiricilere kod yazma biçimlerinde büyük bir esneklik sağlar.
• Scala, Duck Ty'ı sunuyor.ping yapısal tipler aracılığıyla.
• Daha az tekrarlayan ifade içeriyor. Java.
• Scala dilinde yazılmış olan Lift ve Play framework'leri olgunlaşmaya ve popülerlik kazanmaya devam ediyor.

Scala nasıl kurulur

Scala programları yazmaya başlamak için bilgisayarınıza Scala'yı kurmanız gerekir. Bunu yapmak için resmi siteyi ziyaret edin: https://www.scala-lang.org/download/ Scala'nın en son sürümünü indirmek için.

Bağlantıyı takip ettiğinizde, Scala'yı yüklemek için iki seçenek sunulacaktır. Bu Scala eğitiminde, ikinci seçeneği kullanacağız. IntelliJ IDEABu, kutudan çıktığı gibi mükemmel Scala desteği sunmaktadır.

İndirme bağlantısını ziyaret ettiğinizde, IntelliJ IDE'nin iki sürümünü bulacaksınız.

Bu Scala eğitiminde, ücretsiz olan ve Scala programları yazmak için ihtiyacınız olan her şeyi içeren Community Edition'ı indireceğiz.

) 1 Adım Topluluk Sürümünü seçin.
Sayfada, Topluluk Sürümü açılır menüsüne tıklayın.

Bu, JDK uygulamasını içeren JBR ile birlikte IntelliJ IDE'yi indirme seçeneği sunar (Java Scala'nın kod derlemek ve çalıştırmak için ihtiyaç duyduğu OpenJDK gibi bir geliştirme kiti.

) 2 Adım Kurulumu çalıştırın.
IntelliJ'i indirdikten sonra, yükleyiciye çift tıklayın ve ekrandaki yönergeleri izleyin.

) 3 Adım Bir konum seçin.
IDE'nin kurulacağı konumu seçin.

JDK paketini indirmediyseniz bile, kurulum sırasında yükleyici yine de bir onay kutusu aracılığıyla JDK'yı eklemenizi isteyecektir.

) 4 Adım Sonrakine tıkla.
Diğer varsayılan ayarları olduğu gibi bırakın ve İleri'ye tıklayın.

Scala Merhaba Dünya Programı

) 5 Adım Başlangıç ​​simgesine tıklayın.
Kurulum tamamlandıktan sonra, Başlat menüsündeki başlangıç ​​simgesine tıklayarak IntelliJ IDE'yi normal bir uygulama gibi çalıştırın.

IntelliJ'ye Scala eklentisini eklemeniz gerekiyor. Ekranın sağ alt köşesindeki yapılandırma menüsündeki açılır menüye tıklayın ve Eklentiler seçeneğini seçin.

Pazar Yeri sekmesinde Scala'yı arayın. Eklenti, Diller etiketi altında ilk sonuç olarak görünür.

) 6 Adım Eklentiyi kurun.
Scala eklentisini indirmeye başlamak için Yükle'ye tıklayın.

) 7 Adım IDE'yi yeniden başlatın.
İndirme işlemi tamamlandıktan sonra, yüklenen eklentinin çalışmaya başlaması için IDE'yi yeniden başlatmanız istenir.

Yeniden başlattıktan sonra, daha önce olduğunuz sayfaya geri dönersiniz, ancak bu sefer Scala eklentisi yüklenmiş ve kullanıma hazırdır.

) 8 Adım "Proje Oluştur" seçeneğini seçin; bu sizi projenin dilini seçebileceğiniz bir sayfaya yönlendirecektir.

) 9 Adım Scala seçeneğini belirlemek için Scala onay kutusunu işaretleyin ve İleri'ye tıklayın.

) 10 Adım Proje dosyasını kaydetmek için bir konum seçin ve projeye bir ad verin.

Eğer klasör mevcut değilse, IntelliJ klasörü oluşturmak için izin isteyecektir. İzin verin ve Bitir'e tıklayın. Ardından, şu anda herhangi bir Scala kodu içermeyen Scala projenize yönlendirileceksiniz.

Dizinlerin yüklenmesi biraz zaman alıyor, bu nedenle altta bir ilerleme çubuğu görünürken IDE ile etkileşim kuramıyorsanız endişelenmeyin. IDE, Scala'yı çalıştırmak ve otomatik tamamlama sağlamak için gerekli dosyaları yüklüyor.

) 11 Adım IDE'nin sol tarafındaki Proje sekmesine tıklayın ve genişleterek projenin içeriğini görüntüleyin.

Bu aşamada proje boştur ve yalnızca IDE tarafından oluşturulan bir .idea klasörü ve bir hello-world.iml dosyası içerir. İlgi çekici nokta, projenin kaynak kodunu barındıran src klasörüdür. İlk Scala dosyanızı burada oluşturacaksınız.

) 12 Adım `src` üzerine sağ tıklayarak bir menü açın ve yeni bir Scala dosyası oluşturun.

Dosya için bir ad seçin. Bu Scala eğitiminde, şunu kullanın: merhabaArdından, Scala dosyasının içerik türü için açılır menüden Nesne'yi seçin.

Bunu yaptığınızda, kodu çalıştırmak için kullanacağınız tekil bir nesne içeren bir Scala dosyanız olur.

Artık Hello nesnesi içeren bir Scala dosyanız olduğuna göre, App anahtar kelimesini kullanarak oluşturduğunuz nesneyi genişleterek ilk programınızı yazın.

Nesneyi `App` ile genişletmek, derleyiciye program başladığında hangi kodu çalıştıracağını söyler. `App` genişletildikten hemen sonra, sol tarafta yeşil bir ok belirir ve bu da programın artık çalıştırılabilir olduğunu gösterir.

Hello nesnesinin içine, metni konsola yazdırmak için println() fonksiyonunu yazın. Yeşil oka tıklayarak programı çalıştırın.

Oka tıklamak "Hello'yu Çalıştır" seçeneğini sunar. Bu seçeneği seçmek kodu derler ve birkaç saniye sonra program çıktısı IntelliJ konsolunda görünür.

Scala'yı başarıyla kurdunuz ve ilk programınızı çalıştırdınız.

Scala ile yapabilecekleriniz

Scala, esnekliği ve JVM ile uyumluluğu nedeniyle birçok alanda yaygın olarak kullanılmaktadır. Yaygın kullanım örnekleri şunlardır:

• ScalaJS ile ön uç web geliştirme.
• Mobil uygulama geliştirme Android ve Scala Native ile iOS.
• HTTP4S, Akka-Http ve Play Framework gibi sunucu tarafı kütüphaneleri.
• Nesnelerin İnterneti (IoT) uygulamaları.
• Oyun geliştirme.
• ScalaNLP kütüphane paketi kullanılarak doğal dil işleme.
• Fonksiyonel programlama ve nesne yönelimli programlama gibi ileri teknikleri birlikte uygulamak.
• Aktörler kullanarak yüksek eş zamanlılık sağlayan iletişim uygulamaları; Erlang'dan esinlenilmiş bir JVM kütüphanesidir.
• Olasılıksal programlama için Figaro ve Apache gibi kütüphanelerle makine öğrenimi. Spark Büyük ölçekli veri işleme için.

Anonim İşlevler

Scala dili, anonim fonksiyonları da destekler. işlev değişmezleriScala fonksiyonel bir dil olduğu için, geliştiriciler genellikle büyük problemleri birçok küçük göreve böler ve birçok fonksiyon oluşturur. Bunu kolaylaştırmak için Scala, fonksiyonların şu şekilde olmasına izin verir: isimsiz örneklenmişBunları doğrudan değişkenlere veya tanımlara atayabilirsiniz. defAşağıdaki Scala örneğinde gösterildiği gibi:

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

Daha sonra bunları parametreler geçirerek normal fonksiyonlar gibi kullanabilirsiniz:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Bu yöntemler, temiz ve özlü kod istediğinizde işinize yarar. Anonim fonksiyonlar, küçük ve gövdesinde çok fazla kod gerektirmeyen metotlar tanımlarken kullanışlıdır. Çok basittirler ve oluşturulmaları için herhangi bir işlem gerektirmezler.

Bu yöntemler yalnızca argüman alan fonksiyonlarla sınırlı değildir ve argüman almayan yöntemleri örneklemek için de kullanılabilir.

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

Bu anonim fonksiyonların çoğu, hızlı bir fonksiyona ihtiyaç duyulan kodun diğer bölümlerinde kullanılır. Bu nedenle, bunlara ayrıca anonim fonksiyonlar da denir. satır içi işlevlerAnonim fonksiyonların kullanımı, koleksiyonlar üzerinde hızlı işlemler gerçekleştirmek için koleksiyon kütüphanesinde sıkça karşılaşılan bir yöntemdir.

Örneğin, filtre yöntemi, anonim fonksiyonda tanımlanan kriterleri karşılayan öğeleri içeren başka bir koleksiyon oluşturmak için satır içi bir fonksiyon alır.

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)

Burada anonim fonksiyonlar listedeki değerin tek mi yoksa çift mi olduğunu kontrol eder ve eşleşen öğeyi döndürür.

//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

Scala'da, isimsiz fonksiyon parametresinin adlandırılmadığı durumlarda joker karakterler kullanmak da mümkündür. Örneğin:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Bu senaryoda parametreye isim vermiyorsunuz. Bunun yerine alt çizgi (_) kullanılıyor.

Tembel Değerlendirme

Çoğu programlama dili, değişkenleri ve fonksiyon parametrelerini sırayla, birbiri ardına değerlendirir. Scala'da ise anahtar kelime... lazy Değerlerin referans alınana kadar değerlendirilmesini istemediğiniz durumlarla başa çıkmanıza yardımcı olur.

"Lazy" olarak işaretlenmiş bir değişken, tanımlandığı yerde (yani "eager evaluation") değerlendirilmez. Yalnızca kodda daha sonra kendisine referans verildiğinde değerlendirilir.

Bu, bir değerin değerlendirilmesinin maliyetli bir hesaplama gerektirdiği durumlarda faydalı olabilir. Değere her zaman ihtiyaç duyulmuyorsa, değişkeni tembel hale getirerek yazılımı yavaşlatabilecek maliyetli bir hesaplamadan kendinizi kurtarırsınız.

lazy val myExpensiveValue = expensiveComputation

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

Tembel değişkenlerin tek kullanım alanı bu değil. Ayrıca koddaki döngüsel bağımlılıklarla başa çıkmaya da yardımcı olurlar.

Ayarlar bayrağı yanlışsa, myExpensiveValue'ı kullanmanıza gerek kalmaz; bu da maliyetli bir hesaplama yapmaktan sizi kurtarır. Bu, kaynakların asla okunmayan değerler için israf edilmemesini sağlayarak kullanıcıların sorunsuz bir deneyim yaşamasına yardımcı olur.

Tembellik, fonksiyon argümanlarında da işe yarar; bu argümanlar yalnızca fonksiyon içinde referans edildiklerinde kullanılır. Bu kavrama "İsimle çağrılan parametreler" denir.

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

Birçok programlama dili, argümanları değerlendirmek için değerle çağırma yaklaşımını kullanır. İsimle çağırma yoluyla geçirilen bir parametre, yalnızca fonksiyon gövdesi içinde ihtiyaç duyulduğunda değerlendirilir. Değer değerlendirildikten sonra saklanır ve daha sonra yeniden değerlendirilmeden tekrar kullanılabilir; bu kavrama memoizasyon denir.

Tür Çıkarımı

Scala'da, oluşturduğunuz her değişken için tür belirtmenize gerek yoktur çünkü Scala derleyicisi, ifadenin sağ tarafındaki verilerden türleri çıkarabilir. Bu, kodunuzun daha özlü olmasını sağlar ve beklenen türün açık olduğu yerlerde tekrarlayan kod yazmaktan sizi kurtarır.

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

Yüksek Mertebeli Fonksiyon

Yüksek dereceli bir fonksiyon, argüman olarak fonksiyon alabilen ve dönüş tipi olarak bir fonksiyon döndürebilen bir fonksiyondur. Scala'da fonksiyonlar birinci sınıf vatandaş olarak kabul edilir. Fonksiyonları bu şekilde kullanmak, oluşturabileceğiniz program türlerinde çok esnek olmanızı sağlar. Fonksiyonları dinamik olarak oluşturabilir ve işlevselliği diğer fonksiyonlara dinamik olarak aktarabilirsiniz.

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

Yukarıdaki fonksiyonda, bir parametre iletiyorsunuz. Int ve bir alan alan bir fonksiyon Int ve bir döndürür IntBu imzaya sahip herhangi bir fonksiyonu geçirebilirsiniz. İmza derken, bir fonksiyonun girdisini ve çıktısını kastediyoruz. Örneğin, bir fonksiyonun imzası. Int => Int Bu, bir fonksiyonun girdi olarak bir tamsayı (Int) alıp çıktı olarak bir tamsayı (Int) döndürdüğü anlamına gelir.

Bir imza () => Int Bu, bir fonksiyonun girdi olarak hiçbir şey almadığı ve çıktı olarak bir tamsayı (int) döndürdüğü anlamına gelir. Bu tür bir fonksiyona örnek olarak rastgele bir tamsayı üreten bir fonksiyon verilebilir.

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

Yukarıdaki fonksiyonun bir imzası vardır. () => Int.

Bir fonksiyonun ayrıca bir imzası da olabilir. () => UnitBu, fonksiyonun hiçbir girdi almadığı ve bir tür döndürmediği anlamına gelir. Fonksiyon bunun yerine bazı durumları değiştirebilir veya önceden belirlenmiş bir eylemi gerçekleştirebilir.

Bu tür yöntemler, bilinmeyen şekillerde sistemi etkileyebilen bir kara kutu gibi davranabildikleri için önerilmez. Ayrıca test edilmeleri de daha zordur. Açık girdi ve çıktı türlerine sahip olmak, fonksiyonunuzun ne yaptığını anlamanıza olanak tanır.

Üst düzey bir fonksiyon da bir fonksiyon döndürebilir. Örneğin, bir sayıyı alıp ona üs alan bir fonksiyon döndüren bir metot oluşturabilirsiniz.

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

Yukarıdaki fonksiyon bir tamsayı (int) alır. Dönüş türü ise tamsayı alan anonim bir fonksiyondur. x ve bunu üs alma fonksiyonunun argümanı olarak kullanır.

Körileme

Scala'da, iki argüman alan bir fonksiyonu, tek seferde bir argüman alan bir fonksiyona dönüştürebilirsiniz. Bir argüman geçirdiğinizde, onu kısmen uygularsınız ve kalan argümanı alarak çağrıyı tamamlayan bir fonksiyon elde edersiniz. Kısmi uygulama (Currying), bazı argümanları kısmen ekleyerek fonksiyonlar oluşturmanıza olanak tanır.

Bu, eksiksiz bir argüman kümesine sahip olmadan önce dinamik olarak fonksiyonlar oluşturmak için kullanışlıdır.

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

Belirli bir sayıyla çarpma işlemi yapan bir fonksiyona ihtiyacınız varsa, başka bir çarpma metodu oluşturmanıza gerek yoktur. Kısmi uygulama fonksiyonuna tek bir argüman uygulayabilir ve sonucu yeniden kullanabilirsiniz:

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Desen Eşleştirme

Scala, bir değişkenin belirli kriterlere uyup uymadığını kontrol etmenize yardımcı olan güçlü bir yerleşik mekanizmaya sahiptir; bu, bir switch ifadesine çok benzer. Java veya bir if/else ifadesi zinciri. Dil, bir değişkenin belirli bir türde olup olmadığını kontrol etmek için kullanabileceğiniz kalıp eşleştirmeyi destekler. Scala'da kalıp eşleştirme güçlüdür ve belirli bir türe sahip bileşenleri ayrıştırabilir. unapply Eşleştirilen değişkenden istediğiniz alanları doğrudan alma yöntemi.

Scala'da kalıp eşleştirme, switch ifadesine göre daha hoş bir sözdizimi sunar.

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

Değişkeni bir dizi seçenekle karşılaştırırsınız. Değişken kriterleri karşıladığında, kalın okun (=>) sağ tarafındaki ifade değerlendirilir ve eşleşmenin sonucu olarak bir değer döndürülür.

Alt çizgi, kodda eşleşmeyen durumları yakalar ve switch ifadesindeki varsayılan durumun davranışını yansıtır.

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 _ => //unknown type, do something else
}

Yukarıdaki kodda, nesnenin türünü tespit edebilirsiniz. myItem Değişkeni belirleyip, buna bağlı olarak belirli kodlara dallanmak.

Desen eşleştirme, değişkenin her bir duruma sırayla uyup uymadığını kontrol eder.

Alt çizgi, diğer durum ifadelerinin karşılamadığı herhangi bir koşula uyan bir yer tutucu görevi görür. Bir değişken alıyorsunuz. myItem ve ara match yöntemi.

• Kontrol edin myItem is true ve kalın ok işaretinin sağ tarafındaki mantığı çalıştırın: “=>”.
• Kodda tanımlanan durum ifadelerinden herhangi biriyle eşleşmeyen her şeyi eşleştirmek için alt çizgi kullanın.

Case sınıflarıyla, sınıfı ayrıştırarak inceleyebilirsiniz.tracNesnenin içindeki t alanları.

kullanılarak sealed Sınıfları tanımlamak için kullanılan anahtar kelime sayesinde, derleyicinin eşleştirmeye çalıştığınız durumları kapsamlı bir şekilde kontrol etmesinin ve birini ele almayı unuttuğunuzda sizi uyarmasının avantajından yararlanırsınız.

değişmezlik

Scala'da, diğer fonksiyonlar tarafından değiştirilemeyen değerler oluşturmak mümkündür. Bunun için şu yöntem kullanılır: val anahtar kelime. Bu, şu şekilde elde edilir: Java kullanarak final anahtar kelime. Scala'da bunu kullanırsınız. val değişken oluştururken bunun yerine varBu, değiştirilebilir değişkenler için alternatif bir yöntemdir.

Bir değişken, aşağıdaki yöntem kullanılarak tanımlanmıştır: val anahtar kelime salt okunurdur, oysa bir tanesi şu şekilde tanımlanmıştır: var Bu veriler daha sonra diğer fonksiyonlar veya kod içindeki kullanıcı tarafından okunabilir ve değiştirilebilir.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Bir değer atamaya çalışmak myNumber onu bir olarak ilan ettikten sonra val Derleme sırasında "val'e yeniden atama" hatası veriyor.

Neden Değişmezlik kullanılmalı?

Değişmezlik, kodun ve diğer programcıların değerleri beklenmedik şekilde değiştirmesini önlemeye yardımcı olur; bu da öngörülemeyen sonuçlara yol açar. Bir değeri kullananların onu değiştirmesi gerektiğinde, bunun yerine bir kopyasını oluşturabilirler. Bu şekilde, birden fazla aktörün aynı değişkeni değiştirmesinden kaynaklanan hatalar önlenir.

Sınıflar ve Nesneler

Nesneler gerçek dünyadaki varlıklardır ve sınıf, nesneleri tanımlayan bir şablondur. Sınıfların hem durumu hem de davranışları vardır. Durumlar ya değerlerdir ya da değişkenlerdir. Davranışlar ise Scala'daki metotlardır.

Sonraki bölümde Scala'da bir sınıfın nasıl tanımlanacağı, örneğinin nasıl oluşturulacağı ve nasıl kullanılacağı gösterilmektedir.

Burada, iki değere ve iki fonksiyona sahip olan Rectangle adlı bir sınıf bulunmaktadır. Parametreleri de kullanabilirsiniz. l hem de b Bunlar doğrudan programdaki alanlar olarak kullanılır. Ana metodu olan ve sınıfı iki değerle örnekleyen bir nesneniz var.

Örnek:

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 a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

Scala'da tüm alanlar ve metotlar varsayılan olarak herkese açıktır. Bu nedenle, bu özellikleri kullanmak çok önemlidir. override Çünkü toString Scala'daki her nesne için zaten tanımlanmıştır.

miras

Scala'da, geleneksel dillerde bulunan kalıtım biçimleriyle birçok ortak noktaya sahip birden fazla kalıtım türü (tekli, çok seviyeli, çoklu, hiyerarşik ve hibrit) vardır. JavaHem sınıflardan hem de özelliklerden miras alabilirsiniz. Bir sınıfın üyelerini başka bir sınıfa aktarmak için `extension` anahtar kelimesini kullanırsınız. extendsBu, yeniden kullanılabilirliği mümkün kılar.

Bir sınıftan veya birden fazla sınıftan miras almak mümkündür. Ayrıca, kendi üst sınıflarına sahip alt sınıflardan da miras almak mümkündür; bu süreçte bir miras hiyerarşisi oluşturulur.

Aşağıdaki Scala örneğinde, temel sınıf şudur: Circleve türetilmiş sınıf şudur: SphereBir dairenin yarıçap adı verilen bir değeri vardır ve bu değer Sphere sınıfına aktarılır. Bu yöntem calcArea anahtar kelime kullanılarak geçersiz kılınır override.

Örnek:

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

Abstracyon

Scala'da abs oluşturabilirsiniz.tracabs kullanarak t yöntemleri ve üye alanlarıtract sınıfları ve özellikleri. İçeride abstracSınıflar ve özellikler aracılığıyla, mutlak değerleri tanımlayabilirsiniz.tract alanlarını uygulamadan.

Örnek:

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"
    }
}

Bu alanlar, özelliği veya abs'yi genişleten sınıflar tarafından uygulanır.tract sınıfı. Özellikler kullanarak bağlam oluşturabilirsiniz.tracBir uygulamanın ne yapması gerektiğine dair ön bilgiler oluşturun ve daha sonra bu yöntemleri uygulayın.

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

Bu sayede, yöntemleri uygulamadan uygulamanın nasıl görüneceğini planlayabilirsiniz.ping Çeşitli yöntemlerin nasıl görüneceğini hayal ediyorsunuz. Bu, programlama yoluyla mutlaklaştırma olarak bilinen bir kalıbı izler.tracGerçek uygulamadan ziyade, beklentilere odaklanmaktadır.

Önsözüyle başlayan bir ders abstract anahtar kelime hem abs içerebilirtract ve abs olmayantract yöntemleri. Ancak, abs'de çoklu kalıtım desteklenmemektedir.tract sınıfı, bu yüzden sadece birini genişletebilirsiniz.tract sınıfı.

Tekil Nesneler

Singleton, bir programda yalnızca bir kez örneklendirilen bir sınıftır. "Singleton deseni" olarak bilinen popüler ve kullanışlı bir programlama deseninden gelir. Sistemdeki olayları koordine etmek için durumun ayrılmaz bir parçası olduğu, uzun ömürlü ve program boyunca sıkça erişilen örnekler oluşturmak için kullanışlıdır. Scala'da böyle bir sınıf oluşturmak kolaydır çünkü Scala, singleton'ları oluşturmak için basit bir yöntem sağlar. object Anahtar kelime.

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

Bu sayede programın her yerinde bu nesneye referans verebilirsiniz ve programın tüm bölümlerinin aynı veriyi göreceğinden emin olabilirsiniz, çünkü nesnenin yalnızca bir örneği vardır.

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

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

Scala'da statik üye kavramı yoktur; bu nedenle, bir sınıfın statik üyeleri gibi davranan tekil nesneler (singleton objects) kullanılır.

Örtülü Sınıflar

Örtük sınıflar, 2.10 sürümünde eklenen bir özelliktir ve esas olarak mevcut kapalı sınıflara yeni işlevsellik eklemek için kullanılır.

MKS implicit `<implicit>` anahtar kelimesi bir sınıf, nesne veya özellik içinde tanımlanmalıdır. Örtük bir sınıfın birincil kurucusunun ilk parametre listesinde tam olarak bir argümanı olmalıdır. Ayrıca ek bir örtük parametre listesi de içerebilir.

Aşağıdaki Scala örneğinde, bir dizenin sesli harflerini * ile değiştirmek için yeni bir işlevsellik eklendi.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Örtülü sınıfı kullandığınız sınıfta içe aktarmanız gerekiyor.

import StringUtil.StringEnhancer

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

Nesne Yönelimli Programlama (OOP) ve Fonksiyonel Programlama (FP) Karşılaştırması

Nesne yönelimli programlamada programlar gruplar tarafından oluşturulur.ping Verileri ve bu veriler üzerinde çalışan fonksiyonları son derece bağlantılı birimlere dönüştürmek. Nesneler verilerini alanlarda taşır ve metotlar bu alanlar üzerinde çalışır. Bu programlama tarzında, temel amaç, verileri ve bu veriler üzerinde çalışan fonksiyonları birbirine bağlamaktır.tracBuradaki amaç veriyi kullanmaktır, çünkü oluşturulan yöntemler veri üzerinde işlem yapmak üzere tasarlanmıştır.

Fonksiyonel programlamaÖte yandan, veriyi ve üzerinde işlem yapan fonksiyonları birbirinden ayırır. Bu, geliştiricilerin fonksiyonları mutlak değer olarak ele almalarını sağlar.tracProgramları modelleme sürecinde itici güç ve rol oynar.

Scala, fonksiyonları birinci sınıf vatandaş olarak ele alarak fonksiyonel programlamayı mümkün kılar; bu sayede fonksiyonlar diğer fonksiyonlara değer olarak aktarılabilir ve değer olarak geri döndürülebilir. Bu iki paradigmanın birleşimi, Scala'yı veri bilimi gibi sektörlerde karmaşık yazılımlar geliştirmek için mükemmel bir seçim haline getirmiştir.

Scala'daki önemli çerçeveler

İşte Scala için bazı önemli çerçeveler:

• OYNA kullanan açık kaynaklı bir web uygulama çerçevesidir. MVC mimarisi2007 yılında piyasaya sürülen ve şu anda Apache lisansı altında olan bu framework, 2013 yılına gelindiğinde GitHub'da en popüler framework'lerden biri haline geldi. LinkedIn gibi şirketler, WalmartSamsung ve Eero bu çerçeveyi kullanıyor.
• asansör 2007 yılında piyasaya sürülen, Scala ile yazılmış bir diğer ücretsiz web çerçevesi de Lift'dir. Foursquare, Lift çerçevesini kullanır. Bu, yüksek performanslı ve hızlı bir şekilde geliştirme imkanı sunan bir çerçevedir.
• Akça Bu, JVM üzerinde yüksek eş zamanlılık, dağıtım ve dayanıklılık özelliklerine sahip mesaj odaklı uygulamalar oluşturmak için bir araç seti sağlar.
• Kediler Bu, abs sağlayan bir kütüphanedir.tracFonksiyonel programlama için yöntemler.
• Spark Büyük ölçekli veri işleme için birleşik bir analiz motorudur ve büyük veri ve makine öğrenimi iş akışlarında yaygın olarak kullanılmaktadır.

Eşzamanlılık desteği

• Scala'daki değerler varsayılan olarak değiştirilemezdir, bu da onu eşzamanlı çalışma ortamlarına çok uyumlu hale getirir.
• Scala, eşzamanlı uygulamalar için ideal kılan birçok özelliğe sahiptir.
• Futures ve Promises, verilerin asenkron olarak işlenmesini kolaylaştırır ve dolayısıyla paralelliği destekler.
• Akka, Aktör eşzamanlılık modelini kullanan bir araç setidir. Aktörler, mesaj aldıklarında harekete geçerler.
• İş parçacıklarını kullanarak eşzamanlılık Java Scala'da da desteklenmektedir.
• Akış işleme, verilerin sürekli ve gerçek zamanlı olarak işlenmesini sağlayan bir diğer harika özelliktir.

Scala dünyadaki en iyi eşzamanlılık kitaplıklarından bazılarına sahiptir. Java ekosistem:

• Yerli Java İş Parçacığı.
• Vertx gibi kütüphanelerden gelen fiberler.
• ZIO, eşzamanlılık ve eşzamansız hesaplamalarla başa çıkmaya yardımcı olan temel bileşenlere sahip bir kütüphanedir.
• İşlemler için Yazılım İşlemsel Belleği (STM).
• Future, Scala diline entegre edilmiş bir özelliktir.

Java Scala'ya karşı

İşte ana arasındaki farklar Java ve Scala.

SSS