스칼라 튜토리얼: 스칼라 프로그래밍 언어 예제 및 코드

스칼라 튜토리얼 요약

이 스칼라 튜토리얼은 스칼라의 모든 측면과 주제를 다룹니다. 스칼라란 무엇인가, 스칼라 설치 과정, 스칼라 프로그램, 스칼라 함수, 지연 평가, 유형 인터페이스, 클래스 및 객체, 상속, 추상화 등 모든 기본 사항을 처음부터 배우게 됩니다. Java 스칼라 차이 등

스칼라란 무엇인가?

스칼라 함수형 프로그래밍과 객체 지향 프로그래밍을 모두 통합하여 애플리케이션의 확장성을 높이는 정적 타입 프로그래밍 언어입니다. Scala는 주로 JVM 플랫폼에서 실행되며 Scala-Native를 사용하여 네이티브 플랫폼용 소프트웨어를 작성하는 데에도 사용할 수 있습니다. Java스크립트 ScalaJ를 통한 런타임.

Scala는 여러 플랫폼용 소프트웨어를 작성하는 데 사용되는 확장 가능한 언어입니다. 그래서 '스칼라'라는 이름이 붙었습니다. 이 언어는 다음과 같은 문제를 해결하기 위해 만들어졌습니다. Java 동시에 더 간결합니다. 원래는 Martin Odersky가 디자인했으며 2003년에 출시되었습니다.

스칼라를 배워야 하는 이유

Scala 프로그래밍 언어를 배우는 주요 이유는 다음과 같습니다.

Scala는 객체 지향 프로그래머가 배우기 쉽습니다. Java 개발자. 최근 몇 년간 인기 있는 언어 중 하나가 되어가고 있습니다.
Scala는 사용자를 위한 최고 수준의 기능을 제공합니다.
스칼라는 다음에서 실행될 수 있습니다. JVM이로써 다른 언어와의 상호 운용성을 위한 길이 열렸습니다.
이는 동시적이고 분산되며 복원력이 뛰어난 메시지 기반 애플리케이션을 위해 설계되었습니다. 이는 지난 XNUMX년간 가장 까다로운 언어 중 하나입니다.
간결하고 강력한 언어이며 사용자의 요구에 따라 빠르게 성장할 수 있습니다.
이는 객체 지향적이며 개발자가 원하는 방식으로 코딩할 수 있는 많은 유연성을 제공하는 많은 기능적 프로그래밍 기능을 갖추고 있습니다.
스칼라는 다양한 오리 유형을 제공합니다.
당신이 출신이라면 상용구가 적습니다. Java
Scala로 작성된 프레임워크 Lift and Play는 성장 곡선에 있습니다.

스칼라 설치 방법

Scala 프로그램 작성을 시작하려면 컴퓨터에 Scala 프로그램을 설치해야 합니다. 이렇게 하려면 해당 사이트를 방문해야 합니다. https://www.scala-lang.org/download/ 최신 버전의 Scala를 다운로드하려면

링크를 따라가면, 우리는 우리 머신에 Scala를 설치하기 위해 선택할 수 있는 두 가지 옵션으로 안내됩니다. 이 Scala 튜토리얼에서는 다음을 다운로드합니다. IntelliJ IDEA.

다운로드 링크를 방문하면 두 가지 버전의 IntelliJ IDE를 찾을 수 있습니다.

이 Scala 튜토리얼에서는 Community Edition을 다운로드하겠습니다. 이는 무료이며 Scala 프로그램을 작성하는 데 필요한 모든 것이 포함되어 있습니다.

단계 1) 커뮤니티 에디션 선택
해당 페이지에서 커뮤니티 에디션의 드롭다운을 클릭합니다.

JDK 구현이 포함된 JBR과 함께 IntelliJ IDE를 다운로드할 수 있는 옵션이 제공됩니다.Java 개발 키트) Scala가 코드를 컴파일하고 실행하는 데 필요한 OpenJDK입니다.

