checked exception - 반드시 예외 처리를 해야됨

unchecked exception - 예외 처리를 하지 않아도 됨

코틀린은 unchecked exception 이다. - throws 를 볼일이 없다.

try with resource 구문이 없다.

If 문 자바랑 동일

fun validateScoreIsNotNegative(score: Int) {
    if (score < 0) {
        throw IllegalArgumentException("${score}는 0 보다 작을수 없습니다.")
    }
}

fun getPassOrFail(score: Int): String {
    if (score >= 50) {
        return "P"
    } else {
        return "F"
    }
}

하지만 Java 에서는 if-else는 Statement 이지만, Kotlin에서는 Expression 이다.

int score = 30 + 40; //70이라는 하나의 결가과 나온다. (Expression 이면서 statment)

fun getKotlinPassOrFail(score: Int): String {
    return if (score >= 50) {
        "P"
    } else {
        "F"
    }
}

즉 kotlin 에서는 if-else를 expression 으로 사용할 수 있기 때문에 3항 연산자가 없다.

fun getKotlinGetGrade(score: Int): String {
    return if (score >= 90) {
        "A"
    } else if (score >= 80) {
        "B"
    } else {
        "C"
    }
}

switch

fun kotlinValidateScore(score: Int) {
    if (score !in 0..100) {
        throw IllegalArgumentException("score 범위는 0부터 100이 아닙니다.")
    }
}

fun kotlinValidateScore(score: Int) {
    if (score in 0..100) {
        throw IllegalArgumentException("score 범위는 0부터 100입니다.")
    }
}

//코틀린은 switch 가 사라짐 대신에 when을 사용

 fun getGradeWithSwitch(score: Int): String{
    return when (score/10){
        9 -> "A";
        8 -> "B";
        7 -> "C";
        6 -> "D";
        else -> "E"
    }
}
//범위
fun getGradeWithSwitch(score: Int): String{
    return when (score/10){
        in 80..90 -> "A";
        in 70..80 -> "B";
        in 60..70 -> "C";
        in 50..60 -> "D";
        else -> "E"
    }
}

//객체가 스트링이라면...  
fun startWithA(obj: Any):Boolean{
    return when(obj){
        is String -> obj.startsWith("A")
        else -> false
    }
}

fun judgeNumber(number: Int) {
    when (number) {
        1, 0, -1 -> println("어디서 많이 본 숫자 입니다.")
        else -> println("1,0,-1 이 아닙니다.")
    }
}

fun judgeNumber2(number: Int) {
    when {
        number == 0 -> println("주어진 숫자는 0입니다.")
        number % 2 == 0 -> println("주어진 숫자는 짝수입니다.")
        else -> println("주어진 숫자는 홀수입니다.")
    }
}

반복문을 다루는법

val numbers = listOf(1L,2L,3L)
    for (number in numbers) {
        println(number);
    }

    //ㅑ 1부터 3 증가 
    for (i in 1..3) {
        println(i)
    }

    //i 3분터 1로 내려간다.
    for(i in 3 downTo 1){
        println(i);
    }

    //i 2씩 올라간다.
    for(i in 1..5 step 2){
        println(i)
    }

    //1..3 .. 은 InRange
    // IntProgression 등차수열 
    //downTo , step 은 함수 다```

예외를 다루는 법

fun parsIntOrThrow(str: String):Int{
    try {
        return str.toInt();
    }catch (e: NumberFormatException){
        throw IllegalArgumentException("주어진 $str 은 숫자가 아닙니다.")
    }
}

fun parseIntOrThrowV2(str: String): Int? {
    return try {
        str.toInt()
    } catch (e: NumberFormatException) {
        null
    }
}

checked exception - 반드시 예외 처리를 해야됨

unchecked exception - 예외 처리를 하지 않아도 됨

코틀린은 unchecked exception 이다. - throws 를 볼일이 없다.

try with resource 구문이 없다.!

‘==’ : 주소 + 값 같은가

‘.equals() : 값 같은가

Kotlin

‘===’ : 주소 + 값 같은가

‘==’ : 값 같은가

var money1 = Money(1000L);
var money2 = Money(3000L);

println(money1 + money2);

//Money(amount=4000) 자동으로 toString이 들어가있다.

제어문을 다루는법

If 문 자바랑 동일

fun validateScoreIsNotNegative(score: Int) {
    if (score < 0) {
        throw IllegalArgumentException("${score}는 0 보다 작을수 없습니다.")
    }
}

