Programming

1 - Java

1.1 - Creating and Destroying Objects

1.1.1 - Item1: 생성자 대신 정적 팩터리 메서드를 고려하라

해당 설명에서 정적 팩터리 메서드는 디자인 패턴에서의 팩터리 메서드 패턴을 의미하는 것이 아님!!! 주의!!

‘생성자 대신 정적 팩터리 메서드를 고려하라’ 예를 들어 아래와 같은 경우이다

• NG : BigInteger(int, int, Random) → 다양한 매개 변수에 따라 반환 객체에 대한 특성을 이해하기 어려움
• OK : BigInteger.probablePrime → 반환 객체 특성을 이해하기 쉬움

핵심 정리

정적 팩터리 메서드와 public 생성자는 각각의 쓰임새가 있으니 상대적인 장단점을 이해하고 사용하는 것이 좋음. 그래도 정적 팩터리를 사용하는 게 유리한 경우가 더 많으므로 무작정 public 생성자를 제공하는 습관이 있다면 고치자!!

장점

1. 이해하기 쉬운 이름을 짓는게 가능.

• 생성자의 이름은 한개(클래스 명) 한정되어 있음.

• 생성자를 구별하는 것은 매개변수 차이 뿐. 결국 사용자는 생성자의 차이를 이해하기 어려움.

  → 정적 팩터리의 경우 이름만 잘 지으면 반환될 객체의 특성을 쉬이 표현 할 수 있다.

2.새로운 오브젝트를 생성할 필요가 없음. 동일한 오브젝트를 사용.

• 이러한 특성으로 불변 클래스(immutable class)는 인스턴스를 미리 만들어 놓거나 새로 생성한 인스턴스를 캐싱해 재활용하는 식으로 불필요한 객체 생성을 피할 수 있음.

  → 생성 비용이 큰 객체가 자주 요청되는 상황에 적용할 경우 성능을 상당히 끌여올려 줄 수 있는 방법!!(Flyweight pattern과 유사한 방법)

• 반복되는 요청에 같은 객체를 반환하는 경우 정적 팩터리 방식의 클래스는 언제 어느 인스턴스를 살아 있게 할지 통제 할 수 있음

  → 인스턴스 통제(instance-cotrolled) 클래스라 함. 인스턴스를 통제를 하면 클래스를 싱글턴으로 만들 수도 있고, 인스턴스화 불가로 만들 수 있으며, 불변 값 클래스에서 동일한 인스턴스가 단 하나뿐임을 보장할 수 있음.

3. 반환 타입의 하위 타입 객체를 반환할 수 있다.

예를 들어, java.util.Collection에는 emptyList()라는 정적 팩터리 메서드가 있음. 다음과 같은 특징을 가짐.

• emptyList()는 내부 클래스 EmptyList의 인스턴스를 반환 함. 내부 클래스 EmptyList는, public이 아니기 때문에 외부로 부터 감춰짐.
• emptyList()의 반환 타입은 List 인터페이스임.

그래서 Collection의 API는 매우 간결함. 프로그래머는 명시한 인터페이스대로 동작하는 객체를 얻을 것임을 알기에 굳이 알아보지 않아도 됨. 그저 인터페이스의 사용 방법만 알아두면 됨.

4. 입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다.

반환 타입의 하위 타입이기만 하면 어떤 클래스의 객체를 반환하든 상관없음.

5. 정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.(→ 반환 서브타입은 런타임에 정해져도 OK!)

예를 들어, JDBC의 DriverManager.getConnection()의 경우 해당. 결과적으로 API로서의 유연성이 향상 됨.

단점

1. 상속하려면 public이나 protected 생성자가 필요하니 정적 팩터리 메서드만 제공하면 하위 클래스를 만들 수 없다.

→ Collection 프레임워크의 유틸리티 구현 클래스들을 상속할 수 없음. 예를 들어, java.util.Collections의 emtpyList()는 EmptyList를 반환되는데 private이기 때문에 EmptyList의 서브 클래스를 만들 수 없음.

2. 정적 팩터리 메서드는 프로그래머가 찾기 어렵다.

→ 생성자처럼 API 설명에 명확히 드러나지 않아 정적 팩터리 메서드 방식 클래스를 인스턴스화할 방법을 알아내야 함. 아래와 같은 정적 팩터리 메서드에 사용하는 명명 방식을 이용하여 해당 문제를 완화해줘야 함.