단계 2) 설치 실행
IntelliJ를 다운로드한 후 두 번 클릭하여 설치 마법사를 실행하고 대화 상자의 지시를 따르세요.

단계 3) 위치를 선택하십시오
IDE를 설치할 위치를 선택합니다.

우연히 JDK가 포함된 것을 다운로드하지 못했더라도 체크박스를 선택하여 다운로드 여부를 확인할 수 있는 메시지가 표시됩니다.

단계 4) 다음을 클릭하십시오
다른 기본값은 그대로 두고 다음을 클릭합니다.

단계 5) 시작 아이콘을 클릭하세요
설치가 완료되면 일반 애플리케이션처럼 시작 메뉴에서 시작 아이콘을 클릭하여 IntelliJ IDE를 실행합니다.

IntelliJ에 Scala 플러그인을 추가하는 추가 단계를 거쳐야 합니다. 화면 오른쪽 하단에 있는 구성 메뉴에서 드롭다운을 클릭하고 플러그인 옵션을 선택하면 됩니다.

Marketplace 탭에서 Scala를 검색하면 언어 태그 아래 첫 번째 결과로 플러그인이 표시됩니다.

단계 6) 플러그인 설치
설치를 클릭하면 플러그인이 다운로드를 시작하게 됩니다.

단계 7) IDE 다시 시작
다운로드가 완료되면 설치된 플러그인이 작동할 수 있도록 IDE를 다시 시작하라는 메시지가 표시됩니다.

다시 시작하면 IDE를 실행했을 때와 동일한 페이지가 표시되지만 이번에는 이미 Scala 플러그인이 설치되어 있습니다.

스칼라 Hello World 프로그램

단계 1) 프로젝트 생성 옵션을 선택하면 프로젝트에서 사용할 언어 종류를 선택할 수 있는 페이지로 이동합니다.

단계 2) Scala 체크박스를 선택하여 Scala를 선택하고 다음을 클릭합니다.

단계 3) 프로젝트 파일을 저장할 위치를 선택하고 프로젝트 이름을 지정합니다.

디렉터리가 존재하지 않으면 IntelliJ는 폴더 생성 권한을 요청하는 메시지를 표시합니다. 동의하고 완료를 클릭하세요. 현재 Scala 코드가 없는 Scala 프로젝트로 이동됩니다.

일부 인덱스를 로드하는 데 시간이 좀 걸리므로 IDE 하단에 진행률 표시줄이 있는 동안 즉시 아무것도 할 수 없더라도 걱정하지 마세요. 이는 단순히 IDE가 Scala를 실행하는 데 필요한 일부 파일을 로드하고 있다는 의미일 뿐입니다. IDE 자동 완성에 대한 도움말.

단계 4) 다음으로, IDE 왼쪽에 있는 프로젝트 탭을 클릭하고 확장하여 프로젝트 내용을 확인하겠습니다.

현재 프로젝트는 비어 있으며 IDE에서 생성된 .idea 폴더와 hello-world.iml 파일만 포함되어 있습니다. 우리의 관심 지점은 src 폴더입니다. Src는 프로젝트의 소스 코드를 저장하는 곳입니다. 여기에서 첫 번째 Scala 파일을 생성할 것입니다.

단계 5) src를 마우스 오른쪽 버튼으로 클릭하면 새 Scala 파일을 생성할 수 있는 메뉴가 열립니다.

그런 다음 파일 이름을 만듭니다. 이 Scala 튜토리얼에서는 hello를 사용한 다음 Scala 파일의 콘텐츠로 넣을 내용을 드롭다운에서 선택합니다. "객체"를 선택하세요.

이렇게 하면 코드를 실행하는 데 사용할 Singleton 개체가 포함된 Scala 파일이 생성됩니다.

이제 Hello 개체가 포함된 Scala 파일이 생겼습니다. App 키워드를 사용하여 만든 개체를 확장하여 첫 번째 프로그램을 작성합니다.

