231204 TIL

Kotlin 문법 1주차 기초

헷갈리고 잘 와닿지 않는 것들만

Kotlin 시작

 

 

자료형

 

 

증감연산자 ++ --

-1을 더하거나 빼는 특수한 경우

		var num1 = 10
		var num2 = 20
    	var num3 = 30
    
    // 후위연산자는 println연산을 실행후에 증감해요
    println(num1++) // 10
    println(num1) // 11
    
    // 전위연산자는 println연산 실행전에 증감해요
    println(++num2) // 21
    println(num2) // 21
    
    num3++
    println(num3) // 31
    
    ++num3
    println(num3) // 31

 

 

조건문 if/else when

-if/else 의 경우 조건이 많아질 때 when 을 사용하는 것이 가독성에 좋다.

-if 구문은 최악의 경우 모든 조건을 다 비교한다 >> 낭비

 

반복문 for while

-for 의 구조

// 리스트(묶음)에서 하나의 요소들을 반복해서 가져오는 경우입니다
for(요소 in 리스트) {
	  소스코드 (로직)
}

// 숫자의 범위를 기준으로 반복하는 경우입니다
// 시작값이 0이고, 마지막값이 5라면 인덱스는 0,1,2,3,4이므로 총 5번 반복해요
// until을 생략해서 시작값..마지막값으로 사용할수도 있어요
for(인덱스 in 시작값 until 마지막값) {
		소스코드 (로직)
}

-while 의 구조

while(조건식) {
		소스코드 (로직)
		증감식
}

반복문의 break : 가장 가까운 반복문에서 탈출, 다음 블록으로 넘어감 

 

---

객체지향프로그래밍

= 프로그래밍 언어 + 객체지향개념(규칙)

 

목적 : 코드의 재사용성 ⬆️ 유지보수 용이 중복코드 제거

 

클래스(=설계도)의 기본 구조

class 클래스이름 {
	  정보1
		정보2

		행위1
		행위2
}

데이터 클래스, 실드 클래스, 오브젝트 클래스

 

 

생성자

-기본 생성자

아무 매개변수를 받지 않음

class MyClass {
    // 기본 생성자
}

-명시적 생성자(>주/부생성자)

클래스 헤더에 명시적으로 생성자를 추가

class MyClass(val x: Int, val y: Int) {
    // 명시적 생성자
}

-주생성자 : class 선언부에 생성자를 명시

fun main() {

}

// 클래스 선언부에 생성자를 명시함
class Character(_name:String, _hairColor:String, _height:Double) {
    var name:String = ""
    var hairColor:String = ""
    var height:Double = 0.0

		// 매개변수를 직접 넘기지않음
    init {
        println("매개변수없는 생성자 실행 완료!")
    }

}

-부생성자 : 생성자에 변수를 넘김

	fun main() {

  }

  class Character {
      var name:String = ""
      var hairColor:String = ""
      var height:Double = 0.0

      // 명시적 생성자 (Constructor)
      // _name, _hairColor, _height와 같이 생성자에 변수를 넘기는 경우에 사용함
      constructor(_name:String, _hairColor:String, _height:Double) {
          println("${_name}을 생성자로 넘겼어요")
          println("${_hairColor}를 생성자로 넘겼어요")
          println("${_height}를 생성자로 넘겼어요")
      }
  }

 

 

객체

: class 타입으로 선언된 것들

: 모든 인스턴스를 포함 (인스턴스 : class에 소속된 개별적인 개체)

-객체와 인스턴스의 차이

객체는 선언, 인스턴스는 실체화(객체가 메모리에 할당되어 실제 사용될 때 인스턴스라한)

 

 

상속

-class 를 상속하여 다형성 구현. open 키워드로 상속

 

오버라이딩

-부모 class의 정보나 행위를 재설계

 

 

오버로딩

-매개변수의 자료형/갯수를 다르게 하면 동일한 이름으로 여러 개의 메소드를 만들 수 있다.

 

 

 

인터페이스

오버라이딩과 오버로딩은 이해했다.

그런데 인터페이스는....잘 모르겠다.

위 둘은 각각 메소드를 확장할 수 있다는 걸 알겠는데

interface는 그 안의 함수를 그냥 바로 class 에 넣어주면 안되는건가?

 

내가 이해가 안됐던 이유

package com.example.myapplication

class Archer : Character {
    var name:String = ""
    var age:Int = 0
    var gender:String = ""
    var money:Int = 0
    var hp:Int = 0

    constructor(_name:String, _age:Int, _gender:String, _money:Int, _hp:Int) {
        println("${name}궁수 생성")
        name = _name
        age = _age
        gender = _gender
        money = _money
        hp = _hp
    }

    override fun attack() {
        println("활쏘기!")
    }

    fun windArrow() {
        println("바람의 화살!!")
    }

    fun windJump(destination:String) {
        println("${destination}까지 도약!")
    }
}

이 Archer class의 경우는 

override 나 interface 없이 windArrow 나 windJump 함수를 추가하는게 가능했는데

왜 

fun main() {
    var bird = Bird("새")
    
    var duck = Duck("오리")

    bird.fly()
    
    duck.swim()
}

open class Bird(name:String) {
    var name: String = ""

    init {
        // this는 현재 클래스의 상태변수를 의미합니다
        // var name: String = ""
        this.name = name
    }

    fun fly() {
        println("${name} 날아요~")
    }

}


class Duck(name: String) : Bird(name), WaterBirdBehavior {
    override fun swim() {
        println("${name}가 수영해요~")
    }
}

여기에서의 swim은 waterBirdBehavior 라는 인터페이스를 따로만들면서 override를 해야하느냐

 

 : 무조건 만들어야해서 넣은 게 아니고 interface 의 예시를 보여주기 위해 넣은 것

interface 를 사용함으로써 얻을 수 있는 장점이 있고

위의 경우 interface 를 삭제하고 class Duck 의 WaterbirdBehavior를 지워주면 Archer 처럼 작동한다.

 

그럼 interface 의 장점이 뭐냐?

-다양한 클래스가 동일한 행동이나 특성을 공유하도록 하고,
-이로써 유연성을 높이고 코드 재사용성을 증가시킬 수 있다는 점 
-또한, 다중 상속을 지원하는데, 클래스는 여러 인터페이스를 구현할 수 있어 더 다양한 특성을 갖게 될 수 있다
-서로 상속관계가 아닌 클래스들을 묶어줄 수 있다.