class Product(val name: String, val price: Int)

  interface Wheel {
  fun roll() 
}
  
//Kotlin에서는 인터페이스도 상위 인터페이스를 가질 수 있다.
interface Cart : Wheel {
  //kotlin에서는 인터페이스의 Property도 존재 가능하다.
  var coin: Int //MyCart Class에서 무조건 구현해야 하는 추상 프로퍼티다.
  
  val weight : String
    get() = "20KG"
    
    
 fun add(product: Product) 
 
  fun rent() {
   if (coin > 0) {
     println("카트를 대여합니다.")
   }
}
  override fun roll() {
    println("카트가 굴러갑니다.")
  }
}

interface Order {
  fun  add(Product : product) {
    println("${product.name} 주문이 완료 되었습니다.")
  }
}
//Kotlin에서는 하나 이상의 인터페이스를 구현 할 수 있다.
class MyCart(override var coin: Int) : Cart, Order {
  //Cart 인터페이스에서 구현해야하는 추상함수이기 때문에 오버라이드를 통해서 함수 생성 
  override fun add(product: Product){
    if (coin <= 0) println("코인을 넣어주세요.")
      else println("${product.name}이(가) 카트에 추가됐습니다.")
  }
  //복수개의 인터페이스에서 함수를 호출 할려고 하면 super<>키워드로 접근 가능하다.
  super.add(product) //장난감 주문이 완료 되었습니다.
  
}
fun main() {
  val cart = MyCart(coin = 100)
    cart.rent() //카트를 대여합니다. 
    cart.roll() //카트가 굴러갑니다. 
    cart.add(Product(name="장난감",price = 1000)) //장난감이(가) 카트에 추가됐습니다.
}

특징:

①. Kotlin에서는 인터페이스에서도 상위 인터페이스를 가질 수 있다.

②. Kotlin에서는 Interface의 Property도 존재 가능 하다. "var coin: Int"

MyCart Class에서 무조건 구현해야 하는 추상 프로퍼티다. class MyCart(override var coin: Int) ③. 복수개의 인터페이스에서 함수를 호출하려고 하면 super <> 키워드로 접근 가능하다.

출처 : FastCampus

상속

1.자바의 상속

• 객체지향 핵심 원칙 중 하나인 상속은 상속을 통해 기존 코드를 재사용하거나 확장할 수 있다.
• 자바는 기본적으로 모든 클래스가 상속이 가능하나 상속에 따른 부작용이 발생할 경우를 대비해 final 키워드로 막을 수 있다.
• 대표적으로 System 클래스

자바의 모든 클래스의 조상은 Object인데, 코틀린의 모든 클래스의 조상은 "Any"이다.

Any는 equals,hashCode,toString 함수를 제공한다.

코틀린에서 작성하는 어떤 클래스든지 다 이런 함수들을 상속 받는다.

또한 코틀린의 클래스는 자바와 다르게 기본적으로 final class이다. final이기에 기본적으로 상속을 막고, 필요한 경우 open이라는 키워드를 통해 상속을 허용 가능하다.

open class Dog {
  open var age: Int = 0
    
  open fun bark() {
    println("멍멍")
  }
}
  
  // : 뒤에 상위 클래스를 선언 하면 상속 코드 작성 가능하다.
open class Bulldog(overrid var age : Int = 0) : Dog()  {
 //하위클래스에서 상위클래스 age,bark 메서드를 재정의 하려면

    
overrid fun bark() { //overrid된 프로퍼티나,함수는 자동으로 open이 된다.
    //println("컹컹")
  super.bark() //상위 클래스의 함수나 프로퍼티들을 그대로 재사용할 수 있다.
  }
}  

abstract class Developer {
  
  abstract var age: Int
  abstract fun code(language: String)
}
//Developer 추상클래스를 상속받은 BackendDeveloper를 만들었다.
//이때, 하위클래스에서 구현해야하는 프로퍼티나 함수또한 abstarc함수를 사용하면 된다. 
class BackendDeveloper(override var age : Int = 0) : Developer() {
  override fun code(language: String) {
    println("I code with $language")
  }
}
  
  fun main() {
    val backendDeveloper = BackendDeveloper(age = 20) 
    println(backendDeveloper.age)//20
    backendDeveloper.code("Kotlin")//I code with Kotlin 
    
  //val dog = Bulldog(age = 2)
  //println(dog.age)//2
  //dog.bark()//멍멍 
}