App으로 객체를 확장하면 프로그램을 시작할 때 실행할 코드를 컴파일러에 알려줍니다. 앱을 확장한 직후 녹색 화살표가 왼쪽에 표시되어 이제 프로그램을 실행할 수 있음을 나타냅니다.

Hello 객체 안에는 내부 텍스트를 콘솔에 인쇄하는 데 사용되는 println() 함수 하나를 작성합니다. 녹색 화살표를 클릭하여 코드를 실행하겠습니다.

화살표를 클릭하면 Run, hello 옵션이 표시됩니다. 이 화살표를 클릭하면 코드 컴파일이 시작되고 몇 초 후에 IntelliJ IDE에 내장된 콘솔에서 인쇄된 프로그램 결과를 볼 수 있습니다.

이제 Scala를 성공적으로 설치하고 첫 번째 프로그램을 실행했습니다.

스칼라로 할 수 있는 일

ScalaJS를 사용한 프런트엔드 웹 개발
모바일 개발, 둘 다 Android 개발 및 IOS – Scala Native 사용
HTTP4S, Akka-Http, Play Framework와 같은 서버 측 라이브러리
사물인터넷을 활용한
게임 개발
NLP - 라이브러리 ScalaNLP를 사용한 자연어 처리
함수형 프로그래밍 및 객체 지향 프로그래밍과 같은 고급 프로그래밍 기술 테스트
Erlang에서 영감을 받은 JVM용 라이브러리인 액터를 사용하여 고도로 동시 통신 애플리케이션을 구축합니다.
확률적 프로그래밍을 수행하는 Figaro와 Apache와 같은 라이브러리를 사용하여 기계 학습에 사용합니다. Spark 그

익명 기능

Scala 언어에는 익명 함수라고도 불리는 익명 함수가 있습니다. 함수 리터럴. Scala는 함수형 언어이기 때문에 개발자가 큰 문제를 여러 개의 작은 작업으로 나누고 이러한 문제를 해결하기 위해 많은 함수를 만드는 경우가 많습니다. 함수를 쉽게 생성할 수 있도록 Scala에는 다음과 같은 함수가 포함되어 있습니다. 이름 없이 인스턴스화됨. 아래 Scala 예제와 같이 변수 또는 정의 'def'에 직접 할당할 수 있습니다.

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

그런 다음 매개변수를 다음과 같이 전달하여 함수를 사용하는 일반적인 방법을 사용할 수 있습니다.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

이러한 방법은 깨끗하고 간결한 코드를 원할 때 유용합니다. 크지 않고 본문에 많은 코드가 필요하지 않은 메서드를 정의할 때 익명 함수를 사용할 수 있습니다. 매우 간단하며 만드는 데 의식이 필요하지 않습니다.

이러한 메서드는 인수가 있는 함수에만 국한되지 않으며 인수를 사용하지 않는 메서드를 인스턴스화하는 데 사용할 수 있습니다.

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

이러한 익명 함수의 대부분은 빠른 함수를 생성해야 하는 코드의 다른 부분에서 사용됩니다.

이러한 기능을 다음과 같이 부르는 또 다른 이유는 다음과 같습니다. 인라인 함수. 익명 함수를 사용하는 것은 컬렉션에 대해 빠른 작업을 수행하기 위해 컬렉션 라이브러리에서 광범위하게 사용되는 일반적인 패턴입니다.

예를 들어, 인라인 함수/익명 함수를 사용하여 익명 함수에서 정의한 기준을 충족하는 요소만으로 다른 컬렉션을 만드는 필터 메서드가 있습니다.

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)

여기서 우리가 익명 함수로 사용하는 메서드는 목록에서 얻은 값이 홀수인지 짝수인지 확인하고 항목을 반환하는 메서드입니다.

//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에서는 익명 함수의 매개변수 이름이 지정되지 않은 곳에 와일드카드를 사용할 수도 있습니다. 예를 들어

