04.[ 코틀린 객체지향 프로그래밍]

728x90

[04. 코틀린 객체 지향 프로그래밍]

[04-1. 클래스와 생성자]

[클래스 선언] : class 키워드로 선언

-본문 없이 선언부만 있는 클래스의 의미 : 코틀린에서는 클래스의 생성자를 선언부에 작성O

-클래스 멤버 = 생성자/변수/함수/클래스 구성

class 클래스명 {
//본문
}

[생성자 선언] : constructor 키워드로 선언한 함수

class User {
  //변수 선언  
  var name = “kkang”
  //생성자
  constructor(name:String) {
     this.name = name
  }
  //함수 
  fun someFun(){
  }
  //다른 클래스 
  class SomeClass{ }

[클래스 생성] : 클래스명 함수로 객체 생성( new 연산자 사용 X)

val user = User(“kim”) //User타입 객체 생성하여 user 변수로 참조

▷[주 생성자] : 클래스 선언부에 constructor 키워드로 선언된 생성자

-필수 X, 한 클래스에 하나만 가능

-constructor 키워드 생략 가능

-주 생성자 선언하지 않을 경우, 컴파일러가 자동으로 매개변수 없는 생성자 추가함

<주 생성자 매개변수> : 객체 생성 시, 매개변수 타입과 개수에 맞는 인자 전달하여 생성
<주 생성자의 본문> - init{ } 영역
-클래스 선언문에 주 생성자를 함께 작성하기 때문에
생성자 내부 본문을 별도로 작성하고 싶다면 init{ }을 사용하여 본문을 구현함

▷[보조 생성자] : 클래스 본문에 constructor 키워드로 선언된 생성자

-본문에 여러 개 선언 O

-객체 생성 시 자동 호출됨

▷[보조 생성자에 주 생성자 연결] : this() 로 연결

-만약 하나의 클래스 내부에 주 생성자/ 보조 생성자 모두 선언한 경우. 연결 꼭 필요

-생성자 연결 : 보조 생성자에서 주 생성자를 호출하는 방식으로 연결

class User(name: String) {  //주 생성자 : 클래스 선언과 동시에 선언

    constructor(name: String, count: Int) : this(name) { //보조 생성자 
            . . .
    }
}
fun main() {
    val user = User(“kkang” , 10)
}

▷[여러 보조 생성자끼리 연결] : this() 로 연결

-보조 생성자에서 this()로 다른 보조 생성자 호출할 수도 있다.

-다만, 이때에도 보조 생성자에 주 생성자를 연결시켜야 함

class User(name: String) {  //주 생성자 : 클래스 선언과 동시에 선언

    constructor(name: String, count: Int) : this(name) { //보조 생성자 (1) 
            . . .
    }
    constructor(name: String, count: Int, email:String) : this(name, count) {  //보조 생성자 (2)
            . . . 
   }
}

fun main() {
    val user = User(“kkang” , 10)
}

[생성자 매개변수를 클래스의 멤버 변수로 선언하는 방법]

-생성자의 매개변수는 지역변수이므로 기본적으로 다른 함수에서는 사용할 수 X

만약, 생성자 매개변수를 해당 클래스의 멤버 변수처럼 함수에서 사용하고 싶다면?

1) 클래스의 멤버 변수 선언한 뒤, init{ } 영역에서 매개변숫값을 this.키워드 사용하여

클래스의 매개변수로 대입한 뒤 -> 함수에서 자유롭게 사용

class User(name: String, count: Int) {
   //클래스 멤버 변수 선언 
   var name : String 
   var count: Int 
   //주 생성자 본문 작성 
   init{ 
      this.name = name  //객체 생성 시 받은 매개변수를 클래스의 멤버로 대입
      this.count = count
    }
   //함수에서 생성자 매개변수로 받은 값을 자유롭게 사용
   fun someFun() { 
      println(“name : $name, count: $count”)
   }
}

2) 주 생성자 매개변수를 var, val 키워드로 선언

-원래 함수는 매개변수에 var/val 키워드 사용 불가능

-주 생성자 매개변수만 var/val 키워드 사용 가능 -> 동시에 해당 클래스의 멤버 변수가 됨

class User(val name: String, val count: Int) {
     fun someFun() {
         println(“name : $name, count : $count”)
     }
}
fun main() {
    val user = User(“kkang”, 10)
    user.someFun()
}

[04-2. 상속]

[상속과 생성자] : open 키워드

