<jupyter_start><jupyter_text>1. OBJECT- 스칼라의 모든 것이 object!- 숫자도 object, 문자도 object  Web playgrounds- [scalafiddle.io](scalafiddle.io)- [scastie](scastie)<jupyter_code>1+1
1.0/2
"a"+"b"
"a"+("b")
1 + 1
:type 1
1.0 / 2
:type 1.0
"a" + "b"
:t "a"
"ab" * 3
"a".+("b")
"ab".*(3)
"ab" + 'c'
'ab' + "c"
BigInt("12345679") * 9


val a = 1
var b = 2
b = 3
a = 4
val c = 1 + 2; c + 3


def size = 2
5 * size
def square(x: Int) = x * x
square(2)
square(square(2))
def sumOfSquare(x: Int, y: Int) = square(x) + square(y)
def abs(x: Int) = if (x >=0) x else -x
"ab"+3
"a".*(3)
"a"*3
"ab" + 'c'
'a' + "bc"
val a = 1
a = 2
var b = 2
b = 3<jupyter_output><empty_output><jupyter_text>Scala의 특징- 간결한 표현- 강력한 타입체크- 준수한 성능- 방대한 라이브러리 : 자바 라이브러리 사용 가능 Spark- Spark native- Compile-time type checked scala> 1+1- 1+1 : expresion- \, 2 : type, 결과      Object와 상호작용하기<jupyter_code>"hello".toUpperCase
// argument가 없는 경우
// argument가 있는 경우
// sequence하면 모두 take가 가능
"heelo".take(3)
"hello".take(2)
// Infix operator
1+1

// 위와 같은 표현
1.+(1)
"hello" take 2<jupyter_output><empty_output><jupyter_text>Literal Objects Numbers<jupyter_code>1
// 32 bit
1.0
// 64 bit
1.0f
1L<jupyter_output><empty_output><jupyter_text>불리언<jupyter_code>true
false<jupyter_output><empty_output><jupyter_text>char<jupyter_code>'a'<jupyter_output><empty_output><jupyter_text>string<jupyter_code>"hello world"
"""hello
|
|!!!"""
""" "hi" """<jupyter_output><empty_output><jupyter_text>null<jupyter_code>null
// 스칼라에선 null을 안쓰는 방식으로 코딩하는 것을 추천<jupyter_output><empty_output><jupyter_text>UNIT- return하는 것이 없는 것<jupyter_code>()
println("hello world")
:type println("hello-world")