var timesTwo = (_:Int)*2

timesTwo(5)
//10

이 시나리오에서는 전달하는 매개변수의 이름을 지정하지 않습니다. 밑줄을 사용하여 이를 나타내는 유일한 방법입니다.

게으른 평가

대부분의 언어는 변수와 함수 매개변수를 차례로 평가합니다. 스칼라에는 참조될 때까지 평가하고 싶지 않은 값을 처리하는 데 도움이 되는 게으른 키워드가 있습니다.

'게으른'으로 표시된 변수는 정의된 위치에서는 평가되지 않습니다. 이를 흔히 '즉각적 평가'라고 하며, 코드에서 나중에 참조될 때만 평가됩니다.

이는 값을 평가하는 데 비용이 많이 드는 계산이 필요할 때 도움이 될 수 있습니다. 값이 항상 필요한 경우가 아니라면 변수를 게으르게 만들어 소프트웨어 속도를 저하시킬 수 있는 값비싼 계산을 실행하지 않아도 됩니다.

lazy val myExpensiveValue = expensiveComputation

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

이것이 게으른 변수의 유일한 사용 사례는 아닙니다. 또한 코드의 순환 종속성 문제를 처리하는 데 도움이 됩니다.

설정이 false인 경우 myExpensiveValue를 사용할 필요가 없습니다. 그러면 값비싼 계산을 수행하지 않아도 되므로 사용자가 애플리케이션을 사용하여 즐거운 시간을 보낼 수 있습니다. 다른 요구 사항도 부담 없이 적절하게 계산할 수 있기 때문입니다. RAM.

게으름은 함수 인수에도 도움이 됩니다. 여기서 인수는 함수 내에서 참조될 때만 사용됩니다. 이 개념을 Call-by-name 매개변수라고 합니다.

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

많은 언어가 인수를 평가하는 데 call-by-value 방식을 사용합니다. call-by-name을 통해 전달된 매개변수는 함수 본문에서 필요할 때만 평가되고 그 전에는 평가되지 않습니다. 값이 평가되면 저장되고 나중에 다시 평가할 필요 없이 재사용할 수 있습니다. 메모이제이션이라고 알려진 개념입니다.

유형 추론

Scala에서는 생성하는 모든 변수에 대해 유형을 선언할 필요가 없습니다. 이는 Scala 컴파일러가 오른쪽 평가를 기반으로 유형에 대한 유형 추론을 수행할 수 있기 때문입니다. 이를 통해 코드를 더욱 간결하게 만들 수 있습니다. 예상되는 유형이 분명한 상용구를 작성할 필요가 없습니다.

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

고차 함수

고차 함수는 함수를 인수로 취하고 함수를 반환 유형으로 반환할 수 있는 함수입니다. 스칼라에서 함수는 일급 시민으로 간주됩니다. 이러한 기능을 이런 방식으로 사용하면 우리가 만들 수 있는 프로그램 종류에 있어 매우 유연해질 수 있습니다. 함수를 동적으로 생성하고 다른 함수에 동적으로 기능을 제공할 수 있습니다.

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

위 함수에서는 int와 int를 취하고 int를 반환하는 함수를 전달합니다. 해당 서명의 모든 기능을 전달할 수 있습니다. 서명이란 함수의 입력과 출력을 의미합니다. Int=>Int 시그니처는 함수가 Int를 입력으로 사용하고 Int를 출력으로 반환한다는 의미입니다.

()=>Int의 서명은 함수가 입력으로 아무것도 사용하지 않고 출력으로 Int를 반환한다는 것을 의미합니다. 이와 같은 함수의 예로는 임의의 int를 생성하는 함수가 있습니다.

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

위 함수에는 ()=>Int라는 서명이 있습니다.

우리는 scala ()=>Unit 시그니처를 갖는 함수를 가질 수 있습니다. 이는 함수가 아무것도 받아들이지 않고 유형을 반환하지 않는다는 것을 의미합니다. 함수는 미리 결정된 작업을 수행하도록 무언가를 변경하여 일종의 계산을 수행할 수 있습니다.