1.1.2 - Item2: 생성자에 매개변수가 많다면 빌더를 고려하라

핵심 정리

생성자나 정적 팩터리가 처리해야 할 매개변수가 많다면 빌더 패턴을 선택하는게 더 낫다. 매개변수 중 다수가 필수가 아니거나 같은 타입이면 특히 더 그렇다. 빌더는 점층적 생성자보다 클라이언트 코드를 읽고 쓰기가 훨씬 간결하고, 자바빈즈보다 훨씬 안전하다.

No Good : Telescoping constructor pattern

public class NutritionFacts {
    // 멤버 변수 정의 생략...

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0);
    }

    // 위와 같은 흐름으로 끊임없이 생성자 정의
}

• 사용자에게 설정하길 원치 않는 매개 변수까지 강제로 값을 지정해야 함.
• 매개 변수 조합에 따라 생성자 수가 많이 늘어 날 수 있음
• 매개 변수가 늘어남에 따라 코드 작성 및 가독성이 저하 됨.
• 타입만 맞으면 컴파일 에러가 발생하지 않기 때문에 같은 타입의 매개변수를 잘못된 순서로 지정할 경우 실수를 눈치 챌 수 없음.
  • 올바른 매개 변수를 입력하고 있는지 계속 체크해야 하는 불편함.

대안1 : JavaBean Pattern

매개 변수가 없는 생성자로 객체를 생성 후, setter 메서드를 호출해 원하는 매개변수의 값을 설정하는 방식!!

No Good : JavaBeans Pattern

public class NutritionFacts {
    // 멤버 변수 정의 생략

    public NutritionFats() {}

    public void setServingSize(int val) { // 생략 }
    public void setServings(int val) { // 생략 }
    public void setCalories(int val) { // 생략 }
    // 멤버 변수의 setter 함수 정의 계속...
}

JavaBeans Pattern 단점

• 객체 하나를 만들려면 메서드를 여러 개 호출해야 함.
• 객체 생성 후, 매개 변수 간 불 일치가 발생할 수 있음. → 객체 생성하기 전에 불일치를 감지해야 함.
• 객체가 완전히 생성되기 전까지 일관성(consistency)이 무너진 상태에 놓이게 됨.
  • setter에서 내부 상태를 변경 할 수 있음. 또한 클래스를 불변(immutable)으로 만들 수 없음. → 스레드 안전성을 얻기 위해 추가 작업 필요.
  • 생성이 끝난 객체를 직접 ‘freezing’ 작업 후 사용하는 방법이 있으나 실무에서는 거의 쓰이지 않음. 또한, freezing 메서드 호출해줬는지 컴파일러가 보증 할 수 없음. → 런타임 오류에 취약

대안2: Builder Pattern

점층적 생성자 패턴의 안정성과 자바빈즈 패턴의 가독성을 겸비한 패턴으로 클라이언트는 필요한 객체를 직접 만드는 대신, 필수 매개변수만으로 생성자(혹은 정적 팩터리)를 호출해 빌더 객체를 얻어 빌더 객체가 제공하는 세터 메서드들로 원하는 선택 매개변수들을 설정하는 패턴

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // 필수 매개변수
        private final int servingSize;
        private final int servings;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) { 
            this.calories = val; return this;
        }
        public Builder fat(int val) { 
            this.fat= val; return this;
        }
        public Builder sodium(int val) { 
            this.sodium= val; return this;
        }
        public Builder carbohydrate(int val) { 
            this.carbohydrate = val; return this;
        }
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        this.servingSize  = builder.servingSize;
        this.servings     = builder.servings;
        this.calories     = builder.calories;
        this.fat          = builder.fat;
        this.sodium       = builder.sodium;
        this.carbohydrate = builder.carbohydrate;
    } 
}

NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
    calories(100).sodium(35).carbohydrate(27).build();

장점

• 구현하기 쉬움
• 읽기 쉬움
• builder()로 객체 생성하기 전에 매개변수 간 불일치 감지 가능
• 클래스가 계증 구조로 되어 있어도 적용 가능
• API가 유연해짐. 예를 들어 하나의 builder 하나로 여러 객체를 순회하면서 만들수 있고, 빌더에 넘기는 매개 변수에 따라 다른 객체를 만들 수도 있음.

