본문 바로가기
카테고리 없음

Kotlin 문법 총정리

지영영영 2025. 5. 2. 17:28

코틀린 메인 함수

  • fun 이용
  • ; 사용 안함
fun main(){
	print("Hello World")
    println("Hello World")
}

 

코틀린 변수

  • 자동으로 타입을 추론해 설정하기 때문에 타입 지정 필수 아님
  • 하지만 : 타입 을 이용해 타입 지정 가능
fun main(){
	var i : Int = 10
    var name : String = "지영"
    var point : Double = 3.3
}

 

var 와 val 의 차이점

  • var : 재선언(수정 가능)
  • val : 재선언(수정 불가능)
var i : Int = 10
i = 20 //가능

val i2 : Int = 20
i2 = 30 //불가능

 

톱레벨 const

const val num = 20
fun main(){
	...
}

 

형변환

var i = 10
var l = 20L //Long
var name = "지영"
i = name.toInt() //name을 string -> int
l = i.toLong() //i를 int -> long
i = l.toInt() //l을 long -> int

 

String

fun main(){
	var name = "지영"
    print("제 이름은" + name + "입니다")
    print("제 이름은 $name 입니다") //괄호 없으니 띄어쓰기
    print("제 이름은 ${name}입니다") //괄호 있으니 띄어쓰기 없어도 괜찮음
}

 

max, min (최대 / 최소)

fun main(){
	var i = 10
    var j = 20
    print(max(i, j))
    print(min(i, j))
}

 

random

fun main(){
	val randomNumber = Random.nextInt() // 랜덤한 숫자
    print(randomNumber)
    
    val randomNumber1 = Random.nextInt(0, 100) // 0 ~ 99까지의 랜덤한 숫자
    print(randomNumber1)
    
	val randomNumber2 = Random.nextInt(0.0, 1.0) // 0.0 ~ 0.9까지의 랜덤한 숫자
    print(randomNumber2)
}

 

입력

fun main(){
	val reader = Scanner(System.`in`)
    reader.nextInt() //int 입력받는
    reader.next() //string 입력받는
}

 

조건문

fun main(){
	var i = 5
    
    var result = if(i > 10){
    	"10보다 크다"
    }else if(i > 5){
    	"5보다 크다"
    }else{
    	"5보다 작다"
    }
    print(result)
    
    val result = if(i>10) true else false
    
    //Alt + Enter를 이용해 when으로도 변경 가능
}

 

반복문

fun main(){
	val items = listOf(1,2,3,4,5)
    
    //for(int i = 0; i<items.length; i++)
    for(i in 0..3){
    	print(i)
    }
    
    for(i in 0..(items.size-1)){
    	print(items[i])
    }
}

 

List (리스트)

fun main(){
	val items = mutableListOf(1,2,3,4,5) //타입 자동추론으로 <타입> 안해도 된다
    
    items.add(6)
    items.remove(3)
}

 

Array

fun main(){
	val items = listOf(1,2,3)
    
    //예외처리
    try{
    	val item = items[4]
    } catch (e: Exception){
    	print(e.message)
    }
    
}

 

Null 타입지정

fun main(){
	//null을 넣으려면 타입옆에 ? 붙여야한다
	var name: String? = null
    name = "준석"
    
    var name2: String = ""
    
    name?.let{ //name이 null이 아니라면
    	name2 = name
    }
}

 

함수

fun main() {
    print(sum(10, 20))
    print(sum(b = 10, a = 20)) //a,b 순서 안맞춰도 에러 안남
}

//int a, b의 합을 int로 반환하는 함수
fun sum(a: Int, b: Int) : Int{
    return a + b
}

//코틀린 내용이 한줄이라면
//fun sum(a: Int, b: Int) : Int = a + b 로 가능
//fun sum(a: Int, b: Int) = a + b 로 가능 (리턴 타입 생략 가능)

fun sum(a: Int, b: Int, c: Int = 0) = a + b + c
//c에 디폴트값이 있다면 print(sum(10, 20)) 해도 가능

 

class

fun main() {
   val jiyoung = Person("jiyoung", 19)
    print(jiyoung.name)
    print(jiyoung.age)

    jiyoung.age = 23 //var로 수정 가능
    //class의 val와 var를 이용해 getter, setter 기능 가능

}

//코틀린의 기본 생성자를 괄호 안에 작성
//Alt + Enter로 put ~ 를 이용해 깔끔히 정리
class Person(
    val name: String,
    var age: Int
){

}

 

data class

