[Kotlin] 기초문법 #02

클래스의 기본구조

 

클래스: 값과 그 값을 사용하는 기능을 묶어놓은 것 -> 인스턴스를 만드는 틀

인스턴스: 클래스를 이용하여 만들어내는 서로 다른 속성의 객체를 지칭

fun main(){
	//2개의 Person인스턴스
    var a = Person("홍길동", 1999)
    var b = Person("김길동", 1980)
    
    //ex1)
    println("안녕하세요, ${a.birth}년생 ${a.name}입니다")
    
    //ex2)
    a.introduce()
}

//ex1)
class Person(var name: String, val birth: Int)

//ex2)
class Person(var name: String, val birth: Int){
	fun introduce(){
    	println("안녕하세요, ${birth}년생 ${name}입니다")
    }
}

 

클래스 생성자

 

생성자는 인스턴스의 속성을 초기화하는 기능뿐 아니라 인스턴스 생성 시 필요한 구문을 수행

init함수 : 파라미터나 반환형이 없는 특수한 함수, 생성자를 통해 인스턴스가 만들어질때 호출되는 함수

class Person(var name:String, val birth:Int){
	init{
    	println("${this.birth}년생 ${this.name}님이 생성")	//this:인스턴스 자신
    }
}

 

기본생성자 : 클래스를 만들 때 기본

보조생성자 : 필요에 따라 추가적으로 선언

fun main(){
    var d = Person("짱구")
    var e = Person("훈이")
}

class Person(var name:String, val birth:Int){
	init{
    	println("${this.birth}년생 ${this.name}님이 생성")	//this:인스턴스 자신
    }
    
    //보조생성자를 만들 때는 기본생성자를 통해 속성을 반드시 초기화
    constructor(name:String):this(name, 1996){
    	println("보조생성자 사용")
    }
}

 

 

상속

 

상속의 쓰임 2가지

1. 이미 존재하는 클래스를 확장하여 새로운 속성/ 함수를 추가한 클래스를 만들 때

2. 여러 개의 클래스를 만들었는데 클래스들의 공통점을 뽑아 코드관리를 쉽게할 때

 

open : 클래스 상속시, 상속될 수 있도록 클래스 선언할 때 붙여주는 키워드

open class Animal(var name: String, var age:Int, var type:String){
	fun introduce(){
    	println("저는 ${type} ${name}이고, ${age}살 입니다")
    }
}

 

상속 규칙 2가지

1. 서브클래스는 수퍼클래스에 존재하는 속성과 같은 이름의 속성을 가질 수 없다.

2. 서브클래스가 생성될 때에는 반드시 수퍼클래스의 생성자까지 호출해야 한다.

 

서브클래스 파라미터 값에 var를 붙이면 Dog클래스 자체의 속성이 됨

class Dog(name:String, age:Int) : Animal(name, age, "강아지"){
	fun bark(){ println("멍멍") }
}

fun main(){
	var a = Animal("백구", 5, "강아지")
    var b = Animal("백구", 5)
    a.introduce()	// b.introduce() 와 동일
    b.bark()		//멍멍
}

 

 

오버라이딩과 추상화

 

오버라이딩(overriding) : 서브클래스에서 같은 이름과 형태로 된 함수의 내용을 다시 구현 가능

-> 이미 수퍼클래스에서 구현이 끝난 함수를 오버라이딩을 통해 재구현하는 경우

open class Animal{
	open fun eat(){ println("음식 먹음") }
}

class Tiger: Animal(){
	override fun eat(){ println("고기먹음") }
}

fun main(){
	var t = Tiger()
	t.eat()	//고기먹음
}

 

추상화: 선언부만 있고 기능이 구현되지 않은 추상함수/추상클래스로 구성됨

-> 함수의 구체적 구현이 아닌 Animal의 서브클래스에는 eat이라는 함수가 반드시 있어야 함을 명시(각 서브클래스가 필요에 따라 구현)

abstract class Animal{
	abstract fun eat()
    fun sniff(){ println("킁킁") }
}

class Rabbit : Animal(){	//Animal상속
	override fun eat(){ println("당근 먹음") }
}

fun main(){
    var r = Rabbit()
    r.eat()	//당근 먹음
    r.sniff()	//킁킁
}

 

인터페이스 :

자바) 추상함수로만 이루어져 있는 순수 추상화 기능

코틀린) 추상함수, 일반함수, 속성을 모두 가질 수 있음

한번에 여러 인터페이스 상속 가능

interface Runner{
	fun run()
}

interface Eater{
	fun eat(){ println("음식먹음") }
}

class Dog : Runner, Eater{
    override fun run(){ println("호다닥") }
    override fun eat(){ println("사료먹음") }
}

fun main(){
	var d = Dog()
    d.run()	//호다닥
    d.eat() //사료먹음
}

인터페이스 구현 시 별도의 키워드 없어도 포함된 모든 함수를 서브클래스에서 구현,재정의가 가능하다.

구현부가 있는 함수: open함수로 간주

구현부가 없는 함수: abstract함수로 간주

 

 

오버라이딩 : 이미 구현이 끝난 함수의 기능을 서브클래스에서 변경해야 할 때

추상화 : 형식만 선언하고 실제 구현을 서브클래스에서 일임할 때

인터페이스 : 서로 다른 기능들을 여러개 물려줄 때 유용