하지만 이런 종류의 방법은 권장되지 않습니다. 알 수 없는 방식으로 시스템에 영향을 미칠 수 있는 블랙박스처럼 보이기 때문입니다. 또한 테스트할 수 없습니다. 명시적인 입력 및 출력 유형을 사용하면 함수가 무엇을 하는지 추론할 수 있습니다.

고차 함수는 함수를 반환할 수도 있습니다.

예를 들어, 거듭제곱 함수를 생성하는 메서드를 만들 수 있습니다. 즉, 숫자를 가져와서 여기에 거듭제곱을 적용하는 것입니다.

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

위 함수는 int를 취합니다. 우리의 반환 유형은 Int x를 취하는 익명 함수입니다. * 우리는 int x를 power 함수의 인수로 사용합니다.

카레링

스칼라에서는 두 개의 인수를 취하는 함수를 한 번에 하나의 인수를 취하는 함수로 변환할 수 있습니다. 하나의 인수를 전달하면 이를 부분적으로 적용하고 함수를 완성하기 위해 하나의 인수를 사용하는 함수로 끝납니다. Currying을 사용하면 일부 인수를 부분적으로 추가하여 함수를 만들 수 있습니다.

이는 완전한 인수 세트를 갖기 전에 동적으로 함수를 생성하는 데 유용할 수 있습니다.

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

특정 숫자를 곱하는 함수를 만들어야 하는 경우 다른 곱셈 방법을 만들 필요가 없습니다.

위 함수에서 .curred를 호출하면 먼저 하나의 인수를 취하고 부분적으로 적용된 함수를 반환하는 함수를 얻을 수 있습니다.

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

패턴 매칭

Scala에는 스위치 문에서와 마찬가지로 변수가 특정 기준에 일치하는지 확인하는 데 도움이 되는 강력한 내장 메커니즘이 있습니다. Java 또는 일련의 if/else 문에서. 언어에는 변수가 특정 유형인지 확인하는 데 사용할 수 있는 패턴 일치 기능이 있습니다. Scala의 패턴 일치는 강력하며 일치하는 변수에서 직접 관심 있는 필드를 가져오기 위해 unapply 메서드가 있는 구성 요소를 분해하는 데 사용할 수 있습니다.

스칼라의 패턴 매칭은 스위치 문에 비해 더 편리한 구문을 제공합니다.

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

변수를 옵션 집합과 비교하고 일치하는 변수가 기준을 충족하면 굵은 화살표(=>) 오른쪽에 있는 식이 평가되어 일치 결과로 반환됩니다.

우리는 코드에서 일치하지 않는 사례를 찾기 위해 밑줄을 사용합니다. 이는 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
}

위의 코드에서는 myItem 변수의 유형을 확인하고 이를 기반으로 특정 코드로 분기할 수 있습니다.

패턴 일치는 변수가 일치하는지 확인합니다.

밑줄은 위의 사례 문의 다른 항목과 일치하지 않는 다른 조건과 일치하는 자리 표시자로 작동합니다. myItem 변수를 사용하여 match 메서드를 호출합니다.

굵은 화살표 "=>"의 오른쪽에서 몇 가지 논리를 사용하고 myItem이 true인지 확인합니다.
밑줄을 사용하여 코드에서 정의한 Case 문과 일치하지 않는 항목을 일치시킵니다.

Case 클래스를 사용하면 더 나아가 클래스 구조를 분해하여 객체 내부에 필드를 가져올 수도 있습니다.

봉인된 키워드를 사용하여 클래스를 정의함으로써 우리는 컴파일러가 우리가 일치시키려는 사례를 철저하게 확인하고 특정 사례를 처리하는 것을 잊었을 경우 경고하도록 하는 이점을 얻습니다.

불변성

