20231205 (화) Kotlin 3주차강의

코틀린강의 3주차의 내용

 

1. <메소드 설계>

메소드란?

fun 메소드이름(변수명:자료형, 변수명:자료형 ....) : 반환자료형 {
소스코드 로직
}

대충 이런식의 구조라는데.. 처음에 이것만 보고서는 이해가 잘 안갔다. 이후에 예시를 보았는데

 

예시1)

fun main() {
    var num1 = readLine()!!.toInt()
    var num2 = readLine()!!.toInt()
    sum(num1, num2)
}
fun sum(num1:Int, num2:Int) {             <<이런식으로 fun main 을 포함해서 fun다음에 오는 것들을 메소드라고 하나보다.
    var result = num1 + num2
    println("num1과 num2의 덧셈결과는 ${result}입니다.")
}

 

예시2)

fun main() {
    displayInfo()                                     << displayInfo라는 이름의 메소드를 호출함
}

fun displayInfo() : Unit {                       <<예시1처럼 num1:Int, num2:Int 등이 없으면 생략도 가능하다.
    println("오늘의 날씨는 화창합니다")
    println("오늘은 검정색을 조심하세요")
}

 

2. <클래스 설계>

 

보통 클래스를 설계할땐 class 전용 파일을 하나 만들기도 하며 내용으론

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

행위1
행위2
}

이런식으로 짜여진다. (하나의 클래스파일에 여러개의 클래스가 있을수도있음)

 

특별한 클래스들

• 데이터 클래스 (data class)
• 실드 클래스 (sealed class)
• 오브젝트 클래스 (object class)
• 열거 클래스 (enum class)

등등 있지만 이들은 차츰 배워나가자

 

클래스라는건 언제쓰일까?

신규 게임 캐릭터의 머리색상(정보)은 빨강이고, 스킬(행위)은 파이어볼.. 등등 한 객체의 정보를 저장할때 쓰이는것 같다.

 

예시)

아래 예시는 아직 클래스정보를 불러오진 않고 저장만 하는 형식이다

fun main() {
}
class Character {
    var name:String = "이름"                                  <<클래스 Character의 name "이름"
    var hairColor:String = "파랑"                             <<클래스 Character의 hairColor "파랑"
    var height:Double = 175                                   <<클래스 Character의 height 175

    fun fireBall() {
        println("파이어볼!")                                       <<클래스 Character가 하는 행위 fireBall
    }
    fun compositing(device1:String, device2:String): String {
        var device3 = device1 + device2
        println("새로운 무기인 ${device3}입니다")   <<이는 새로운 무기를 얻으면 출력되도록 할 예정인가보다.
        return device3
    }
}

 

3. <생성자 활용>

생성자는 주 생성자, 부 생성자 2개로 나뉘는데

 

-Init 주 생성자

fun main() {
}
// 클래스 선언부에 생성자를 명시함
class Character(_name:String, _hairColor:String, _height:Double) {   <<이부분이 확실하게 정해져야된다.
    var name:String = ""
    var hairColor:String = ""
    var height:Double = 0.0

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

    fun fireBall() {
        println("파이어볼!")
    }
    fun compositing(device1:String, device2:String): String {
        var device3 = device1 + device2
        println("새로운 무기인 ${device3}입니다")
        return device3
    }
}

 

-Constructor 부생성자

fun main() {
  }
  class Character {                                                  <<위와같이 캐릭터옆에 적지않고 따로 constructor를 남긴다.
      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}를 생성자로 넘겼어요")
      }

      fun fireBall() {
          println("파이어볼!")
      }
      fun compositing(device1:String, device2:String): String {
          var device3 = device1 + device2
          println("새로운 무기인 ${device3}입니다")
          return device3
      }
  }

 

이렇듯 생성자를 적을땐 _name, _hairColor, _height  _(언더바)를 넣어준다.

이제 요기서 Constructor 심화를 들어가보면

 

fun main() {
}
class Character {
    var name:String = ""
    var hairColor:String = ""
    var height:Double = 0.0
    var age:Int = 0
    var gender:String = ""

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

    fun fireBall() {
        println("파이어볼!")
    }
    fun compositing(device1:String, device2:String): String {
        var device3 = device1 + device2
        println("새로운 무기인 ${device3}입니다")
        return device3
    }
}