class ChildBulldog : Bulldog () {
  overrid var age: Int = 0
  overrid fun bark() {
    super.bark()
  }
}

출처 : FastCampus

자바와 코틀린의 차이점

1.자바에는 있지만 코틀린에는 없는 기능

체크드 익셉션(Checked Exception)

• 자바의 익셉션 계층

① Throwable: 예외 계층의 최상위 클래스

② Error: 시스템에 비정상적인 상황이 발생.예측이 어렵다.

③ Exception: 시스템에서 포착 가능하며(try-catch) 복구 가능.예외 처리 강제

Ex)FileNotFoundException, IOException

(자바에서 Exception은 Compile Error가 발생하기에 무조건 try~catch로 감싸거나, throws로 예외 전파 해야한다.)

try {
  Thread.sleep(1);
} catch (InterruptedException e) {
  // 예외 처리
}

• 자바에서 Checked Exception을 처리할때, 의미 없는 처리를 반복하는 경우가 있다.
• Checked Exception이 발생할 경우 catch안에서 에러를 해결하는 일은 생각보다 흔하지 않고,

오히려 생산성을 감소 시킨다.

try{
  log.append(message)
} catch(IOException e) {
  // Do nothing 흔하게 볼 수 있는 코드
}

try {
  File file = FileUtils.get(filename);
  //...
}catch (FileNotFoundException e) {
  //파일이 없는데 어떤 처리를 하지?
}

try {
  return objectMapper.readValue(json, clazz);
} catch (IOException e) {
  //단순 에러 로그 출력
  logger.error(e.getMessage(), e);
}

④ RuntimeException: 런타임시에 발생하는 예외.예외 처리를 강제하지 않음.

ex) NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException

(CODE를 작성하는 시점에는 파악 하기 어려움,Unchecked Exception)

런타임은 프로그램의 수명 주기 중 실제로 코드가 실행 되면서, 메모리가 할당되고, 사용자와 상호 작용하며, 다양한 작업을 수행하는 시간이다. 런타임 오류는 이러한 실행 과정에서 발생하는 오류로, 일반적으로 프로그램의 논리적 오류, 잘못된 데이터 처리, 또는 예상하지 못한 상황에 대한 처리의 부재와 같은 문제로 인해 발생한다.

Kotlin은 Checked Exception을 강제하지 않는다.

Thread.sleep(1);

원하는 경우 try-catch를 쓸 수 있다.

try {
  Thread.sleep(1)
} catch (e: Exception) {
  //예외 처리
}

기본 자료형

• 자바는 Primitive data Type을 지원하며, 객체로된 Reference type도 지원한다.

int i = 0;
Integer ii = 0;
String str = ii.toString();

• 코틀린은 레퍼런스 타입만 지원한다.

val i: Int = 0;

val str: String = i.toString()

정적 멤버

• 자바는 static 키워드로 정적 멤버를 선언한다.

public class JavaClass {
  
  static int i = 0;
  
  public static void staticMethod() {
    // ... 
  }
}

• 코틀린은 companion object로 대체 한다.

class KotlinClass {
   
  companion object {
    val i: Int = 0
      
      fun function() {
      //...
    }
  }
}

삼항 연산자

• 자바는 삼항 연산자가 존재한다.

String animalSound = "호랑이".equals(animal) ? "어흥" : "야옹";

• 코틀린은 if-else로 대신한다.

val animalSound: string = if ("호랑이" == animal) "어흥" else "야옹"

세미콜론(;)

• 자바에서 라인의 끝은 무조건 세미콜론으로 끝나야한다.

Boolean isAdmin = userService.isAdmin(userId);

• 코틀린은 세미콜론이 필수가 아니다.

val isAdmin: Boolean = userService.isAdmin(userId)

2.Kotlin에는 있지만 자바에는 없는 기능

확장

• 개발자가 임의로 객체의 함수나 프로퍼티를 확장해서 사용할 수 있다.