val 키워드를 사용하면 Scala의 다른 함수로 변경할 수 없는 값을 생성할 수 있습니다. 이는 다음에서 달성됩니다. Java final 키워드를 사용하여. Scala에서는 변수를 생성할 때 가변 변수를 생성하는 데 사용하는 대안인 var를 사용하는 대신 val 키워드를 사용하여 이를 수행합니다.

val 키워드를 사용하여 정의된 변수는 읽기 전용인 반면, var로 정의된 변수는 다른 함수를 사용하거나 코드에서 사용자가 임의로 읽고 변경할 수 있습니다.

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

값을 val로 선언한 후 myNumber에 값을 할당하려고 하면 컴파일 타임 오류 또는 "val에 재할당"이 발생합니다.

불변성을 사용하는 이유는 무엇입니까?

불변성은 코드와 다른 프로그래머가 값을 예기치 않게 변경하는 것을 방지하는 데 도움이 됩니다. 이로 인해 우리가 저장한 값을 사용하려는 경우 대신 복사본을 만들 수 있으므로 예상치 못한 결과가 발생할 수 있습니다. 이렇게 하면 여러 액터가 동일한 변수를 변경하여 발생할 수 있는 버그가 방지됩니다.

클래스와 객체

우리 모두는 객체가 실제 개체이고 클래스는 객체를 정의하는 템플릿이라는 것을 알고 있습니다. 클래스에는 상태와 동작이 모두 있습니다. 상태는 값이거나 변수입니다. 동작은 Scala의 메서드입니다.

Scala를 사용하여 클래스를 정의하고 인스턴스화하고 사용하는 방법을 살펴보겠습니다.

여기에는 두 개의 변수와 두 개의 함수가 있는 Rectangle이라는 클래스가 있습니다. 매개변수 l 및 b를 프로그램의 필드로 직접 사용할 수도 있습니다. 기본 메소드가 있고 두 개의 값으로 클래스를 인스턴스화한 객체가 있습니다.

예:

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

Scala에서는 모든 필드와 메서드가 기본적으로 공개됩니다. Scala에서는 Object에 대해 toString 메소드가 정의되어 있으므로 override를 사용하는 것이 필수적입니다.

계승

Scala에는 단일, 다중 레벨, 다중, 계층적, 하이브리드와 같은 여러 유형의 상속이 있으며 이는 다음에서 발견되는 기존 형식과 많은 공통점을 갖습니다. Java. 클래스와 특성 모두에서 상속받을 수 있습니다. "extends" 키워드를 사용하여 한 클래스의 멤버를 다른 클래스로 상속할 수 있습니다. 이를 통해 재사용이 가능해집니다.

하나의 클래스 또는 여러 클래스에서 상속받을 수 있습니다. 자체적으로 슈퍼클래스를 갖고 있는 서브클래스로부터 상속받아 프로세스에서 상속 계층 구조를 만드는 것도 가능합니다.

아래 Scala 예제에서 Base 클래스는 Circle이고 파생 클래스는 Sphere입니다. 원에는 Sphere 클래스에 상속된 반경이라는 값이 있습니다. calcArea 메서드는 override 키워드를 사용하여 재정의됩니다.

예:

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

추출

스칼라에서는 추상 클래스와 특성을 사용하여 추상 메서드와 멤버 필드를 만들 수 있습니다. 추상 클래스와 특성 내에서 추상 필드를 반드시 구현하지 않고도 정의할 수 있습니다.

예:

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

이러한 필드는 특성 또는 추상 클래스를 확장하는 클래스에 의해 구현됩니다. 특성을 사용하여 애플리케이션이 무엇을 할 수 있어야 하는지에 대한 계약을 생성한 다음 나중에 해당 메서드를 구현할 수 있습니다.

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

이렇게 하면 다양한 메서드가 어떻게 생겼는지 구상하는 데 도움이 될 수 있는 메서드를 구현하지 않고도 애플리케이션이 어떻게 보일지 계획할 수 있습니다. 이는 실제 구현이 아닌 추상화 프로그래밍으로 알려진 패턴을 따릅니다.