-상속 : 다른 클래스를 참조하여 클래스를 선언하는 것

-코틀린의 클래스는 기본적으로 다른 클래스 상속 허용 X

-단, open 키워드 사용한 클래스는 다른 클래스에서 상속 허용 O

-하위 클래스 생성자에서 상위 클래스의 생성자를 호출해야 하므로 클래스 선언부에 super() 호출

//open키워드 상위 클래스
open class Super(name : String) {...}

//Super상속받은 Sub 하위 클래스
class Sub: Super {
constructor(name: String) : super(name) { //상위 클래스의 생성자 호출
}
}

[오버라이딩] - 재정의 override 키워드

-상위 클래스 멤버를 하위 클래스에서 사용 O

-오버라이딩 : 동일한 이름의 멤버로 사용하되, 필요한 부분 추가하여 재선언

-단, 상위 클래스의 open 키워드 붙은 멤버에 대해서만 오버라이딩 가능

open class Super { //상위 클래스 
    open var someData = 10
    open fun someFun() {
          println(“i am super class)
     }
}
class Sub: Super() { //하위 클래ᅟᅳᆺ 
     override var someData = 20
     override fun someFun() {
           pritnln(“i am sub class”)
     }
}

[접근 제한자]

-클래스의 멤버를 외부의 어느 범위까지 이용가능하게 할지 결정하는 키워드

접근제한자	최상위에서 이용	클래스 멤버에서 이용
public	모든 파일에서 가능	모든 클래스에서 가능
internal	같은 모듈 내에서 가능	같은 모듈 내에서 가능
protected	최상위에서는 사용 X	해당 클래스 + 하위 클래스에서만 접근 가능
private	파일 내부에서만 이용	클래스 내부에서만 이용

[04-3. 클래스의 종류]

*VO(value-object) 크래스 : 내부에 특별한 함수 X, 오직 데이터만 포함한 클래스

[데이터 클래스] : data 키워드로 선언

data class DataClass(val name: String, val email: String, val age: Int)

-자주 사용하는 데이터를 객체로 묶어서 선언함

-주 새성자의 val, var 키워드로 매개변수 선언하여 해당 클래스의 멤버 변수로 활용

▷[비교 : equals() 함수]

- 주 생성자에 선언한 멤버변수의 데이터에 대해서만 비교 대상으로 삼음

-객체 비교 : 일반 클래스의 객체에 대해 equals() 함수 사용
: 두 객체가 동일 타입인지 비교
-객체 내부 데이터 비교 : 데이터 클래스의 객체에 대해 equals() 함수 사용
: 두 객체의 주 생성자에 선언한 해당 멤버 변수 값이 같은지 비교

▷[객체 데이터 반환 : toString() 함수]

-주 생성자의 매개변수에 선언된 데이터만 출력 대상

-해당 객체가 가지는 값을 확인하고 싶을 때 사용

일반 클래스의 toString() : 의미 없는 데이터 출력
데이터 클래스의 toString() : 객체가 포함하는 멤버 변수의 데이터를 출력

[오브젝트 클래스] : 익명 클래스 object 키워드 사용

-이름이 없으므로 -> 클래스 선언과 동시에 객체 생성.

-단, object 클래스 선언 시 타입 명시하지 않으면 기본 최상위 타입 Any 객체 취급

-상위 클래스를 상속받은 타입
-인터페이스 구현한 타입

-따라서 오브젝트 클래스의 타입도 보통 :(콜론) 뒤에 명시

open class Super{ // 상위 클래스 
     open var data = 10
     open fun some() {
           println(“i am super some();”)
     }
}
val obj = object: Super() { //상위 클래스 상속받은 오브젝트 클래ᅟᅳᆺ 
    override var data = 20
    oberride fun some() {
          println(“o am object some() ” )
    }
}
fun main() {     obj.data = 30 
     obj.some()
}

[캠패니언 클래스] : companion 키워드로 클래스 선언

- static 느낌. 클래스 이름으로 직접 멤버 접근 O

-객체 생성 없이도 클래스의 이름으로 특정 멤버에 접근하여 사용이 가능

-클래스 내부에 xompanion object{ } 형태로 선언

-> 이 클래스 감싸는 위 클래스로 해당 멤버에 접근 가능하게 됨

class MyClass{
   companion object {
       var data =10
       fun some() {
            println(data)
       }
     }
}
fun main() {
     MyClass.data= 20
     MyClass.some()
}

[참고] : Do It 안드로이드 앱 프로그래밍 with 코틀린