단점

• 객체를 만들려면 빌더부터 만들어야 함. → 빌더 생성 비용이 크지는 않지만 성능에 민감한 상황에서는 문제가 될 수 있음.
• 점층적 생성자 패턴보다는 코드가 길기 때문에 매개변수가 4개 이상은 되어야 값어치를 한다.
• but!! API는 시간이 지날수록 매개변수가 많아지는 경향이 있기 때문에 애초에 빌도로 시작하는 편이 나음.

2 - Scala

2.1 - The Absolute Scala Basics

1. Values, Variables and Types

Scala에는 두 종류의 변수 val과 var이 있음. val의 자바의 final 변수와 비슷하다. 일단 초기화하고 나면 val 변수에 대해 값을 다시 할당 할 수 없다. 반면 var은 자바의 final이 아닌 일반 변수와 비슷하다. var 변수는 없어질 때까지 계속 값을 재할당 할 수 있다.

val x: Int = 2 // immutable -> can't be reassigned
// x = 2 (x)

var y: Int = 1 // mutable   -> can be reassigned
y = 1
y += 1

Scala에서는 var 변수보단 val 변수를 선호한다. 그 이유는 함수형 프로그래밍에서 side effect를 최소화 하기 위해서 임.

Takeaway

• vars 보단 vals 선호
• 모든 val과 var은 타입을 가짐
• 타입을 생략 할 경우 컴파일러가 자동으로 타입 추론

2. Expressions

Basic Expressions: operators

val x = 3 + 5 // EXPRESSION
val xIsEven = x % 2 == 0
val xIs Odd = !xIsEven

If Expression

val cond: Boolean = ...
val i = if (cond) 42 else 0

스칼라에서 코드 블럭은 expression 이다.

val x = {
    val cond: Boolean = ...
    if (cond) 42 else 0
}

• 블록의 값은 마지막 expression의 값이다.

Expressions vs. instructions

• instructions are executed(think Java)
• expressions are evaluated(Scala)

3. Functions

scala에서는 함수를 다음과 같이 정의한다

def max(x: Int, y: Int): Int = {
    if (x > y)
        x
    else
        y
}

함수 정의는 ‘def’로 시작한다. 그 다음으로 함수 이름이 오고, 그 뒤에 괄호 안에 콤마(,)로 구분한 파라메터 목록이 온다. 컴파일러가 파라미터 타입을 추론하지 않기 때문에 모든 파라미터에는 타입 지정을 반드시 덧붙여야 한다. 다음으로 파라미터 목록을 닫는 괄호 뒤에는 리턴 타입을 정의한다. 그 뒤로 중괄호 안에는 함수의 본문이 들어간다.

위 max() 경우 결과 타입을 생략해도 컴파일러가 타입을 추론하지만, 때로 컴파일러가 함수의 결과 타입을 지정하도록 요구하는 경우가 있는데 함수가 재귀적이라면 함수의 결과 타입을 반드시 명시해야 한다.

Recursion Function - Fibonacci function

def fibonacci(n: Int): Int = {
    if (n <= 2) 1
    else fibonacci(n-1) + fibonacci(n-2)
}

스칼라는 함수를 정의하고 그 내부에 함수를 정의 할 수 있다. 아래 코드는 중첩된 함수를 정의한다.

Nested Function - Prime check function

def isPrime(n: Int): Boolean = {
    def isPrimeUntil(t: Int): Boolean = {
        if (t <= 1) true
        else n % t != 0 && isPrimeUntil(t-1)
    }

    isPrimeUntil(n / 2)
}

4. Type inference

스칼라는 프로그래머가 특정 타입을 생략할 수 있도록 해주는 빌트인 타입 추론 기능을 갖추고 있다. 컴파일러가 변수의 초기화 표현식으로 부터 타입을 추론 할 수 있기 때문에 변수의 타입을 지정할 필요가 없을 때가 많다. 또한 메소드의 리턴 타입은 본문의 타입과 일치하기 때문에 리턴 타입 또한 컴파일러가 추론 할 수 있다.

val message = "Hello, world!" // 초기화 값이 String이기 때문에 message 변수는 String 타입
val x = 2       // 초기화 값이 2이기 때문에 변수 x는 Int 타입
val y = x + "items"     // Int + String = String. 변수 y는 String 타입