abstract 키워드가 앞에 붙은 클래스에는 추상 메소드와 비추상 메소드가 모두 포함될 수 있습니다. 그러나 추상 클래스에서는 다중 상속이 지원되지 않습니다. 따라서 최대 하나의 추상 클래스를 확장할 수 있습니다.

싱글톤 객체

싱글톤은 프로그램에서 한 번만 인스턴스화되는 클래스입니다. 이는 "싱글톤 패턴"으로 알려진 널리 사용되고 유용한 프로그래밍 패턴에서 유래되었습니다. 이는 오래 지속될 인스턴스를 생성하는 데 유용하며 시스템 이벤트를 조정하는 데 필수적인 상태인 프로그램 전체에서 일반적으로 액세스됩니다. Scala에서 object 키워드를 사용하여 싱글톤을 생성하는 간단한 방법을 제공하므로 Scala에서 이러한 클래스를 생성하는 것은 쉽습니다.

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

그런 다음 프로그램의 모든 부분에서 인스턴스가 하나만 있으므로 동일한 데이터를 볼 수 있다는 보장을 받아 프로그램 전체에서 이 개체를 참조할 수 있습니다.

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

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

스칼라에는 정적 멤버라는 개념이 없습니다. 이것이 바로 클래스의 정적 멤버처럼 작동하는 싱글톤 객체를 사용해야 하는 이유입니다.

암시적 클래스

암묵적 클래스는 버전 2.1 이후에 추가된 새로운 기능입니다. 주로 폐쇄된 클래스에 새로운 기능을 추가하는 것입니다.

암시적 키워드는 클래스, 개체 또는 특성에 정의되어야 합니다. 암시적 클래스의 기본 생성자는 첫 번째 매개변수 목록에 정확히 하나의 인수를 가져야 합니다. 또한 추가적인 암시적 매개변수 목록이 포함될 수도 있습니다.

아래 Scala 예제에서는 문자열의 모음을 *로 바꾸는 새로운 기능이 추가되었습니다.

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

사용 중인 클래스로 가져와야 합니다.

import StringUtil.StringEnhancer

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

객체지향 프로그래밍(OOP)과 함수형 프로그래밍(FP)

OOP에서 프로그램은 데이터와 그 데이터에서 작동하는 함수를 매우 연결된 단위로 그룹화하여 구성됩니다. 객체는 데이터를 처리하는 필드와 메서드에 데이터를 전달합니다. 이 프로그래밍 스타일에서 주요 추상화는 데이터이며, 생성된 메서드는 데이터에서 작동하도록 되어 있습니다.

기능적 프로그래밍반면에, 데이터와 데이터에서 작동하는 함수를 분리합니다. 이를 통해 개발자는 프로그램을 모델링할 때 함수를 추상화 및 구동력으로 취급할 수 있습니다.

스칼라는 함수를 일급 시민으로 두고 함수형 프로그래밍을 가능하게 하며, 이를 다른 함수에 값으로 전달하고 값으로 반환할 수 있습니다. 이 두 패러다임의 조합은 스칼라를 데이터 과학과 같은 다양한 산업에서 복잡한 소프트웨어를 구축하는 데 좋은 선택으로 만들었습니다.

Scala의 중요한 프레임워크

다음은 Scala의 몇 가지 중요한 프레임워크입니다.

연극 다음을 사용하는 오픈 소스 웹 애플리케이션 프레임워크입니다. MVC 아키텍처. 2007년에 출시되어 현재 Apache 라이센스가 부여된 이 프레임워크는 2013년 GitHub에서 가장 인기 있는 프레임워크가 되었습니다. LinkedIn, Walmart, Samsung, Eero와 같은 회사가 이 프레임워크를 사용합니다.
승강기 2007년에 출시된 Scala로 작성된 또 다른 무료 웹 프레임워크입니다. Foursquare는 Lift 프레임워크를 사용합니다. 고성능이며 프레임워크 구축 속도가 더 빠릅니다.
아카
고양이
Spark

