[앱 스쿨 2기 : Android] 4주차 2023.05.16 (Kotlin)

hxeyexn·2023년 5월 16일
0
post-thumbnail

📅 2023.05.16

📂Kotiln21_OverridingEx1 ~ 📂Kotlin26_InterfaceEx1

Any 클래스

Kotlin에서 사용하는 모든 클래스의 부모 클래스

  • 클래스를 정의할 때 상속 받지 않으면 자동으로 Any 클래스를 상속받음
  • 모든 객체들은 Any 타입 변수에 담을 수 있음
  • 자바의 Object와 같은 기능
fun main() {

	var a1: Any = TestClass1()
    var a2: Any = TestClass2()    
}

class TestClass1
class TestClass2

Any 클래스가 제공하는 메서드 overriding

  • toString : 객체의 정보 문자열을 반환하기 위해 만드는 메서드
  • toString 메서드를 호출하고 이 메서드가 반환하는 문자열을 이용해 출력하게 됨
fun main() {
	val t1 = TestClass(100, 200)
    println(t1)
}

class TestClass (var a1: Int, var a2: Int) {
	override fun toString(): String {

        
    }
}

📂Kotlin22_Any


this와 super

this

  • 객체 자기 자신을 지칭
  • 멤버 변수와 메서드 내부의 변수를 구분할 때 사용
class TestClass {
    private var num: Int = 0

    fun setNum(num: Int) {
        this.num = num // 멤버 변수에 접근하기 위해 this 키워드 사용
    }

    fun printNum() {
        println("My variable: $num") // 멤버 변수에 직접 접근
    }
}

fun main() {
    val obj = TestClass()
    obj.setNum(10)
    obj.printNum()
}
  • 멤버 메서드와 메서드 내부의 메서드를 구분할 때 사용
fun main() {
    val obj = TestClass()
    obj.testMethod()
}

class TestClass {
    fun testMethod() {
        println("testMethod")
        this.internalMethod() // 메서드 내부의 메서드 호출
    }

    private fun internalMethod() {
        println("internalMethod")
    }
}
  • 생성자에서 다른 생성자를 호출할 때 사용
fun main() {
    val obj1 = TestClass("John", 25)
    val obj2 = TestClass("Alice")
}

class TestClass(val name: String, val age: Int) {

    constructor(name: String) : this(name, 0) {
        println("Secondary constructor: name=$name")
    }

    init {
        println("Primary constructor: name=$name, age=$age")
    }
}
➡️ Primary constructor: name=John, age=25
   Primary constructor: name=Alice, age=0
   Secondary constructor: name=Alice

super

  • 부모 영역을 지칭
  • 멤버 변수와 상속받은 멤버 변수를 구분할 때 사용
fun main() {
	val obj = SubClass()
    obj.printNum()
}

open class SuperClass {
	open val num: Int = 5
}

class SubClass : SuperClass() {
	override val num: Int = 10
    
    fun printNum() {
    	println("SubClass - num : $num")
        println("SuperClass - num : ${super.num}")
    }
}
  • overriding한 메서드와 부모의 메서드를 구분할 때 사용
fun main() {
	val obj = SubClass()
    obj.testMethod()
}

open class SuperClass {
	open fun testMethod() {
    	println("SuperClass - testMethod")
    }
}

class SubClass : SuperClass() {
	override fun testMethod() {
    	super.testMethod()	// 부모 클래스의 메서드 호출
        println("SubClass - testMethod")
    }
}
➡️ SuperClass - testMethod
   SubClass - testMethod
  • 부모의 생성자를 호출할 때 사용
fun main() {
	val obj = SubClass("John", 25)
    obj.printName()
}
open class SuperClass(val name: String) {
	open fun printName() {
    	println("SuperClass - Name : $name")
    }
}

class SubClass(name: String, val age: Int): SuperClass(name) {
	override fun printName() {
    	super.printName()	// 부모 클래스의 메서드 호출
        println("SubClass - Age : $age")
    }
}
➡️ SuperClass - Name: John
   SubClass - Age: 25

추상 클래스

추상 클래스 : 추상 메서드를 가지고 있는 클래스
추상 메서드 : 구현되지 않은 메서드

추상 클래스와 추상 메서드

  • 추상 클래스는 완벽한 클래스가 아님 → 객체를 생성할 수 없음
  • 추상 클래스를 상속받은 클래스를 만들고 추상 메서드를 오버라이딩하여 사용
  • abstract와 상속을 위해 open키워드 사용
  • 추상 클래스는 메서드 오버라이딩에 대한 강제성을 주기 위한 수단
fun main() {
	val t2 = TestClass2()
    t2.testMethod()
    
    val t3: TestClass1 = TestClass2()
    t3.testMethod()
}

// 추상 클래스
open abstract class TestClass1 {

	// 추상 메서드
    open abstract fun testMethod()
}

// 추상 클래스를 상속 받은 클래스
class TestClass2 : TestClass1() {
	override fun testMethod() {
    	println("TestClass2의 testMethod")
    }
}
➡️ TestClass2의 testMethod
   TestClass2의 testMethod

📂Kotlint23_Abstract


인터페이스

인터페이스를 사용하여 다양한 참조변수에 담을 수 있는 클래스를 만들 수 있음

  • Kotlin은 다중 상속 지원 X → 자기 타입의 변수나 부모형 타입 변수에만 담을 수 있음
  • 생성된 객체의 주소 값을 다양한 타입에 변수에 담을 수 있도록 한다면 인터페이스를 활용하면 됨
  • 인터페이스는 클래스가 아니므로 객체를 생성할 때 사용할 수 없음
  • 단, 클래스는 한 개 이상의 인터페이스를 구현할 수 있으며 생성된 객체는 구현한 인터페이스형 참조 변수에 담을 수 있음
  • 인터페이스에는 추상 메서드와 일반 메서드 모두를 구현해서 사용할 수 있음
  • 인터페이스는 추상 클래스와 목적이 비슷하지만 하나의 클래스에 여러 인터페이스를 구현할 수 있는 장점을 가지고 있음, 추상 클래스는 하나당 하나의 클래스를 만들어야 함
fun main() {
	val t1 = TestClass()
    t1.interfaceMethod1()
    t1.interfaceMethod2()
    t1.interfaceMethod3()
    
    testFunction1(t1)
    testFunction2(t1)
}

fun testFunction1(t100: Inter1) {
	t100.interfaceMethod1()
}

fun testFunction2(t200: Inter2) {
	t200.interfaceMethod2()
}

interface Inter1 {
	fun interfaceMethod1()
}

interface Inter2 {
	fun interfaceMethod2() 
}

interface Inter3 {
	fun interfaceMethod3()
}

// 인터페이스를 정의한 클래스
class TestClass : Inter1, Inter2, Inter3 {
	override fun interfaceMethod1() {
    	println("interfaceMetho1")
    }
    
    override fun interfaceMethod2() {
    	println("interfaceMetho2")
    }
    
    override fun interfaceMethod3() {
    	println("interfaceMethod3")
    }
}

📂Kotlin25_Interface


profile
Android Developer

0개의 댓글