def succ(x: Int) = x + 1 // 함수 본문의 Expression은 Int 타입이기 때문에 succ 함수 리턴 타입은 Int 타입
// 동일한 함수 정의
def succ(x: Int): Int = x + 1

// 다음과 같이 사용하면 에러 발생
val x: Int = "Hello, world!"    // 변수 x는 Int형으로 명시되어 있기 때문에 우변의 초기값인 String을 입력할 경우 에러

앞서 함수의 결과 타입을 생략해도 컴파일러가 타입을 추론하지만, 때로 컴파일러가 함수의 결과 타입을 지정하도록 요구하는 경우가 있다고 설명하였다. 하지만 함수가 재귀적이라면 함수의 결과 타입을 반드시 명시해야 한다.

5. Stack & Tail Recursion

def factorial(n: Int): Int = {
    if (n <= 1) 1
    else {
        println("Computing factorial of " + n + " - I first need factorial of " + (n-1))
        val result = n * factorial(n-1)
        println("Computed factorial of " + n)

        result
    }
}

factorial(5000) // Stack Overflow Error Occured!!

위 코드는 Factorial을 재귀적으로 계산하는 코드로 작은 수에 대해서는 정상 동작하지만 어느 시점에서는 결국 재귀적 함수 호출로 인해 스택 사용이 중첩되어 스택 오버플로 에러가 발생한다.

이렇게 재귀 함수의 콜 스택이 깊어질수록 메모리 오버헤드가 발생하는 문제를 해결하기 위한 재귀 호출 방식을 Tail Recursion(꼬리 재귀) 라고 한다.

재귀 함수의 실행 결과가 연산에 사용되지 않고 바로 반환되게 함으로써 이전 함수의 상태를 유지 할 필요가 없기 때문에 스택을 사용하지 않으므로 메모리 오버헤드가 발생하지 않는다.

아래는 꼬리 재귀로 구현한 Factorial 함수이다.

def anotherFactorial(n: Int): Int = {
    @tailrec
    def factHelper(x: Int, accumulator: Int): Int = {
        if( x <= 1) accumulator
        else factHelper(x - 1, x * accumulator) // TAIL RECURSION
    }

    factHelper(n, 1)
}
/*
  anotherFactorial(10) = factoHelper(10, 1)
  = factHelper(9, 10 * 1)
  = factHelper(8, 9 * 10 * 1)
  = factHelper(7, 8 * 9 * 10 * 1)
  = ...
  = factHelper(2, 3 $ 4 * ... * 10 * 1)
  = factHelper(1, 1 * 2 * 3 * 4 * ... * 10)
  = 1 * 2 * 3 * 4 * ... * 10
*/

6. Call-by-Name and Call-by-Value

Scala에서는 다음과 같은 두 가지의 함수 호출 방식이 있음.

• Call By Value(CBV) : 값에 의한 호출
• Call By Name(CBN) : 이름에 의한 호출

def calledByValue(x: Long): Unit = {
    println("CBV by value: " + x)
    println("CBV by value: " + x)
}

def calledByName(x: Long): Unit = {
    println("CBN by value: " + x)
    println("CBN by value: " + x)
}

calledByValue(System.nanoTime())
calledByName(System.nanoTime())

/*
CBV by value: 2892182467908626
CBV by value: 2892182467908626
CBN by value: 2892201562799589
CBN by value: 2892218927551838
*/

CBV의 경우는 함수가 호출되기 전에 파라미터의 값이 미리 정해지지만, CBN의 경우는 파라미터를 참조할 때마다 전달된 표현식이 평가되고 실행된다는 점이 다름.

아래의 코드는 CBN, CBV 파라메터를 입력받는 함수 호출에 대한 다른 예이다.

def infinite(): Int = 1 + infinite()
def printFirst(x: Int, y: => Int) = println(x)

// printFirst(infinite(), 34) <-- Error
printFirst(34, infinite())

첫 번째의 printFirst 호출의 경우 첫번째 인자가 Int 타입으로 infinite() 함수의 리턴 타입이 Int이어서 컴파일을 성공하지만 CBV 이기 때문에 먼저 infinite 함수의 호출 계산이 이뤄지는데 이때 무한재귀 호출로 에러가 발생한다.