동시성 지원

Scala의 값은 기본적으로 변경할 수 없습니다. 이로 인해 동시 환경에 매우 적응할 수 있습니다.
Scala에는 동시 애플리케이션에 가장 적합한 많은 기능이 있습니다.
Future와 Promises를 사용하면 비동기적으로 데이터를 더 쉽게 처리할 수 있어 병렬 처리가 지원됩니다.
Akka - Actor 동시성 모델을 사용하는 툴킷입니다. 메시지를 받으면 행동하는 액터가 많이 있습니다.
스레드를 사용한 동시성 Java Scala에서도 지원될 수 있습니다.
스트림 처리는 데이터의 지속적인 실시간 처리를 가능하게 하는 또 다른 뛰어난 기능입니다.

Scala에는 최고의 동시성 라이브러리가 있습니다. Java 생태계.

출신 Java 스레드
Vertex와 같은 라이브러리의 Fiber
ZIO – 동시성 및 비동기 계산을 처리하는 데 도움이 되는 기본 요소를 갖춘 라이브러리
STM – 거래
미래 – Scala 언어에 내장

Java 대 스칼라

여기에 주요 차이점 Java 그리고 스칼라.

스칼라	Java
더 컴팩트하고 간결해졌습니다.	비교적 큰 코드 덩어리
객체지향과 기능지향 언어로 설계 및 개발되었습니다. 동시성, 불변성과 같은 다양한 기능적 프로그래밍 기능을 지원합니다.	원래 객체 지향 언어로 개발되었고 최근에 함수형 프로그래밍 기능을 지원하기 시작했습니다. 여전히 함수형 프로그래밍 언어로는 강력하지 않습니다.
현대적인 동시성을 지원하기 위해 액터 모델을 사용합니다.	동시성을 위해 기존 스레드 기반 모델을 사용합니다.
프레임워크 지원 – Play, Lift	Spring, Grails 등을 지원합니다.
지연 평가 지원	게으른 평가를 지원하지 않습니다.
정적 멤버 없음	정적 멤버가 포함되어 있습니다.
연산자 오버로딩 지원	연산자 오버로딩을 지원하지 않습니다
소스코드 컴파일 속도가 비교적 느림	소스 코드 컴파일이 Scala보다 빠릅니다.
특성 – 다음과 같이 행동한다 Java 8 개의 인터페이스	Java 8개의 인터페이스는 클래스와 인터페이스 사이의 격차를 해소하려고 노력합니다.
재작성이 필요하다	재작성은 필요하지 않습니다
버그 없는 코드에 대한 보장은 없습니다.	결함 감소에 대한 완벽한 보장
이전 버전과의 호환성을 지원합니다.	Scala는 이전 버전과의 호환성을 지원하지 않습니다.
Opera토르는 다르게 취급됩니다 Java 메소드 호출이 아닙니다.	모든 항목의 연산자는 Scala에서 호출되는 메서드를 통해 수행됩니다.
클래스를 사용하여 다중 상속을 지원하지만 추상 클래스를 사용하지는 않습니다.	클래스를 사용하는 다중 상속을 지원하지 않지만 인터페이스를 사용하여 다중 상속을 지원합니다.
코드는 간결한 형태로 작성되었습니다.	코드는 긴 형식으로 작성됩니다.
스칼라에는 static 키워드가 없습니다.	Java static 키워드가 포함되어 있습니다.

요약

이 튜토리얼에서는 Scala를 시작하는 방법을 배웠습니다. 또한 기능적 및 객체 지향 기능도 배웠습니다. 당신은 또한 사이의 유사점과 차이점을 발견했습니다 Java 그리고 스칼라. 이 튜토리얼은 잘 설명된 다양한 예제를 통해 여러분에게 도움이 되었을 것입니다.

당신은 좋아할 것입니다 :