// Unit이라고 떠야하는데 왜 오류지 : repl에선 됨<jupyter_output><empty_output><jupyter_text>object 정의하기 빈 jobect<jupyter_code>object Test
Test
object Test {}
Test<jupyter_output><empty_output><jupyter_text>method가 있는 object<jupyter_code>object Test2 {
    def name: String="홍길동"
    def name1: String="바보"
}
Test2.name
Test2.name1<jupyter_output><empty_output><jupyter_text>repl에서 여러줄을 사용하려면 :paste라고 쓰고 해야함!  파라미터 받는 method<jupyter_code>object Test3 {
    def hello(to: String): String="Hello " + to
}
Test3.hello("Alice")
Test3 hello "hi"<jupyter_output><empty_output><jupyter_text>Default parameter Values<jupyter_code>object Test4 {
    def hello(firstName: String, lastName: String="!"): String=
    "Hello " + firstName + " " +lastName
    
}
// lastName이 없으면 "!"
Test4.hello("tony")
Test4.hello("tony", "stark")<jupyter_output><empty_output><jupyter_text>keyword parameters<jupyter_code>Test4.hello(lastName="hi", firstName="kkkk")<jupyter_output><empty_output><jupyter_text>Apply Method- 이름을 말 안하고 바로할 수 있음- 예약된 것을 수행- 자주 쓰고, 많이 쓰는 것을 이렇게 만듬- 함수처럼 작동해서 object를 사용해 함수를 만듬- 실제 스칼라 function도 이렇게 되어 있음<jupyter_code>object inc {
    def apply(n: Int): Int = n+1
}
// 인자는 항상 타입을 적어줘야 함
// return 타입을 항상 작성해주는 것을 권장
inc.apply(1)
inc(1)
def add(n: Int): Int ={
    println("adding!")
    n+1
}
// 마지막꺼만 타입 리턴
add(10)
def add(n: Int): Int ={println(s"adding $n"); n+1}
// s를 써야 %n에 타입을 넘길 수 있음
add(10)<jupyter_output>adding 10<jupyter_text>Fields<jupyter_code>object Test5 {
    val name: String = "Alice"
    def hello(other: String): String = name + " says hi to " + other
}
Test5.name
Test5.hello("Bob")<jupyter_output><empty_output><jupyter_text>Methods vs Fields- 큰 차이는 없고, 이름이 겹치면 안됨<jupyter_code>object Test6 {
    val simpleField = {
        println("evaluating simpleField")
        42
    }
    lazy val lazyField = {
        println("Evaluating lazy")
        42
    }
    def noParameterMethod = {
        println("evaluating")
        42
    }
}
// 생성 당시엔 아무것도 실행이 안되고
// object가 호출되면 필드값들이 실행
Test6
// val은 처음 실행될 떄 한번
// lazy가 실행될 때 시작
// def는 계속
// 사이드 이펙트
Test6.lazyField
Test6.simpleField
Test6.simpleField
// println이 안됨! 처음만 실행
Test6.noParameterMethod
Test6.noParameterMethod
// lazy는 드물게 호출되는 케이스에 사용
object foo {
  def a = {
    println("a")
    1
  }
  val b = {
    println("b")
    a + 2
  }
  def c = {
    println("c")
    a
    b + "c"
  }
}
foo.c + foo.b + foo.a
// foo가 불리는 순간 b, a+2니까 a가 찍히고 c가 찍히고 a가 찍히고 b는 value라 안나오고<jupyter_output><empty_output><jupyter_text>Hello World<jupyter_code>// vi HelloWorld.scala file
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, world!")
  }
}
// main method를 실행!
// 리턴이 없는 Unit
> scala HelloWorld
> scalac HelloWorld.scala
// scalac는 컴파일 -> .class라는 파일 생성되며 $가 붙은 것은 추후 설명해드림<jupyter_output><empty_output><jupyter_text>더 간단하게!!<jupyter_code>object HelloWorld extends App {
  println("Hello, world!")
}
// extends App이라고 달아주면 main 함수 안을 바로 작성할 수 있음<jupyter_output><empty_output><jupyter_text>BLOCKS- 중괄호로 감싸면 한 덩어리처럼 실행<jupyter_code>{1; 2; 3}<jupyter_output><empty_output><jupyter_text>- repl에선 오류가 나는데, console:12: warning: a pure expression does nothing in statement position; multiline expressions might require enclosing parentheses- 1,2는 하는게 없다- 사이드 이펙트시 사용<jupyter_code>{
  println("This is a side-effect")
  println("This is a side-effect as well")
  3
}<jupyter_output>This is a side-effect
This is a side-effect as well<jupyter_text>계산중간값에 이름 붙이기<jupyter_code>def name: String = {
  val title = "Doctor"
  val name = "Strange"
  title + " " + name
}

name<jupyter_output><empty_output><jupyter_text>조건<jupyter_code>if (1 < 2) "Yes" else "No"
// res: String = Yes
:type if (1 < 2) "Yes" else "No"
// String
if(1 < 2) println("Yes") else println("No")
// Yes
:type if(1 < 2) println("Yes") else println("No")
// Unit<jupyter_output><empty_output><jupyter_text>Writing Methods- 메소드 입출력 타입 파악 및 메소드 타입 선언부 작성    - def add(n: Int): Int = ??? 이런식으로 해도 됨- 테스트 케이스 준비- 코드 실행- 메소드 구현- 코드 재실행  숙제- Double 하나를 입력받아 그 제곱을 출력하는 square method를 가진 calc object를 작성해보세요.- Double 하나를 입력받아 그 세제곱을 출력하는 cubic method를 calc object 안에 작성해보세요. 구현할 때 square를 이용해보세요.- 위의 두 method를 Double 뿐만 아니라 Int 값도 입력받을 수 있도록 해 보세요<jupyter_code>object calc {
    def square(x: Double): Double = x*x
    def square(x: Int): Int = x*x
    def cubic(x: Double): Double = square(x)*x
    def cubic(x: Int): Int = square(x)*x
}

// 함수 이름이 같아도 타입이 다르면 다른거가 됨!! 충격적임ㅋㅋㅋㅋㅋㅋㅋㅋㅋ
calc.square(2)
calc.cubic(3)
calc.cubic(2.0)
println(calc.square(2.0) == 4.0)<jupyter_output>true
{'fraction_non_alphanumeric': 0.14199739752765128, 'fraction_numerical': 0.02147039687703318, 'mean_word_length': 4.149916247906198, 'pattern_counts': {'":': 0, '<': 94, '<?xml version=': 0, '>': 95, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '171671', 'license': 'MIT', 'n_tokens_mistral': 3207, 'n_tokens_neox': 3529, 'n_words': 671, 'path': 'scala/01.object.ipynb', 'repo_name': 'zzsza/TIL', 'size': '6148'}