이 코드에서 클래스를 불러올때 이름, 머리색, 키 3개만 포함하면 위의 constructor를 부르고

이름 머리색 키 나이 성별까지 다 포함하면 아래의 constructor를 부른다.

생성자는 현시점으론 절반만 이해한 느낌.. 좀 더 반복숙달할 필요가 있다.

 

4. <객체의 활용>

 

main에서 입력할 정보를 주고 아래 class에서 불러온뒤 다시 main에서 문장을 완성하는 식

fun main() {
// 불마법사로 객체화
    var magicianOne = Character("불마법사", "red", 180.2)  <<여기서 정보를 이름, 머리색, 키 3개만 준다.
println("${magicianOne.name}의 머리색상은 ${magicianOne.hairColor}입니다") 

${magicianOne.name}<< 이런식으로 $표시 뒤 magicianOne(객체명).name(정보)
magicianOne.fireBall()

// 냉마법사로 객체화
    var magicianTwo = Character("냉마법사", "blue", 162.2, 25, "여") <<여기선 정보를 5개 준다.
println("${magicianTwo.name}의 머리색상은 ${magicianTwo.hairColor}이고 나이는 ${magicianTwo.age}입니다.")
magicianTwo.fireBall()
}
class Character {
    var name:String = ""
    var hairColor:String = ""
    var height:Double = 0.0
    var age:Int = 0
    var gender:String = ""

    // 명시적 생성자 (Constructor)
    // _name, _hairColor, _height와 같이 생성자에 변수를 넘기는 경우에 사용함
    constructor(_name:String, _hairColor:String, _height:Double) {  <<불마법사의 경우 여기에서 불러와진다.
        println("${_name}을 생성자로 넘겼어요")
        println("${_hairColor}를 생성자로 넘겼어요")
        println("${_height}를 생성자로 넘겼어요")
name = _name
hairColor = _hairColor
height = _height
    }
    // _name, _hairColor, _height, _age, _gender와 같이 생성자에 변수를 넘기는 경우에 사용함
    constructor(_name:String, _hairColor:String, _height:Double, _age:Int, _gender:String) {       

    ↑ ↑ 냉마법사의 경우 여기에서 불러와진다. 여기서 String은 문자 Double 은 소수점까지있는 숫자 Int는 숫자를 의미
        println("${_name}을 생성자로 넘겼어요")
        println("${_hairColor}를 생성자로 넘겼어요")
        println("${_height}를 생성자로 넘겼어요")
        println("${_age}를 생성자로 넘겼어요")
        println("${_gender}를 생성자로 넘겼어요")

name = _name
hairColor = _hairColor
height = _height
age = _age
gender = _gender
    }
    fun fireBall() {
        println("파이어볼!")
    }
    fun compositing(device1:String, device2:String): String {
        var device3 = device1 + device2
        println("새로운 무기인 ${device3}입니다")
        return device3
    }
}

 

이해를 돕기위해 위 코드의 결과물

불마법사을 생성자로 넘겼어요
red를 생성자로 넘겼어요
180.2를 생성자로 넘겼어요
불마법사의 머리색상은 red입니다
파이어볼!
냉마법사을 생성자로 넘겼어요
blue를 생성자로 넘겼어요
162.2를 생성자로 넘겼어요
25를 생성자로 넘겼어요
여를 생성자로 넘겼어요
냉마법사의 머리색상은 blue이고 나이는 25입니다.
파이어볼!

 

5. <상속>

 

상속이란?

클래스들을 하나의 클래스에 상속시켜서 부모클래스만 변경하는 것으로 공수를 줄일 수 있다.

공통적인 요소들이 있다면 부모/자식 클래스를 구분해서 상속관계를 만들 수 있다.

코틀린은 기본적으로 상속을 막아두었고, open 키워드를 활용해서 상속 관계를 만들 수 있다.

 

예시)

fun main() {
    var bird = Bird("새")                << 부모클래스에서 생성자를 활용하는 경우에 자식에서 객체 생성시 전달해줘야한다
    var chicken = Chicken("닭")
    var sparrow = Sparrow("참새")
    var pigeon = Pigeon("비둘기")

    bird.fly()
    chicken.fly()
    sparrow.fly()
    pigeon.fly()
}

open class Bird(name:String) {                      <<open 명령어를 입력해서 부모클래스를 만들었다.
    var name: String = ""