두 번째 printFirst 호출의 경우는 두 번째 인자에 CBN으로 인자를 받고 있다. 하지만 함수 본문에서는 해당 인자의 참조를 하고 있지 않기 때문에 정상적으로 첫번째 인자의 값을 출력하고 정상 종료한다.

Takeaways

• Call by value

  • value is computed before call
  • same value used everywhere

• Call by name

  • expression is passed literally
  • expression is evaluated at every use within

7. Default and Named Arguments

scala에서 파라미터의 디폴트값을 지정할 수 있다. 디폴트 값을 지정한 파라미터가 있다면, 함수 호출시 해당 인자를 생략 할 수 있다. 생략한 인자는 디폴트값으로 채워진다.

• Before

  def trFact(n: Int, acc: Int): Int = {
      if (n <= 1) acc
      else trFact(n-1, n*acc)
  }
  
  val fact10 = trFact(10, 1) // <- 1 최초 값 설정.
  

• After

  def trFact(n: Int, acc: Int = 1): Int = { // <- acc 파라메터 디폴트값 1 설정
      if (n <= 1) acc
      else trFact(n-1, n*acc)
  }
  
  val fact10 = trFact(10)
  

디폴트 인자는 이름을 붙인 인자와 조합하면 유용하다.

def savePicture(format: String = "jpg", width: Int = 1920, height: Int = 1080): Unit = println("saving picture")

savePicture() // all parameter value is default 

savePicture(height = 600, format = "bmp")
/*
    1. pass in every leading argument
    2. name the arguments
*/

위 코드를 보면 savePicture()라고 호출하면 세 파라미터가 모두 디폴트값이 된다. 이름 붙인 인자를 이용해 호출하면, 이름 붙이지 않은 인자에 대해 디폴트값으로 유지한 채 어떤 값이라도 명시 할 수 있다.

Takeaways

When 99% of time we call a function with the same params:

def factorial(x: Int, acc: Int = 1): Int = {
    ...
}

val fact10 = factorial(10)

Naming parameters

def greet(name: String = "Superman", age: Int = 10): String = 
s"Hi, I'm $name and I'm $age years old."

greet(age = 5)

8. Smart Operations on Strings

scala에서 문자열 처리 방법과 Scala 2.10에 추가된 String interpolation 기능을 알아본다.

문자열 처리

val str: String = "hello, I am learning Scala"

println(str.charAt(2))          // 1
println(str.substring(7, 11))   // I am
println(str.split(" ").toList)  // List(Hello, I, am, learning, Scala)
println(str.startWith("Hello")) // true
println(str.replace(" ", "-"))  // "hello,-I-am-learning-Scala"
println(str.toLowerCase())      // "hello, i am learning scala"
println(str.length)             // 26

val aNumberString = "2"
val aNumber = aNumberString.toInt
println('a' +: aNumberString :+ 'z')   // a2z
println(str.reverse)                   // alacS gninrael ma I ,olleH
println(str.take(2))                   // He

String interpolation

• 데이터를 기반으로 문자열을 더 쉽게 만들수 있는 기능
• 즉, 문자열을 출력하거나 선언할 때 중간에 다른 변수를 끼워넣는 구문
• String interpolation은 s, f, raw 세가지의 방식을 제공한다.

아래는interpolation방식 3가지의 예 이다.

// Scala-specific: String interpolators.

// S-interpolators
val name = "David"
val age = 12
val greeting = s"Hello, my name is $name and I amd $age years old"
val anotherGreeting = s"Hello, my name is $name and I will be turning ${age + 1} years old."

println(anotherGreeting)    // Hello, my name is David and I will be turning 13 years old.

// F-interpolators
val speed = 1.2f
val myth = f"$name can eat $speed%2.2f burgers per minute"
println(myth)           // David can eat 1.20 burgers per minute

// raw-interpolator
pritln(raw"This is a \n newline") // This is a \n newline
val escaped = "This is a \n newline"
println(raw"$escaped")      // This is a
                            //  newline

String interpoators: F

• For formatted strings, similar to printf:

  val speed = 1.2f
  val myth = f"$name can eat $speed%2.2f burgers per minute"
  println(myth)           // David can eat 1.20 burgers per minute
  

• Can check for type correctness

  val x = 1.1f       // value is Float
  val str = f"$x%3d" // format requires Int --> Compiler error!!!