fun getPassOrFail(score: Int): String {
    if (score >= 50) {
        return "P"
    } else {
        return "F"
    }
}

하지만 Java 에서는 if-else는 Statement 이지만, Kotlin에서는 Expression 이다.

int score = 30 + 40; //70이라는 하나의 결가과 나온다. (Expression 이면서 statment)

fun getKotlinPassOrFail(score: Int): String {
    return if (score >= 50) {
        "P"
    } else {
        "F"
    }
}

즉 kotlin 에서는 if-else를 expression 으로 사용할 수 있기 때문에 3항 연산자가 없다.

fun getKotlinGetGrade(score: Int): String {
    return if (score >= 90) {
        "A"
    } else if (score >= 80) {
        "B"
    } else {
        "C"
    }
}

switch

fun kotlinValidateScore(score: Int) {
    if (score !in 0..100) {
        throw IllegalArgumentException("score 범위는 0부터 100이 아닙니다.")
    }
}

fun kotlinValidateScore(score: Int) {
    if (score in 0..100) {
        throw IllegalArgumentException("score 범위는 0부터 100입니다.")
    }
}

//코틀린은 switch 가 사라짐 대신에 when을 사용

 fun getGradeWithSwitch(score: Int): String{
    return when (score/10){
        9 -> "A";
        8 -> "B";
        7 -> "C";
        6 -> "D";
        else -> "E"
    }
}
//범위
fun getGradeWithSwitch(score: Int): String{
    return when (score/10){
        in 80..90 -> "A";
        in 70..80 -> "B";
        in 60..70 -> "C";
        in 50..60 -> "D";
        else -> "E"
    }
}

//객체가 스트링이라면...  
fun startWithA(obj: Any):Boolean{
    return when(obj){
        is String -> obj.startsWith("A")
        else -> false
    }
}

fun judgeNumber(number: Int) {
    when (number) {
        1, 0, -1 -> println("어디서 많이 본 숫자 입니다.")
        else -> println("1,0,-1 이 아닙니다.")
    }
}

fun judgeNumber2(number: Int) {
    when {
        number == 0 -> println("주어진 숫자는 0입니다.")
        number % 2 == 0 -> println("주어진 숫자는 짝수입니다.")
        else -> println("주어진 숫자는 홀수입니다.")
    }
}

//Java 에선
int number1 = 4;
long number2 = number1;
System.out.println(number1 + number2);

//int 타입의 값이 long 타입으로 암시적으로 변경되었고 Java 에서는 더 큰 타입으로 암시적 변경이 가능

하지만 코틀린에서는 불가능

val number1 = 4
val number2 = number1 // 컴파일 에러

//-> solution
val number = 3 //--int
val number2: Long = number.toLong() //으로 해결

to 변환 타입을 사용해야된다.

객체 타입 예제

fun printAgeIfPerson(obj: Any){
    if(obj is person){
    val person obj as person
    println(person.age)
    }
}

fun printAgeIfPerson(obj: Any){
    if(obj !is person){
    val person obj as person
    println(person.age)
    }
}

java → instanceof

kotlin → is

→ as 는 타입으로 변경

Any (Java의 Object) : 최상의 타입

Unit

Nothing

String interpolation/ String Indexing

var 과 val 의 차이점

• var(variable) 변할수있는 값
• val(value) 변할수 없는 값

var number: Long = 1L // Long number = 1L;
val number: Long = 1L // final Long number = 1L;

Tip !

모든 변수는 일단 val 로 만들고 꼭 필요한 경운 var로 변경한다.

코틀린에서는 알아서 long(primitive type) 또는 Long (reference type)를 자동으로 알아서 판단하에 적용해준다. 이 말은 즉, 프로그래머가 boxing unboxing 고려할필요없다.

reference type [예) Long, Integer, .. DOUBLE ] 은 null 이 허용된다.

? 를 넣어준다.

val number: Long? = 1L

객체 인스턴스 할 때는 new 를 쓰지 않는다.

function

fun startsWithA(str: String): Boolean{
    return str.startsWith("A");
}

safe call

null 이 아니면 그냥 실행하고, 널이면 전체가 널

val str:String? = "ABC"
// println(str.length)-- error
println(str?.length) //-- str 이 null이면 전체가 null

Elvis 연산자

앞의 연산 결과가 null 이면 뒤의 값을 사용

val str: String? = null
str?.length ?: 0; //-- 0 

예제

fun calculate(number: Long?): Long {
    number ?: return 0;
}

