[Kotlin] 객체지향 프로그래밍

💡생성자, 상속, 추상, interface💡

 

---

▪️객체지향 프로그래밍

· 프로그램에서 사용되는 여러 데이터나 기능을 객체로 묶어서 관리하는 프로그래밍 기법이다.

· 매개체 하나의 정보를 관리하기 위해서는 객체 하나가 필요하며 관리하고자 하는 매개체의 수만큼 객체를 생성해야 한다.

fun main() {
    // 객체 만들기
    val obj1 = TestObject()
    val obj2 = TestObject()
    
    // obj1에는 이미 만들어논 객체가 있으므로 obj3에는 obj1의 주소값이 들어감(같은 객체)
    val obj3 = obj1
    
    // 객체의 주소값이 나옴
    println("obj1 : $obj1")
    println("obj2 : $obj2")
    println("obj3 : $obj3")
}

class TestObject

 

멤버 변수

fun main() {
    val obj = TestObject()
    
    println("num1, num2 : ${obj.num1}, ${obj.num2}")
    
    // num1은 val로 선언했기 때문에 값을 바꿀 수 없음
//  obj.num1 = 20
    obj.num2 = 200

    println("num1, num2 : ${obj.num1}, ${obj.num2}")
}

class TestObject {
    // 멤버 변수
    val num1 = 10
    var num2 = 100
}

 

멤버 메서드(함수)

fun main() {
    val obj = TestObject()

    obj.testMethod()
}

class TestObject {
    // 멤버 메서드
    fun testMethod() {
        println("testMethod 호출")
    }
}

 

 

▪️생성자

 

init

· 객체를 생성할 때 자동으로 수행될 코드를 작성하는 곳이다.

· init 코드 블록을 만들어 주면 객체 생성 시 자동으로 처리되는 코드를 만들 수 있다.

fun main() {
    val obj = TestClass()
}

class TestClass {
    init {
        println("init 코드입니다")
    }
}

 

constructor

· constructor를 이용하여 생성자를 정의할 수 있다.

· 매개 변수의 개수나 자료형을 달리하여 여러 개를 만들어 사용할 수 있다.

fun main() {
    val obj1 = TestClass()
    val obj2 = TestClass(10)
    val obj3 = TestClass(10, 20)
}

class TestClass {
    constructor() {
        println("매개 변수가 없는 생성자")
    }

    constructor(num1 : Int) {
        println("매개 변수가 한 개인 생성자")
    }

    constructor(num1 : Int, num2 : Int) {
        println("매개 변수가 두 개인 생성자")
    }
}

 

주 생성자

· 클래스명 옆에 바로 주 생성자를 만들 수도 있다.

class TestClass1 constructor(var num1 : Int, var num2 : Int)
// constructor 생략 가능
class TestClass2 (var num1 : Int, var num2 : Int)

 

보조 생성자

fun main() {
    // 매개 변수를 하나만 넣었으므로 보조 생성자를 호출
    val obj = TestClass(10)
}

class TestClass constructor(var num1 : Int, var num2 : Int) {
    // 보조 생성자
    constructor(num : Int) : this(num, 30) {
        println("보조 생성자 호출")
   }
}

 

 

▪️상속

· 클래스를 설계할 때 다른 클래스가 가지고 있는 부분을 물려받은 것을 의미한다.

· SuperClass : 상속을 해주는 클래스(부모)

· SubClass : 상속을 받는 클래스(자식)

· 부모 클래스는 open 키워드를 사용해야 하며 사용하지 않으면 자바 코드로 변경될 때 final 키워드가 붙는다.

fun main() {
    val sub = SubClass()

    println("${sub.subMember}")
    sub.subMethod()

    // 상속을 받았기때문에 부모의 멤버 변수, 메서드를 쓸 수 있음
    println("${sub.superMember}")
    sub.superMethod()
}

// 상속을 해줘야 하기 때문에 oepn을 붙여주자
open class SuperClass {
    var superMember = 100

    fun superMethod() {
        println("superMethod 호출")
    }
}

// 상속을 받을 경우 부모 클래스의 생성자를 호출해야 함
// 매개 변수가 없으므로 ()만 해줌
class SubClass : SuperClass() {
    var subMember = 100

    fun subMethod() {
        println("subMethod 호출")
    }
}

 

· 상속을 받을 경우 반드시 부모 클래스의 주 생성자를 불러줘야 한다.

// 매개 변수가 한개인 부모
// 여기서 주 생성자는 매개 변수 한개짜리
open class SuperClass(var num : Int)

// 두 가지 방법 중 편한대로 쓰면 됨
class SubClass1 : SuperClass(100)
class SubClass2 : SuperClass {
    constructor() : super(100)
}

 

 

▪️지연 초기화

 

lateinit

· var로 선언된 변수의 초기화를 뒤로 미룰 수 있다.

· 변수의 값을 사용하기 전에 반드시 초기화가 이루어져야 한다.

· val로는 선언할 수 없으며 반드시 var로 선언해야 한다.

fun main() {
    val obj = LatClass()
    obj.letMethod()
}

class LatClass {
    lateinit var str : String

    fun letMethod() {
        // ::는 리플렉션이라 부르고 해당 객체와 관련된 클래스를 파악하기 위해 사용
        // isInitialized는 초기화 된적이 있는지 확인함
        if(!::str.isInitialized) {
            str = "문자열"
            println("$str")
        }
    }
}

 

by lazy

· val로 선언된 변수는 by lazy 코드 블록을 이용하면 된다.

· 사용할 때 값을 초기화한다는 의미를 가지고 있다.

fun main() {
    val obj = BylClass()

    println("str : ${obj.str}")
}

class BylClass {
    val str by lazy {
        println("str 사용")
        "문자열"
    }
}

 

 

▪️abstract

· 추상 클래스, 추상 메서드 : 구현되지 않은 클래스와 메서드

· 추상 클래스를 통해서는 객체를 생성할 수 없다.

· 객체를 생성하려면 추상 클래스를 상속받은 클래스를 만들고 추상 메서드를 구현해야 한다.

· 추상 클래스의 목적은 자식 클래스에서 메서드를 Overriding 하게 하려는 것이다. (강제성 부여)

· 클래스명 앞에 open abstract를 붙여주면 된다.

fun main() {
    // 추상 클래스는 객체를 생성할 수 없음
    //val obj = AbsClass1()
    
    val obj = AbsClass2()
    obj.absMethod()
}

open abstract class AbsClass1 {
    open abstract fun absMethod()
}

class AbsClass2 : AbsClass1() {
    override fun absMethod() {
        println("absMethod 호출")
    }
}

 

 

▪️interface

· 객체의 주소 값을 다양한 타입의 변수에 담을 수 있도록 하고 싶다면 인터페이스를 활용하면 된다.

· 클래스는 한 개 이상의 인터페이스를 구현할 수 있다.

fun main() {
    val obj = IntClass()
    obj.inter1Method()
    obj.inter2Method()
}

interface Inter1 {
    fun inter1Method() {
        println("inter1Method1 호출")
    }
}

interface Inter2 {
    fun inter2Method() {
        println("inter2Method 호출")
    }
}

class IntClass() : Inter1, Inter2 {
    override fun inter1Method() {
        super.inter1Method()
        println("IntClass에서 inter1Method 호출")
    }

    override fun inter2Method() {
        super.inter2Method()
        println("IntClass에서 inter2Method 호출")
    }
}

 

---