MyStringExtensions.kt

fun String.first(): Char {
 return this[0]
}

fun String.addFirst(char: Char): String {
    return char + this.substring(0)
}

fun main() {
   println("ABCD".first()) // 출력 : A
   
   println("ABCD".addFirst('Z')) // 출력 : ZABCD
}

출처 : FastCampus

//클래스의 생성자를 만들 때, constructor keyword 사용 가능.
//constructor 생략 가능, 굳이 constructor를 쓰는 경우는, 특정 Annotation을 같이 쓰는 경우.
class Coffee //constructor
  (
  val name:String = "",
  val price: Int = "0",
  val iced : Booelan = false,
  ) {
  
  val brand: String
  //custom getter get() = "스타벅스" //String 표현식 
 get() {
 return "스타벅스"
 }
  //var로 선언된 프로퍼티는 custom setter도 만들 수 있다.
  var quantity : Int = 0
  set(value) {
  if (value > 0) { //수량이 0 이상인 경우에만 할당
  field = value //field는 식별자. setter getter에 사용하게 되면 quantity 같은 이름이 접근한다.
             }
  }
  
  }
  
class EmptyClass

    
fun main() {
  val coffee = Coffee()
  coffee.name = "아이스 아메리카노"
  coffee.price = 2000
  coffee.quantity = 1 
  coffee.iced = true
    
  if(coffee.iced) { 
    println("아이스 커피")
  }  //아이스커피    
  println("${coffee.brand} ${coffe.name} 가격은 ${coffee.price} 수량은 ${coffee.quantity}")
 //스타벅스 아이스 아메리카노 가격은 2000 수량은 1
}

출처 : FastCampus

예외처리

코틀린의 모든 예외 클래스는 최상위 예외 클래스인 Throwable을 상속한다.

자바에서는 Checked Exception은 compile Error가 발생하기 때문에 무조건 try-catch로 감싸거나, throws로 예외를 전파 해야한다.

try {
  Thread.sleep(1);
} catch (InterruptedException e) {
  //예외 처리
}

코틀린은 Checked Exception을 강제하지 않는다.

아래의 코드는 코틀린에서 컴파일 오류가 발생하지 않는다.

Thread.sleep(1);

fun main() {
  
  try {
    throw Exception()
  }catch(e: Exception) {
    println("에러 발생!") //에러 발생!
  }
  finally{
    println("finally 실행!") //finally 실행! 
  }
//kotlin은 표현식 형태로서 try catch문이 가능하다.
  val a = try {
    "1234".toInt()
  } catch (e: Exception) {
    println("예외 발생 !")
  }
  println(a) //1234
    
    //직접 Exception을 할려면 throw를 사용할 수 있다. 
    //throw Exception("예외 발생") //run창에 빨간 text로 : 예외 발생! 출력  
    val b : String? = null
    val c = b ?: failFast("a is null")
      
      println(c?.length)
    //Noting에서 발생하면 아래 코드는 실행되지 않는다.
    println("이 메세지는 출력 안됨 ")
      
  }  

fun failFast(message: String): Nothing {
  throw IllegalArgumentException(message) //throw를 리턴하게 되면 Nothing 타입을 반환 
}

출처 : FastCampus

널 참조의 위험성

• 자바를 포함한 많은 프로그래밍 언어에서 가장 많이 발생하는 유형이NullPointException 줄여서 NPE라고도 부른다.

• 자바에선 NPE를 줄이기위해 Optional을 지원 하기 시작했다.
• 자바의 Optional은 값을 래핑하기 때문에 객체 생성에 따른 호버헤드가 발생하고, 컴파일 단계에서 null 가능성을 검사하지 않는다.
• 코틀린을 비롯한 최신 언어에선 null 가능성을 컴파일러가 미리 감지해서 NPE 가능성을 줄일 수있다.

fun main() {
 //컴파일 오류 val a : String = null
  // var b : String = "aabbcc"
// b = null  컴파일 오류   
  
  var a : String? = null
    println(a?.length) //null 
    
    var b: Int = if (a != null) a.length else 0
      println(b) // null
      
      //엘비스 연산자
      //좌변이 null인 경우, 우변 값 반환
      val c = a?.length ?: 0
        println(c)
}