    init {
        // this는 현재 클래스의 상태변수를 의미합니다  <<받아오는 자식클래스에 따라 바뀐다는 의미같다.
        // var name: String = ""
        this.name = name
    }

    fun fly() {
        println("${name} 날아요~")                       <<이부분을 바꾸면 자식들의 정보도 바뀐다.
    }
}
class Chicken(name: String) : Bird(name) {    << 클래스 옆에 : 표시와 부모클래스 이름을 붙인다.
}
class Sparrow(name: String) : Bird(name) {    << 이런식으로 정보가 없는 경우도 있다.(부모클래스로 부터 받아옴)
}
class Pigeon(name: String) : Bird(name) {
}

 

6. <오버라이딩>

 

오버라이딩이란?

상속받은 부모 클래스의 정보나 메소드를 재설계한다.

주로 부모 클래스의 메소드를 재설계한다

 

예시)

fun main() {
    var bird = Bird("새")
    var chicken = Chicken("닭", 2)
    var sparrow = Sparrow("참새", "갈색")
    var pigeon = Pigeon("비둘기", "서울")

    bird.fly()
    chicken.fly()
    sparrow.fly()
    pigeon.fly()
}
open class Bird(name:String) {
    var name: String = ""

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

    open fun fly() {                                          <<여기서 상속시켜준다.
        println("${name}은 날아요~")
    }
}
class Chicken(name: String, age: Int) : Bird(name) {
    var age:Int = 0
    init {
        this.age = age
    }
    override fun fly() {                                      <<오버라이딩 명령어와 부모 클래스의 메소드를 가져와준다.
//        super객체는 부모의 객체를 의미하며 자동으로 생성됨
//        즉 부모객체의 fly메소드를 부르는 행위임
//        필요없으니 주석처리완료
//        super.fly()
        println("${age}살의 ${name}가 날아봅니다~ 꼬끼오!")      <<어떤 내용이 출력될지 입력해준다.
    }
}
class Sparrow(name: String, color: String) : Bird(name) {
    var color:String = ""
    init {
        this.color = color
    }
    override fun fly() {
//        super.fly()
        println("${color}의 ${name}이 날아봅니다~ 짹짹!")
    }
}
class Pigeon(name: String, address: String) : Bird(name) {
    var address: String = ""
    init {
        this.address = address
    }
    override fun fly() {
//        super.fly()
        println("${address} 살고있는 ${name}가 날아봅니다~ 구구!")
    }
}

 

7. <오버로딩>

 

오버로딩이란?

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

 

예시)

정수와 실수(소수) 둘다 받아 더하는 메소드가 만들어져야한다.

 

fun main() {
    var calc = Calculator()
    
    var intResult = calc.add(1,2)
    var doubleResult = calc.add(1.2, 2.2)
    
    println("정수 덧셈결과: ${intResult}")
    println("실수 덧셈결과: ${doubleResult}")    
}
class Calculator {
    fun add(num1: Int, num2: Int): Int {            <<정수를 받는 경우
        return num1+num2
    }
    fun add(num1: Double, num2: Double): Double {     <<실수(소수)를 받는 경우
        return num1+num2
    }
}

 

8. <인터페이스>

 

인터페이스란?

상속으로 닭, 참새, 비둘기와 부모 클래스인 Bird를 만들었는데 새에도 많은 종류가 있고, 고유한 행동도 다르다.

코틀린은 반드시 부모 클래스는 한개라서 모두 상속으로 처리할 수 없고 이때 인터페이스를 사용한다.

 

근본적인 공통점을 상속 받고, 추가적인 기능들은 인터페이스로 추가해준다.

 

아래의 예시처럼 메소드의 로직이 존재하지않고 이름만 존재할때 추상 메소드라고 한다.

추상메소드가 아니여도 괜찮지만 인터페이스는 추상메소드를 작성하는 습관을 가지는게 좋다.

 

예시)

interface 인터페이스이름 {
fun 메소드이름()                  <<<<요것이 추상 메소드
}

 

그리고 이는 클래스처럼 따로 인터페이스 파일을 생성할수가 있다!

 

이로서 3주차가 끝이났다.

 

오늘의 한마디 : 처음엔 졸리기도하고 힘도 들고 그랬지만 무언가를 배워나간다는 느낌이 드는게 좋다.