fun notNull(str:String?): Boolean{
return str!!.startsWith("A") //-- 절대 str 이 null이 아닐때 쓰임 만약 널이 들어오면 NPE

플랫폼 타입

코틀린에서 Java 코드를 가져다 사용할 때 어떻게 처리될까?

val person = Person("공부하는 개발자")

fun startWithA(str: String): Boolean{
    return str.startsWhith("A")
}

public class Person{
    private final String name;

    @NotNull // @Nullable 일때는 에러 
    public String getName(){
    return name;
        }
}

예제) 영화 예매

• 할인 조건
  • 예) 10번째로 상영 시작 시간 예매한 고객에게 할인
  • 예) 조조할인 아침10~오후1시까지 예매한 고객에게 할인
• 할인 정책
  • 예) 금액 할인 정책 (amount)
  • 예) 비율 할인 정책 (percentage)

대부분의 사람은 클래스를 결정한 후에 클래스에 어떤 속성과 메서드가 필요한지 고민한다.

하지만, 객체 지향은 클래스가 아닌 객체에 초점을 맞출 때에만 얻을수있다.

첫째, 어떤 클래스가 필요한지를 고민하기 전에 어떤 객체들이 필요한지 고민하라.

둘째, 객체를 독립적인 존재가 아니라 기능을 구현하기 위해 협력하는 공동체의 일원으로 봐야 한다.

도메인 이란, 문제를 해결하기위해 사용자가 프로그램을 사용하는 분야를 가리킨다.

일반적으로 클래스의 이름은 대응되는 도메인 개념의 이름과 동일하거나 적어도 유사하게 지어야한다.

클래스 생성시

외부에서는 객체의 속성에 직접 접근할수 없고(private) public 메소드를 통해서만 내부 상태를 변경할 수 있게 해야 한다.

이유) 경계의 명확성이 객체의 자율성을 보장하기 때문이다. + 프로그래머에게 구현의 자유를 제공하기 때문

캡슐화 - 데이터와 내부 기능을 함께 묶는것

캡슐화와 접근제어

• 퍼블릭 인터페이스 (public interface) - 외부에서 접근 가능
• 구현 (implementation) - 오직 내부에서만 접근 가능

프로그래머의 자유

• 클래스 작성자
  • 새로운 데이터 타입을 프로그램에 추가
• 클라이언트 프로그래머
  • 필요한 클래스들을 엮어서 애플리케이션을 빠르고 안정적으로 구축

객체의 변경을 관리할 수있는 기법 = 접근제어

개발자라면 객체지향은 정말 중요하다.

나도 개발을 하고있지만 객체지향을 정말 잘 알고있다? 흠.... 백엔드 개발을 하면서 객체지향을 좀 뚜렷하게 알고싶어서 이 책을 샀다. 산지 벌써 한 2년된거 같다. 나는 정말 책을 극혐한다..하지만 이제 책좀 읽어보고 블로그도 동시해 해보려고 글을 쓴다.

조영호 지음

• Chapter 1. 객체, 설계

  이론 보다는 실무가 먼저다.

  모듈이란

  크기와 상관없이 클래스, 패키지, 라이브러리와 같이 프로그램을 구성하는 임의의 요소를 의미한다.

  모듈의 목적

  • 제대로 동작

  • 변경을 위해 존재

  • 코드를 읽는 사람과 의사소통

    객체지향 설계는 서로 의존하면서 협력하는 객체들의 공동체를 구축하는 것이다. 따라서 우리의 목표는 애플리케이션의 기능을 구현하는데 필요한 최소한의 의존성만 유지하고 불필요한 의존성을 제거하는 것이다.

  • 의존성이 과한 경우를 가리켜 결합도(coupling)가 높다 라고 말한다.

  • 개념적이나 물리적으로 객체 내부의 세부적인 사항을 감추는 것을 캡슐화(encapsulation)라고 한다.

  • 밀접하게 연관된 작업만을 수행하고 연관성 없는 작업은 다른 객체에게 위임하는 객체를 가리켜 응집도(cohension)가 높다라고 말한다.

    절차적 프로그래밍 - 프로세스와 데이터를 별도의 모듈에 위치시키는 방식 - 전형적인 의존성코드 (BAD)

    나쁜이유 - 데이터의 의존해야 한다는 근복적인 문제점 때문에 변경에 취약

    객체가 어떤 데이터를 가지느냐보다는 객체에 어떤 책임을 할당할 것이냐에 초점을 맞춰야한다.