fun getNullStr(): String? = null
  
fun getLongthIfNotNull(str: String?) = str?.length ?:0
  
fun main() {
  val nullableStr = getNullStr()
    
  val nullableStrLength = nullableStr?.length ?: "문자길이".length 
    println(nullableStrLength) //4 (문자길이 반환해줌)
    
  val length = getLengthIfNotNull(null)
  println(length) //0  3line에 null이 아닌 경우 0을 출력하도록 되어있기에 0 출력
    
    
    //throw NullPorinterException() //에러발생 
    val c: String? = null
    val b = c!!.length //!!쓰게 되면,개발자가 봤을 때 이 코드는 널이 발생하지 않는 안전한 코드다.라고 컴파일러에게 알려줌
    //Null을 없애주는 것은 아니고 널이 발생하든 안하든 개발자가 체크해야하는 부분이다.
      
}

출처 : FastCampus

오늘은 흐름제어에 대해서 필기 해보았다.

if..else

//if..else
fun main() {
  
  //if..else 사용
  val job = "SoftWare Developer"
    
    if(job == "Software Developer") {
      println("개발자")
    } else("개발자 아님")  
}

//코틀린의 if...else는  "표현식" 이다. 자바는 "구문"이다. 
val age : Int = 10
  
  val str = if(age > 10) {
    "성인"
  } else {
    "아이"
  }

//코틀린은 삼항 연산자가 없다. if..else가 표현식이므로 불필요 하다.
val a = 1
val b = 2
val c = if (b > a) b else a

위와 같이, Kotlin에서의 if..else문은 표현식이며, 삼항연산자가 없다는 특징이 있다. 

When

자바에서 특정 break누락한 경우, 그대로 넘어가기에 예상치 않은 결과를 return할 수 있다.밑은 자바에서의 When 예시

Kotlin

//Kotlin에서 When식 
fun main() {
  val day = 2
  val result = When (day) {
    1 -> "월요일"
    2 -> "화요일"
    3 -> "수요일"
    4 -> "목요일"
    else -> "기타"  
  }
  println(result) //화요일
  // else 생략 가능.
    when(getColor()) {
    Color.Red -> print("red")
    Color.GREEN -> print("green")
    else -> println("blue")
  }
  // 여러개의 조건을 콤마로 구분해 한줄에서 정의할 수 있다.
  when (getNumber()) {
    0, 1 -> print("0 또는 1")
    else -> print("0또는 1이 아님")
  }
}

enum class Color {
  RED, GREEN, BLUE
}

fun getColor() = Color.RED

fun getNumber() = 2-

for loop

fun main() {
  //  범위 연산자 ..를 사용해 for loop 돌리기
  for (i in 0 < .. <3) {
    println(i) 
      //0
      //1
      //2
      //3
  }
  // until을 사용해 반복한다.
  // 뒤에 온 숫자는 포함하지 않는다.
  for (i in 0< until <3) {
    println(i)
      //0
      //1
      //2
  }
  //step의 값 만큼 증가시킨다
  for(i in 0 <.. < 6 step 2){
    println(i)
      //0
      //2
      //4
      //6
  }
  //downTo를 사용해 반복하면서 값을 감소시킨다.
  for(i in 3> downTo >1) {
    println(i)
      //3
      //2
      //1
  }
  
  //전달받은 배열을 반복
  val numbers = arrayOf(1,2,3)
    
    for(i in numbers) {
      println(i)
    }
  //1
  //2
  //3
}

While

fun main() {
  //Java의 while문과 동일
  //조건을 확인하고 참이면 코드 블록을 실행한 후 다시 조건을 확인
  
  var x = 5
    
    while(x > 0) {
      println(x)
        x--
        //5
        //4
        //3
        //2
        //1
    }
  
}

출처 FastCampus

(Kotlin 카테고리를 통해서 순서대로 공부할 수 있으니, 참고 부탁드립니다. ^^ 👍 )

이번엔 함수에 대해서 알아보자. Kotlin에는 함수를 선언하는 것도 엄청 다양하고 유용한 것들이 많다!👏(대박...함수 조차 이렇게 많이 신경쓰는 언어 너무 매력있고 멋있어요 정말)  빨리 알고 싶으니 바로 Let's go!