fun main() {
   val jiyoung = Person("jiyoung", 19)
    print(jiyoung.name) //private으로 getter도 불가 (에러)
    print(jiyoung.age)

    jiyoung.age = 23 //var로 수정 가능
    
//코틀린의 기본 생성자를 괄호 안에 작성
//Alt + Enter로 put ~ 를 이용해 깔끔히 정리
class Person(
    private val name: String, //getter, setter 모두 불가 (기본값은 public)
    var age: Int
){

 

data class (getter, setter) 

fun main() {
    val jiyoung = Person("jiyoung", 19)
    val jiyoung2 = Person("jiyoung", 19)


    println(jiyoung) // 해시코드 : @6b143ee9
    println(jiyoung2) // 해시코드 : @1936f0f5
    print(jiyoung == jiyoung2) //F로 나옴 (다른사람이니)
    jiyoung.hobby = "sing" //여기서도 바꿀 수 있다
}
//data : 재정의 (data class). 이름과 나이가 같으니 같은 사람으로 값이 나온다
data class Person(
    private val name: String,


    var age: Int
){
    var hobby = "축구"

    //더 무언가를 하고 싶다면 (실행할때마다 init안의 코드가 실행된다)
    init{
        println("init");
    }

    //생성자안에 별도의 프롬프트가 있다면
    fun some(){
        hobby = "농구"
    }
}

 

getter, setter 재정의(제어) 

fun main() {
    val jiyoung = Person("jiyoung", 19)
    val jiyoung2 = Person("jiyoung", 19)

    println(jiyoung) // 해시코드 : @6b143ee9
    println(jiyoung2) // 해시코드 : @1936f0f5
    print(jiyoung == jiyoung2) //F로 나옴 (다른사람이니)

}
//data : 재정의 (data class). 이름과 나이가 같으니 같은 사람으로 값이 나온다
data class Person(
    private val name: String,
    var age: Int
){
    var hobby = "축구"
        private set //이렇게 붙이면 외부(fun main)에서 수정 못함
        get() = "취미 : $field" //getter 재정의

    //더 무언가를 하고 싶다면 (실행할때마다 init안의 코드가 실행된다)
    init{

 

상속

open class Person

fun main() {

}
class SuperMan : Person()

abstract class Animal{
    open fun move(){ //open을 해야 상속하고 Dog, Cat에서 오버라이드가 가능
        print("이동")
    }
}
class Dog : Animal(){
    override fun move(){
        print("껑충")
    }
}
class Cat : Animal(){
    override fun move(){
        print("살금")
    }
}

 

인터페이스(interface) 

open class Person

fun main() {

}

interface Drawable{
    fun draw()
}

class SuperMan : Person()

abstract class Animal{
    open fun move(){ //open을 해야 상속하고 Dog, Cat에서 오버라이드가 가능
        print("이동")
    }
}
class Dog : Animal(), Drawable{ //인터페이스 적용 방법 (, Drawable)
    override fun move(){
        print("껑충")
    }

    override fun draw() {
        TODO("Not yet implemented")
    }

}
class Cat : Animal(), Drawable{
    override fun move(){
        print("살금")
    }

    override fun draw() {
        TODO("Not yet implemented")
    }
}

 

타입체크(is)

open class Person

fun main() {
    val dog: Animal = Dog()
    val cat = Cat()

    //타입체크(is)
    if(dog is Dog){ //T
        println("멍멍이")
    }

    if(dog is Cat){ //F
        println("멍멍이")
    }

}

interface Drawable{
    fun draw()
}

class SuperMan : Person()

abstract class Animal{
    open fun move(){ //open을 해야 상속하고 Dog, Cat에서 오버라이드가 가능
        print("이동")
    }
}
class Dog : Animal(), Drawable{ //인터페이스 적용 방법 (, Drawable)
    override fun move(){
        print("껑충")
    }

    override fun draw() {
        TODO("Not yet implemented")
    }

}
class Cat : Animal(), Drawable{
    override fun move(){
        print("살금")
    }

    override fun draw() {
        TODO("Not yet implemented")
    }

 

제네릭

fun main() {
    val box = Box(10)
    val box2 = Box("dfdfd")
    print(box.value)
}
//제네릭(프로그래밍에서 타입 파라미터를 사용하여 코드를 일반화하고 재사용성을 높이는 방법)
class Box<T>(var value: T){

}

 

callBack함수 (람다식)

// 람다식
fun main() {
    myFunc(10) { //전달하는게 하나라면 myFunc(){}에서 ()생략 가능
        println("함수 호출")
    }

}
//함수는 input, output 정의하기


//input, output 아무것도 없다면
fun myFunc(a: Int, callBack : () -> Unit){
    println("함수시작")
    callBack() //함수호출
    println("함수끝")
}

 

코루틴

// 람다식
fun main() {
    lifecycleScope.launch{
        myFunc(10) {
            println("함수 호출")
        }
    }
}


suspend fun myFunce(a: Int, callBack: () -> Unit = {}){

    println("함수시작")
    callBack()
    println("함수끝")
}
dependencies {
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.5.0")
}

 

티스토리툴바