①. 가장 기본적인 함수 스타일

  //function의 약자 fun, 함수명, 함수 인자, 함수 반환할 타입,로직이 있다.
    fun sum(a: Int, b: Int) : Int {
        return  a + b
    }

위의 코드를 잘 살펴보면

①.function의 약자인 fun

②. 함수명(sum)

③. 함수의 인자(a: Int, b: Int)

④. 함수가 반환할 Type

⑤.함수의 로직이 들어가는 몸통( { return a +b } )으로 구성 되어 있다!

②.표현식 스타일

  //표현식 스타일
    fun sum2(a: Int, b: Int) : Int = a + b
    //표현식 & 반환타입 생략
    fun sum3(a: Int, b: Int) = a + b

Kotlin에서는 표현식 스타일을 제공하고 있다. sum2의 함수를 보면 중괄호 없이 로직만 들어간 것을 확인할 수가 있다.

바로 이런 방법을 표현식이라고 한다!

sum3처럼 반환타입을 생략할 수가 있다.저번 시간에 변수는 타입추론이 가능하다고 했었다. 그런 것처럼 함수도 타입 추론이 가능해져서 타입을 컴파일러가 기본적으로 추론 해주기 때문에 반환 타입을 생략 가능하다!  이것은 함수 본문이 단 하나의 표현식으로 구성된 함수인데 단일 표현식 함수(single-expression function)라고 한다.

 //몸통이 있는 함수는 반환 타입을 제거하면 컴파일 오류 //Int 생략하면 오류
    fun sum4(a: Int, b:Int) : Int {
        return a + b
    }

단! 위의 코드처럼 중괄호가 있을 경우, return-type을 생략하면 compile error가 발생 하니 주의 바란다😢..

예를 들어서 위의 "Int" 를 생략하게 되버리면 return 부분에서 빨간 줄로 변할 것이다(헉👀)

③.반환타입이 없는 함수는 Unit을 반환 한다.

  //반환타입이 없는 함수는 Unit을 반환한다. Void와 유사 반환타입에는  : Unit 이 숨겨져 있다.
    fun printSum(a: Int, b: Int) {
        println("$a + $b = ${a + b}")
    }

Kotlin에서는 반환 타입이 없는 함수는 Unit을 반환하게 되어 있다. Java로 굳이 이야기 하자면 Void와 유사하다.

return이 없고 반환 값이 없는 함수의 경우에 사용 가능하다. Kotlin에서 반환 값이 없거나 중요하지 않은 경우에 사용되는 특수한 타입이다.

하지만 일반적으로 Unit 타입은 생략하고 작성하는 것이 더 깔끔하고 일반적이다.

 ④.Default Parameter

//디폴트 파라미터
    fun greeting(message: String = "안녕하세요!!") {
        println(message)
    }
    
       fun main() {
        greeting()
        greeting("Hi!")
    }

Kotlin에서는 Default Parameter라는 아주 유용한 기능을 제공하고 있다. 인자로 message라는 String값을 받도록 하고,

"안녕하세요!!"라는 값을 할당했는데, 

main 함수에서 실행하게 되면, 첫번째 greeting() 이라고 선언한 함수는 아무 값도 안주니 "안녕하세요!!"라는 값이 출력된다.

두번 째 함수인 greeting("HI!!!")에서는 "HI!!!"라는 값이 출력 된다. 이와 같이 Kotlin에서는 값이 없는 경우 Default parameter에서 값을 할당 해줄 수가 있다.

아래는 자바 코드인데, Message라는 Java class라는 클래스를 생성했다.

public class Message {

    public void greeting(String message) {
        if (message == null || message.length() == 0) {
            System.out.println("안녕하세요!!");
            return;
        }
        System.out.println(message);
    }

    public static void main(String[] args){

        new Message().greeting(null);

        new Message().greeting("Hello, World");
    }
}

, new Message().greeting(null);은 null이기 때문에 if문으로 값을 check해서 넣어주는 것과 유사하다.

⑤.Named Argument

fun log(level: String = INFO", message: String) {
  println("[$level]$message")
}

fun main() {
  log(message = "인포 로그")
  log(level = "DEBUG", "디버그 로그")
  log("WARN", "워닝 로그")
  log(level = "ERROR", message="에러 로그")
 
}

위와 같이 level이라는 String 변수, message라는 스트링 변수를 받았다. 그래서 level은 괄호로 감싸주었고 $를 주었다.

main 함수에서 log를 4번을 사용했다.

함수에 변수 값을 넣을 때, 이름과 값을 매핑하는 기법을 Named Argument라고 한다. 출력하게 되면

fun log(level: String = INFO", message: String) {
  println("[$level]$message")
}

fun main() {
  log(message = "인포 로그") //[INFO]인포 로그
  log(level = "DEBUG", "디버그 로그") //[DEBUG]디버그 로그
  log("WARN", "워닝 로그") //[WRAN]워닝 로그
  log(level = "ERROR", message="에러 로그") //[ERROR]에러 로그
 
}

이렇게 출력 된다.

위와 같이 여러 함수기능들이 있으며, Kotlin의 변수와 같이, 함수도 따로 클래스가 없는데도 함수를 선언 가능한 특징이 있다.

참고: FastCampus

(Kotlin 카테고리를 통해서 순서대로 공부할 수 있으니, 참고 부탁드립니다. ^^ 👍 )

Kotlin을 이번에 강의를 듣게 되었다. Java를 이용했던 변수와 다르게 또 다른 변수 선언 법이라서 재밌었다.

Kotlin의 변수에 대해서 알아보자.

//클래스에 있지 않게 가능.
var x = 5

fun main() {

    x+= 1
    println(x)
    val a : Int = 1

    val b = 1

    val c : Int
    c = 3

    val d : Int
    d = 123

    //val(final 재할당 X)
    //var(variable 재할당 O)


    var f = 123

    //오류 f = "hi";
}

위의 코드블록을 살펴보다 보면... 음..? 뭔가 익숙지 않은.... Kotlin만의 향수가 나고 있다.

엄청난 매력을 가지고 있는 친구다. 차근차근 알아보자!

-Kotlin의 변수 선언의 특징- 

①. Kotlin에서는 val과 var 키워드를 사용해서 변수를 선언한다. 

val :  Java에서의 "final" 변수와 유사한 친구다. 즉, 한번 값이 할당 돼버리면,  변경 불가능한 변수라고 생각하시면 된다.

var:   var은 변경 가능한 변수(Mutable) 다. variable뜻처럼,  변할 수 있으니, "variable"의 줄임말이라고 외워보면 한결 쉬워졌다.

②. Kotlin에서는  타입 "추론"이 가능하다.

Kotlin은 변수 선언 시 타입을 명시적으로 선언하지 않아도 Compiler가 type을 추론할 수가 있다... 👍(... 엄청나군)

이게 얼마나 대단한 거냐면 예를 들어 `val a : Int = 1`에서 `Int`타입을 명시한 것이랑, `val b = 1`에서는 타입을 생략했을 때, Compiler는 아, 얘도 위에 거랑 같은 거구나 하고 생각하고 `Int`로 추론 해버린다..  무시무시한 능력이다. (인공지능?)

③. Kotlin에서는 범위 밖 변수 선언 가능 하다.

위의 예시 코드로 잠깐 Scroll을 올려다보면.. 음? 맨 윗 첫 번째 코드에 외톨이 같이 홀로 변수를 지정할 수가 있다..

이렇게 외톨이 같이 함수 밖에 정의된 변수들도 함수 안으로 가져올 수가 있다.

var globalVar = "전역 변수"

fun main() {
    println(globalVar) // 전역 변수 출력

    globalVar = "전역 변수 수정"
    println(globalVar) // 수정된 전역 변수 출력

    var globalVar = "함수 내에서 재정의한 전역 변수"
    println(globalVar) // 함수 내에서 재정의한 전역 변수 출력
}

④. 타입 불일치 오류를 발생시킬 수 있다.

  var f = 123
  //오류 f = "hi";

Int로 추론되었던 것이, 문자열 같은 Type이 다른 걸로 재할당하려고 하면, 오류가 발생해 버린다.

참고: FastCampus