안드로이드 앱 개발

//시작함수
fun main(){


}//main 함수 종료...

//어떤 그룹의 크루원 정보 저장 클래스 
class Crew{
    
    //property [ 이름, 나이, 주소 ]
    var name:String?= null
    var age:Int?= null
    var address:String?= null

    //method - property 출력 기능
    fun show(){
        println("$name : $age , $address")
    }
}

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()

}//main 함수 종료...

//어떤 그룹의 크루원 정보 저장 클래스 
class Crew{
    
    //property [ 이름, 나이, 주소 ]
    var name:String?= null
    var age:Int?= null
    var address:String?= null

    //method - property 출력 기능
    fun show(){
        println("$name : $age , $address")
    }
}

//**출력**
sam : 20 , seoul

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()
    
    //스코프 함수로 멤버 여러개 사용해보기
    var crew2= Crew()
    crew2.apply {
        //이 apply{} 영역 안에서는 this가 crew2를 의미함. 또한 this는 생략이 가능함
        this.name= "robin"
        age= 25
        address="busan"
        show()
    }

}//main 함수 종료...

// 원래는 이런식으로 객체생성후 apply 라는 이름의 함수를 추가하는 것임( 일종의 확장함수 ) -- 이를 람다식처럼 줄여서 ()를 생략한 문법임
crew2.apply(){
}

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()
    
    //스코프 함수로 멤버 여러개 사용해보기
    var crew2= Crew()
    crew2.apply {
        //이 apply{} 영역 안에서는 this가 crew2를 의미함. 또한 this는 생략이 가능함
        this.name= "robin"
        age= 25
        address="busan"
        show()
    }
    
    //영역안에서 it을 사용하는 스코프 함수
    val crew3= Crew()
    crew3.also {
        // also{} 영역 안에서는 it이 crew3을 의미함. it은 생략 불가
        it.name= "hong"
        it.age= 30
        it.address="paris"
        it.show()
    }

}//main 함수 종료...

// 1.1) apply - 본인객체를 return
val crew4:Crew= Crew()
val crew5:Crew= crew4.apply {
    name="kim"   //this. 키워드 생략 가능
    age= 40
    address="newyork"
    //별도의 리턴 명시가 없지만 무조건 return this 인것임
}
crew5.show()

// 1.2) run - 마지막 실행문이 return 값
val crew6:Crew= Crew()
val len= crew6.run {
    name="park"
    age= 45
    address="tokyo"
    name?.length //마지막 실행문이 리턴값  - 글자수 4 리턴됨
}
println("이름의 글자수 : $len")

//2.1) also - it 키워드를 사용하며 본인객체를 return
val crew7:Crew= Crew()
val crew8:Crew= crew7.also {
    it.name="lee"
    it.age= 50
    it.address="incheon"
    //별도의 리턴 명시가 없지만 무조건 return this 인것임
}
crew8.show()

//2.2) let - it 키워드를 사용하며 마지막 실행문이 return 값
val crew9:Crew= Crew()
val n:String?= crew9.let {
    it.name="choi"
    it.age=20
    it.address="LA"
    it.name?.uppercase()  //마지막 실행문의 결과가 리턴   -- 이름을 대문자로 변경한 결과값 "CHOI" 리턴됨
}
println("이름의 대문자 출력 : $n")

//** scope function 중 run과 비슷한 동작을 하는 with가 있음. 사용문법이 약간 다름.... **
val crew10:Crew= Crew()
with(crew10){      //범위 안에 객체를 파라미터로 전달받는 형태
    name="aaa"
    age=20
    address="HANOI"
    show()
    name?.lowercase()  //리턴값을 마지막 실행문의 결과
}

val builder:AlertDialog.Builder= AlertDialog.Builder(this)
builder.setTitle("aaa")
builder.setMessage("bbbb")
builder.setPositiveButton("OK", null)
builder.setNegativeButton("CANCEL", null)
val dialog=builder.create()
dialog.show()

val builder2:AlertDialog.Builder= AlertDialog.Builder(this)
val dialog2= builder2.run{
    setTitle("sss")
    setMessage("asdfasdfa")
    setPositiveButton("확인", null)
    setNegativeButton("취소", null)
    create()      // 빌더가 생성하는 dialog 객체가 리턴됨
}
dialog2.show()

var s1:String  = null //ERROR - non nullable 변수

var s2:String? = null //OK  - nullable 변수

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type

}

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용

}

//**출력**
글자수 : 5

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용
    
    //nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력시도하기
    println("글자수 : " + str2.length)  // ERROR :  String? 타입은 null 일 수도 있다는 것이기에 . 연산자가 언제나 안전하게 멤버를 가져올 수 있다고 확신할 수 없음 - 실제 null 이 아니어도 사용불가 [ 객체가 없을때 NullPointException 발생 ]

}

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용
    
    //nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력시도하기
    //println("글자수 : " + str2.length)  // ERROR :  String? 타입은 null 일 수도 있다는 것이기에 . 연산자가 언제나 안전하게 멤버를 가져올 수 있다고 확신할 수 없음 - 실제 null 이 아니어도 사용불가 [ 객체가 없을때 NullPointException 발생 ]
    
    //해결방법 - null인지 확인하는 if문 코드 필요
    if(str2!=null) println("글자수 : " + str2.length) //if문이 참일때만 실행되는 영역이어서 String?도 사용가능함.

}

//**출력**
글자수 : 5
글자수 : 4

println("글자수 : " + str2?.length)  // null이 아니면 멤버에 접근, null이면 그냥 null 을 결과로 줌

//**출력**
글자수 : 4

str2= null;
println("글자수 : " + str2?.length)  // null 출력

//**출력**
글자수 : null

val len= if(str2!=null) str2.length else -1
println(len)

//**출력**
-1

val len2= str2?.length ?: -1   // ?: 연산자 뒤에 null일때 원하는 값을 지정
println(len2)

//**출력**
-1

var ss:String?= "Hello"
//println( ss.length )  //ERROR - String? 타입은 NPE 발생이 안되도록 문법적으로 못쓰도록 하고 있음
println( "글자수 : " + ss!!.length  )

//**출력**
글자수 : 5

//null참조객체
val sss:String?= null
println( "글자수 : " + sss!!.length  ) //Exception -- 실행 중 예외발생

//**출력**
Exception in thread "main" java.lang.NullPointerException

//시작 함수..
fun main(){

}// main() 함수 종료..

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    //val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
    //억지로 as 연산자를 통해 형변환
    val zzz:ZZZ = mmm as ZZZ  //문법적으로는 error가 없지만 Class cast Exception 발생함!
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    //val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
    //억지로 as 연산자를 통해 형변환
    //val zzz:ZZZ = mmm as ZZZ  //문법적으로는 error가 없지만 Class cast Exception 발생함!
    
    //이때 혹시 잘못된 casting을 해도 예외로 인해 앱이 다운되지 않고 그냥 null을 리턴하는 안전한 캐스팅 연산자 as?
    val zzz:ZZZ? = mmm as? ZZZ?
    println(zzz) // null출력   - 객체가 실제로 캐스팅이 되었다면 [클래스명@해시코드] 가 출력됨
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

//시작 함수
fun main(){

}//main 함수 종료..

//1. 클래스안에 inner 클래스만들기
class AAA{
    var a:Int=0

    fun show(){
        println("AAA클래스이 show")
        println()
    }

    //이너클래스 [ 자바와 다르게 inner키워드가 없으면 아웃터클래스의 멤버를 마음대로 사용할 수 없음 ] ////////////////
    inner class BBB{

        fun show(){
            println("BBB 클래스의 show") 
        }
    }
    /////////////////////////////////////////////////////////////////////////////////////////////////////
}

//시작 함수
fun main(){

    //1. 이너클래스
    val bbb: BBB       //ERROR - BBB 이너클래스를 인식하지 못함
    val bbb: AAA.BBB   //OK - 아웃터 클래스명 AAA를 통해 인식 가능

}//main 함수 종료..

//시작 함수
fun main(){

    //1. 이너클래스
    //val bbb: BBB               //ERROR - BBB 이너클래스를 인식하지 못함
    //val bbb: AAA.BBB           //OK - 아웃터 클래스명 AAA를 통해 인식 가능
    val bbb: AAA.BBB = AAA.BBB() //ERROR - 아웃터 클래스 밖에서는 객체 생성 불가

}//main 함수 종료..

//시작 함수
fun main(){

    //1. 이너클래스
    //val bbb: BBB                 //ERROR - BBB 이너클래스를 인식하지 못함
    //val bbb: AAA.BBB             //OK - 아웃터 클래스명 AAA를 통해 인식 가능
    //val bbb: AAA.BBB = AAA.BBB() //ERROR - 아웃터 클래스 밖에서는 객체 생성 불가
    
    val obj: AAA = AAA() // 아웃터 객체 생성
    val obj2: AAA.BBB = obj.getBBBInstance()  //이너클래스 객체를 생성하여 리턴해주는 메소드 이용
    obj2.show()

}//main 함수 종료..

//1. 클래스안에 inner 클래스만들기
class AAA{
    var a:Int=0

    fun show(){
        println("AAA클래스이 show")
        println()
    }

    // BBB 이너클래스를 객체로 생성하여 리턴해주는 메소드
    fun getBBBInstance() : BBB{
        return BBB()
    }

    //이너클래스 [ 자바와 다르게 inner키워드가 없으면 아웃터클래스의 멤버를 마음대로 사용할 수 없음 ] ////////////////
    inner class BBB{

        fun show(){
            println("BBB 클래스의 show") 
        }
    }
    /////////////////////////////////////////////////////////////////////////////////////////////////////
}

//**출력**
BBB 클래스의 show

//시작 함수
fun main(){

    //1. 이너클래스
    //val bbb: BBB                 //ERROR - BBB 이너클래스를 인식하지 못함
    //val bbb: AAA.BBB             //OK - 아웃터 클래스명 AAA를 통해 인식 가능
    //val bbb: AAA.BBB = AAA.BBB() //ERROR - 아웃터 클래스 밖에서는 객체 생성 불가
    
    val obj: AAA = AAA() // 아웃터 객체 생성
    val obj2: AAA.BBB = obj.getBBBInstance()  //이너클래스 객체를 생성하여 리턴해주는 메소드 이용
    obj2.show()

}//main 함수 종료..

//1. 클래스안에 inner 클래스만들기
class AAA{
    var a:Int=0

    fun show(){
        println("AAA클래스이 show")
        println()
    }

    // BBB 이너클래스를 객체로 생성하여 리턴해주는 메소드
    fun getBBBInstance() : BBB{
        return BBB()
    }

    //이너클래스 [ 자바와 다르게 inner키워드가 없으면 아웃터클래스의 멤버를 마음대로 사용할 수 없음 ] ////////////////
    inner class BBB{

        fun show(){
            println( "부모클래스의 프로퍼티 a : $a ") //부모의 멤버를 마음대로

            //아웃터 클래스의 this사용법이 Java와 다름!! [ this@부모클래스명 ]
            //아웃터클래스의 show를 호출하고 싶다면..
            this@AAA.show();
        }
    }
    /////////////////////////////////////////////////////////////////////////////////////////////////////
}

//**출력**
부모클래스의 프로퍼티 a : 10
AAA클래스이 show

// 인터페이스는 특별할 것 없음
interface Clickable{
    //추상메소드
    fun onClick()
}

//시작 함수
fun main(){

    //2. 인터페이스
    val c= Clickable() //ERROR :인터페이스는 곧바로 생성(new)할 수 없어서..

}//main 함수 종료..

//2. 인터페이스는 특별할 것 없음
interface Clickable{
    //추상메소드
    fun onClick()
}

//시작 함수
fun main(){

    //2. 인터페이스
    //val c= Clickable() //ERROR :인터페이스는 곧바로 생성(new)할 수 없어서..
    
    //clickable을 구현한 Test클래스 객체 생성
    val t= Test()
    t.onClick()

}//main 함수 종료..

//2. 인터페이스는 특별할 것 없음
interface Clickable{
    //추상메소드
    fun onClick()
}

//인터페이스를 구현하는 클래스 [ 클래스 상속과 문법적으로 표현법이 비슷해보이지만 주생성자 호출()문이 없음 :  (다중 구현할때는 , 를 사용) ]
class Test : Clickable{

    //추상메소드 구현  - 기능구현도 이미 Clickable에 있는 함수명과 같은 함수를 만드는 만큼 override 키워드 필요
    override fun onClick() {
        println("click!!!!")
        println()
    }
}


//**출력**
click!!!!

//시작 함수
fun main(){

    //2. 인터페이스
    //val c= Clickable() //ERROR :인터페이스는 곧바로 생성(new)할 수 없어서..
    
    //3. 익명클래스 [ Java와 문법이 많이 다름 : object키워드를 사용해야만 함 ]
    val a= object : Clickable{ //[ ()없는 것 주의!!!] -- Clickable 인터페이스 구현
        override fun onClick() {
            println("Anonymous class onClick!!!!!")
            println()
        }
    }
    a.onClick()

}//main 함수 종료..

//2. 인터페이스는 특별할 것 없음
interface Clickable{
    //추상메소드
    fun onClick()
}


//**출력**
Anonymous class onClick!!!!!

public class Hello{
    public static void main(String[] args){
    
        System.out.println("인스턴스 변수 a : " + a);  //ERROR - a 변수 인식안됨, 또한 Sample 객체를 생성해야만 사용가능
        System.out.println("static 변수 b : " + b);  //ERROR - static 변수 b는 Sample 안에 있기에 인식안됨
        
        //Sample 객체를 생성하지 않고 정적 멤버 사용하기
        System.out.println("static 변수 b : " + Sample.b);  //OK - 클래스명.정적멤버  로 사용가능
    
    }
}


class Sample{
    int a= 10;           //일반 멤버변수 - 인스턴스 변수
    static int b= 20;    //정적 멤버변수
}

//시작 함수
fun main(){

    //4. 동반객체 [ companion object -  java의 static 키워드와 유사한 기능 : 객체 생성없이 사용가능한 멤버들 ]
    println( Sample.title )   

    // 동반객체의 멤버변수 값 변경
    Sample.title="robin"
    println( Sample.title)

    //당연히 static method 같은 기능의 메소드도 만들수 있음
    Sample.showTitle()
    println()

}//main 함수 종료..

//4. companion object [ companion: 동반자, 동행 ] - JAVA의 static 키워드를 대신하는 문법
class Sample{
    var a:Int=10

    companion object{
        var title:String="sam"  //java static variable 같은 역할

        fun showTitle():Unit{   //java static method 같은 역할
            println("제목 : $title")
            //println("Sample클래스 객체의 프로퍼티 a : $a ") //당연히 객체의 프로퍼티[자바에서는 인스턴스변수]는 사용할 수 없음
        }
    }
}

//**출력**
sam
robin
제목 : robin

class MainActivity : AppCompatActivity() {

    //뷰 참조변수
    var tv: TextView     //1. ERROR - 클래스의 프로퍼티는 반드시 초기화 해야 함.
    
    var tv2: TextView= findViewById(R.id.tv2)  //2. Exception - 문법에러는 아니지만 런타임(실행 중) 오류 발생함
    
    //3. null값으로 초기화 하기 위해 TextView? nullable 변수로 선언
    var tv3: TextView?= null  
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 화면에 보여줄 뷰를 설정
        setContentView(R.layout.activity_main)
        
        tv3= findViewById(R.id.tv3)
        tv3?.text="aaa".   // nullable 참조변수의 멤버를 사용할 때 마다 ?. null 안전 연산자를 사용하는 불편함이 있음.
    }
    
}

class Hello{

    var name:String  //ERROR : 프로퍼티는 선언하면서 값을 초기화 하지 않으면 에러
    
}

class Hello{

    //var name:String  //ERROR : 프로퍼티는 선언하면서 값을 초기화 하지 않으면 에러
    
    lateinit var name:String  //lateinit 키워드를 통해 나중에 초기화한다고 명시!
    
    fun show(){
        println("property name : $name") //프로퍼티이므로 메소드에서 사용가능
    }
    
}

//5.1) 프로퍼티(멤버변수)의 늦은 초기화문법 [ lateinit ]
val h:Hello= Hello()

// 초기화 없이 사용해 보기
println(h.name) //Exception : lateinit 프로퍼티의 초기화를 하기 전에 사용하면 Exception 발생
h.show()        //Exception : lateinit 프로퍼티의 초기화를 하기 전에 사용하면 Exception 발생 - 늦은 초기화확인 문법을 통해 예외발생 막을 수 있음.

class Hello{

    //var name:String  //ERROR : 프로퍼티는 선언하면서 값을 초기화 하지 않으면 에러

    lateinit var name:String  //lateinit 키워드를 통해 나중에 초기화한다고 명시!

    //초기화 코드를 가진 메소드!!    
    fun onCreate(){
        name= "sam"
    }

    fun show(){
        println("property name : $name") //프로퍼티이므로 다른 메소드에서 사용가능
    }

fun main(){

    val h:Hello= Hello()

    //println(h.name) //Exception : lateinit 프로퍼티의 초기화를 하기 전에 사용하면 Exception 발생
    //h.show()        //Exception : lateinit 프로퍼티의 초기화를 하기 전에 사용하면 Exception 발생 - 늦은 초기화확인 문법을 통해 예외발생 막을 수 있음.

    h.onCreate() //이 메소드에서 초기화
    println(h.name)
    h.show()

}

//**출력**
sam
property name : sam

lateinit var title:String?  //ERROR

lateinit var age:Int //ERROR

lateinit val address:String //ERROR

fun show(){
    //println("property name : $name") //프로퍼티이므로 다른 메소드에서 사용가능

    //lateinit 프로퍼티의 초기화여부에 확인하여 안전하게 사용하기 [ 코틀린 버전 1.2부터 사용가능 ]
    if( ::name.isInitialized  ) println("property name : $name")
}

class Hello{

    //5.2) val의 늦은 초기화는 lazy [ by lazy ]  - 작성 위치와 상관없이 사용될 때 lazy 블럭{}의 내용이 실행되고 마지막에 있는 값이 대입됨
    val address:String by lazy { "seoul" }

}

class Hello{

    //5.2) val의 늦은 초기화는 lazy [ by lazy ]  - 작성 위치와 상관없이 사용될 때 lazy 블럭{}의 내용이 실행되고 마지막에 있는 값이 대입됨
    val address:String by lazy { "seoul" }
    
    // lazy 블럭{}안에 일반적인 실행문도 구현가능함 
    val title:String by lazy {
        println("by lazy 초기화블럭")
        "Hello title"
    }

}

fun main(){

    //5.2)lazy 초기화
    val h:Hello= Hello() //이때 init{} 초기화 블럭 실행됨
    
    println(h.address) //이때 address 변수가 사용되면서 lazy 블럭이 실행되며 초기화 됨 - "seoul"값이 대입됨

    //by lazy{}블럭안에 실행문 넣고 실행되는 시점 확인
    println(h.title) //이때 title이 사용되면서 lazy 블럭이 실행되며 초기화 됨  -- android에서 활용하기 좋음

}


class Hello {

    //5.2) val의 늦은 초기화는 lazy [ by lazy ]  - 작성 위치와 상관없이 사용될 때 lazy 블럭{}의 내용이 실행되고 마지막에 있는 값이 대입됨
    val address:String by lazy { "seoul" }

    // lazy 블럭{}안에 일반적인 실행문도 구현가능함 - 아래 만들어 본 초기화블럭인 init{} 과 다르게 이 프로퍼티를 사용하기 전에는 발동하지 않음.
    val title:String by lazy {
        println("by lazy 초기화블럭")
        "Hello title"
    }

    //init 초기화블럭
    init {
        println("이 초기화 블럭은 객체생성시에 자동 호출됨")
    }
    
}


//**출력**
이 초기화 블럭은 객체생성시에 자동 호출됨
seoul
by lazy 초기화블럭
Hello title

class MainActivity : AppCompatActivity() {

    val tv: TextView = findViewById() //ERROR - onCreate()에서 setContentVeiw() 다은에 실행해야 하기에 에러
    val tv:TextView by lazy { findViewById(R.id.tv) } <--이런식으로 사용할 수 있음. 그럼.. onCreate() 에서 findViewById()를 안해도 됨.
    
}

val age:Int by lazy { 20 }

val message:String? by lazy { "Hello by lazy....." }
val message2:String? by lazy { null }

val message3:String? by lazy {
    if(age<20) "미성년자"
    else "성인"
    //참고로 만약 lazy 초기화 하는 age가 이전에 사용된 적이 없다면 바로 이때 초기화됨
}

var sss:String by lazy { "Nice" }  //ERROR

val nnn:MyKotlinClass by lazy { MyKotlinClass() }

//시작함수
fun main(){

}//main 함수 종료...

//상속을 해줄 부모클래스는 반드시 open 키워드가 추가되어야 함. 없으면 Java에서의 final 클래스와 같은 것임
open class First{
    var a:Int=10

    //override 해줄 메소드라고 명시하기위해 open키워드 추가 [없으면 final method ]
    open fun show(){
        println(" a : $a ")
    }
}

//시작함수
fun main(){

    //1) 자식 클래스의 객체 생성하기 - 코틀린의 상속은 부모클래스에 open키워드를 추가해야만 함.
    var obj= Second()
    obj.a=10    //부모클래스 First의 멤버변수를 내것인양 사용
    obj.b=20    //자식클래스 Second의 멤버변수
    obj.show()  //부모클래스 First의 멤버함수를 내것인양 호출

}//main 함수 종료...

//상속을 해줄 부모클래스는 반드시 open 키워드가 추가되어야 함. 없으면 Java에서의 final 클래스와 같은 것임
open class First{
    var a:Int=10

    //override 해줄 메소드라고 명시하기위해 open키워드 추가 [없으면 final method ]
    open fun show(){
        println(" a : $a ")
    }
}

//상속을 받은 자식클래스
//상속의 문법 [ 클래스명 뒤에 : 후 부모클래스명() 작성 <- 부모클래스명 뒤에 주 생성자호출()를 주의할것!! ]
class Second : First(){
    var b:Int=20
}

//시작함수
fun main(){

    //1) 자식 클래스의 객체 생성하기 - 코틀린의 상속은 부모클래스에 open키워드를 추가해야만 함.
    var obj= Second()
    obj.a=10    //부모클래스 First의 멤버변수를 내것인양 사용
    obj.b=20    //자식클래스 Second의 멤버변수
    obj.show()  //**오버라이드에 의해 Second의 show()메소드 호출**

}//main 함수 종료...

//상속을 해줄 부모클래스는 반드시 open 키워드가 추가되어야 함. 없으면 Java에서의 final 클래스와 같은 것임
open class First{
    var a:Int=10

    //override 해줄 메소드라고 명시하기위해 open키워드 추가 [없으면 final method ]
    open fun show(){
        println(" a : $a ")
    }
}

//상속의 문법 [ 클래스명 뒤에 : 후 부모클래스명() 작성 <- 부모클래스명 뒤에 주 생성자호출()를 주의할것!! ]
class Second : First(){
    var b:Int=20

    //같은 이름의 메소드를 부모로부터 상속받았기에 그냥 쓰면 에러!!
    //오버라이드라고 명시적으로 표기를 해야함.[ 이때, 오버라이드가 되는 메소드도 역시 open키워드가 있어야함. 없으며 final 메소드로 인식함 ]
    override fun show(){
        super.show()         //First 부모클래스의 show() 호출 - a 변수 출력
        println(" b : $b")
    }
}

//**출력**
 a : 10
 b : 20

//시작함수
fun main(){

    var f:First= Second() // up casting   - 부모참조변수로 자식 객체 참조
    f.show()  // 실제 가리키는 대상객체인 Second의 show() 메소드 호출

}//main 함수 종료...

//**출력**
 a : 10
 b : 20

//시작함수
fun main(){

    var f:First= Second() // up casting
    f.show()    // 실제 가리키는 대상객체인 Second의 show() 메소드 호출
    f.aaa()     // ERRPR : 부모참조변수인 f 가 실제 Second를 참조하고 있더라도 Second클래스의 고유 멤버는 사용불가
    
}//main 함수 종료...

//부모 클래스
open class First{
    var a:Int=10

    //override 해줄 메소드
    open fun show(){
        println(" a : $a ")
    }
}

class Second : First(){
    var b:Int=20

    //오버라이드 한 show() 메소드
    override fun show(){
        super.show()
        println(" b : $b")
    }

    //Second 클래스만의 고유한 메소드
    fun aaa(){
        println("Second의 고유 메소드")
    }
}

//시작함수
fun main(){

    var f:First= Second() // up casting
    
    //down casting.
    val s:Second = f   //ERROR - 형변환 없이 대입하려하면 자식이 부모를 참조한다고 판단하여 에러문법처러됨
    
    
}//main 함수 종료...

//시작함수
fun main(){

    var f:First= Second() // up casting
    
    //down casting.
    val s:Second = f   //ERROR - 형변환 없이 대입하려하면 자식이 부모를 참조한다고 판단하여 에러문법처러됨
    
    //val  s:Second = (Second)f   // ERROR - 자바에서의 형변환 연산자 (Type) 은 코틀린에 없는 문법임
    val  s:Second = f as Second   // 형변환 연산자 as
    s.show()
    s.aaa()
    
}//main 함수 종료...

//**출력**
 a : 10
 b : 20 
 Second의 고유 메소드

//일반회원 : [이름, 나이] 정보를 프로퍼티(멤버변수)로 가지는 클래스 - 주 생성자 활용 [ 클래스 명 옆에 constructor 키워드]
open class Person constructor(var name:String, var age:Int){ // 상속을 허용하기 위해 open 키워드

    init {
        println("create Person instance")
    }

    //멤버변수 값을 출력해주는 기능 메소드 - 자식클래스에서 override 하는 것을 허용하기 위해 open 키워드
    open fun show(){
        println("name : $name    age: $age ")
    }
}

//시작 함수
fun main(){

    //상속 마무리 연습 [ Person <- Student <- AlbaStudent ]
    
    //1) 일반회원    
    var p= Person("sam", 20)  //이름, 나이
    p.show()
    println()

}//main 함수 죵료..


//**출력**
create Person instance
name : sam    age: 20

//학생회원 : [이름, 나이, 전공]을 저장하는 클래스 - 일반회원을 상속받아 제작 
//상속받을 Person클래스에 이미 name, age 프로퍼티들이 있으므로 Student에서는 name, age를 받을 때 var키워드를 사용하면 안됨!!! 변수 오버라이드가 됨.
open class Student constructor(name:String, age:Int, var major:String) : Person(name, age) {
    init {
        println("create Student instance")
    }

    //override 키워드가 추가되면 open키워드가 이미 적용된 것임.
    override fun show(){
        //super.show()
        println("name : $name    age: $age    major : $major ")
    }
}

//시작 함수
fun main(){

    //상속 마무리 연습 [ Person <- Student <- AlbaStudent ]
    
    //1) 일반회원    
    var p= Person("sam", 20)  //이름, 나이
    p.show()
    println()
    
    //2) 학생회원
    var stu= Student("robin", 25, "kotlin android")
    stu.show()
    println()

}//main 함수 죵료..


//**출력**
create Person instance
name : sam    age: 20

create Student instance
name : robin    age: 25    major : kotlin android

//근로장학생 : [이름, 나이, 전공, 업무] property(멤버변수) 를 가지는 클래스 - Student 클래스 상속
//constructor 키워드 생략해보기
class AlbaStudent(name:String, age:Int, major:String, var task:String) : Student(name, age, major){
    init {
        println("create AlbaStudent instance")
    }

    override fun show() {
        //super.show()
        println("name : $name    age: $age    major : $major    task : $task ")
    }
}

//시작 함수
fun main(){

    //상속 마무리 연습 [ Person <- Student <- AlbaStudent ]
    
    //1) 일반회원    
    var p= Person("sam", 20)  //이름, 나이
    p.show()
    println()
    
    //2) 학생회원
    var stu= Student("robin", 25, "kotlin android")
    stu.show()
    println()
    
    //3) 근로장학생 회원
    val alba= AlbaStudent("tom", 27, "java android", "PC Management")
    alba.show()
    println()

}//main 함수 죵료..


//**출력**
create Person instance
name : sam    age: 20

create Student instance
name : robin    age: 25    major : kotlin android

create AlbaStudent instance
name : tom    age: 27    major : java android    task : PC Management

//교수회원 : [이름, 나이, 연구과제] 프로퍼티를 가지는 클래스 - Person 클래스 상속
//보조 생성자를 사용하여 상속할 때 부모생성자 클래스명 뒤에 ()를 쓰지 않고.. 자식클래스의 보조 생성자에서 super()로 호출하도록 함.
class Professor : Person{

    //Professor 클래스의 property(멤버변수) : 보조생성자는 직접 프로퍼티를 만들 수 없기에....
    var subject:String?= null

    //보조 생성자
    constructor(name:String, age:Int, subject: String) : super(name, age){ //super()키워드로 부모생성자 호출
        //멤버변수(프로퍼티)에 매개변수 전달!!
        this.subject= subject
        println("create Professor instance")
    }

    override fun show() {
        //super.show()
        println("name : $name    age: $age    subject: $subject ")
    }
}

//시작 함수
fun main(){

    //상속 마무리 연습 [ Person <- Student <- AlbaStudent ]
    
    //1) 일반회원    
    var p= Person("sam", 20)  //이름, 나이
    p.show()
    println()
    
    //2) 학생회원
    var stu= Student("robin", 25, "kotlin android")
    stu.show()
    println()
    
    //3) 근로장학생 회원
    val alba= AlbaStudent("tom", 27, "java android", "PC Management")
    alba.show()
    println()
    
    //4) 교수회원 - 보조생성자를 이용하는 Professor 클래스(Person을 상속하는) 연습
    val t= Professor("son", 45, "mobile optimization")
    t.show()
    println()

}//main 함수 죵료..


//**출력**
create Person instance
name : sam    age: 20

create Student instance
name : robin    age: 25    major : kotlin android

create AlbaStudent instance
name : tom    age: 27    major : java android    task : PC Management

create Professor instance
name : son    age: 45    subject: mobile optimization

//시작함수
fun main(){

}//main 함수 종료...

//클래스 선언 - 자바나 C++과 기본 모습은 비슷함. 단, 멤버변수(Field)를 Property(프로퍼티) 라고 부름
class MyClass{
    //멤버변수[ Property:프로퍼티] -반드시 초기화 해야함
    var a:Int= 10

    //메소드 : Method
    fun show(){
        println(" show : $a ")
        println()
    }
}

//시작함수
fun main(){

    //1. 클래스 정의 및 생성 - main()함수 밑에 클래스 선언
    //객체 생성 [매우 특이함!!! new키워드가 존재하지 않음 ]
    var obj= MyClass()
    obj.show()   
    
 }//main 함수 종료...

//클래스 선언 - 자바나 C++과 기본 모습은 비슷함. 단, 멤버변수(Field)를 Property(프로퍼티) 라고 부름
class MyClass{
    //멤버변수[ Property:프로퍼티] -반드시 초기화 해야함
    var a:Int= 10

    //메소드 : Method
    fun show(){
        println(" show : $a ")
        println()
    }
}

//**출력**
 show : 10

//java언어와는 다르게 클래스 이름이 파일명과 반드시 같을 필요는 없음.
class MyKotlinClass {
    //property  -- 멤버변수
    var a=10
    val b=20

    //method    -- 멤버함수
    fun show(){
        println(a)
        println(b)
        println()
    }
}

//시작함수
fun main(){

    //1-1. 별도의 파일로 만든 MyKotlinClass 클래스를 객체로 만들기 [당연히 클래스파일의 확장자는 .kt]
    var obj2= MyKotlinClass()  //객체생성
    obj2.show()    //메소드 호출
    
 }//main 함수 종료...
 
 //**출력**
 10
 20

//주 생성자 [클래스명 옆에 constructor()키워드로 정의
class Simple constructor(){
	
}

//시작함수
fun main(){

    //2.1 주 생성자 [Primary Constructor]
    var s= Simple()
    
 }//main 함수 종료...

//2.1 주 생성자 [클래스명 옆에 constructor()키워드로 정의]
class Simple constructor(){
    //근데 주 생성자가 별도의 메소드가 아니어서.. 코드를 작성할 수 없음.
    //그래서 존재하는 초기화 블럭 키워드
    init {
        //주 생성자가 호출될 때 실행되는 영역
        println("Simple primary constructor!!")
        println()
    }
}

//**출력**
Simple primary constructor!!

//시작함수
fun main(){

    //주 생성자에 파라미터 전달  [ 기본적으로 주 생성자는 오버로딩이 없음 ]
    var s2= Simple2(1000) 
    println(s2.num) //멤버변수 확인
    s2.show()       //멤버함수 호출
    
 }//main 함수 종료...

//주 생성자에 값 전달
//아주 특이하게 주 생성자의 파라미터를 만들 때 var, val을 사용하면 곧바로 프로퍼티, 즉, 멤버변수가 됨
class Simple2 constructor(var num:Int){

    init {
        println("Simple2 primary constructor!! : $num ")  //초기화블럭에서는 당연히 주 생성자의 파라미터인 num 변수 사용가능
    }

    fun show(){
        println("프로퍼티 num : $num ")  //주 생성자의 파라미터면서 멤버변수인 num 변수 사용가능
        println()
    }
    
}


//**출력**
Simple2 primary constructor!! : 1000
1000
프로퍼티 num : 1000

//시작함수
fun main(){

    //주 생성자에 파라미터 전달 
    var s2= Simple2(1000, 20) //2개의 파라미터에 값 모두 전달
    println(s2.num) //멤버변수 확인
    //println(s2.num2) //ERROR- 멤버변수가 아니어서 인식 불가
    s2.show()
    
 }//main 함수 종료...

// var을 안써도 에러는 아니지만 그때의 파리미터는 단순 매개변수임. 즉, 멤버변수(property)가 아님
class Simple2 constructor(var num:Int, num2:Int){  //num2는 var 키워드가 없기에 일반 매개변수

    init {
        println("Simple2 primary constructor!! : $num ")
        println("Simple2 primary constructor!! : $num2 ") //초기화 블럭에서는 num2매개변수 인식가능
    }

    fun show(){
        println("프로퍼티 num : $num ")
        //println("프로퍼티 num : $num2 ") //ERROR - 일반 메소드에서는 num2인식 불가
        println()
    }

}

//**출력**
Simple2 primary constructor!! : 1000
Simple2 primary constructor!! : 20
1000
프로퍼티 num : 1000

//시작함수
fun main(){

    //주 생성자에 파라미터 전달 
    var s2= Simple2(30) 
    println(s2.n)  //멤버변수 확인
    println(s2.n2) //멤버변수 확인
    
 }//main 함수 종료...

class Simple2 constructor(num:Int){  //num : var 키워드가 없기에 일반 매개변수

    //자바에서 처럼 멤버변수 만들기
    var n:Int= 10

    //프로퍼티에 주 생성자의 매개변수를 대입하여 사용하는 것은 가능함
    var n2:Int= num;
    
}

//**출력**
10
30

//시작함수
fun main(){

    //보조 생성자 [Secondary Constructor]
    var s3= Simple3()
    
 }//main 함수 종료...

//보조 생성자 - 자바처럼 class안에 메소드처럼 존재하는 생성자
class Simple3{

    //보조 생성자
    constructor(){
        println("Simple3 Secondary 생성자")
        println()
    }

}//Simple3 class....


//**출력**
Simple3 Secondary 생성자

//시작함수
fun main(){

    //보조 생성자 [Secondary Constructor]
    var s3= Simple3()
    
    //생성자 오버로딩
    var s4= Simple3(100)
    
 }//main 함수 종료...

//보조 생성자 - 자바처럼 class안에 메소드처럼 존재하는 생성자
class Simple3{
    
    //보조 생성자
    constructor(){
        println("Simple3 Secondary 생성자")
        println()
    }

    //보조 생성자는 Overloading 이 됨 [보조생성자의 파라미터에는 var로 곧바로 property를 만들 수 없음]
    constructor(num: Int){
        println("Simple3 Overloading Secondary 생성자 : $num ")
        println()
    }

}


//**출력**
Simple3 Secondary 생성자

Simple3 Overloading Secondary 생성자 : 100

//시작함수
fun main(){

    //보조 생성자 [Secondary Constructor]
    var s3= Simple3()
    
    //생성자 오버로딩
    var s4= Simple3(100)
    
 }//main 함수 종료...

class Simple3{
    //초기화 블럭 [물론 없어도 됨] -- 생성자보다 먼저 실행되는 영역
    init {
        println("이 영역은 항상 객체생성시에 초기화를 위해 처음으로 실행됨")
    }

    //보조 생성자
    constructor(){
        println("Simple3 Secondary 생성자")
        println()
    }

    //보조 생성자는 Overloading 이 됨 [보조생성자의 파라미터에는 var로 곧바로 property를 만들 수 없음
    constructor(num: Int){
        println("Simple3 Overloading Secondary 생성자 : $num ")
        println()
    }

}

//**출력**
이 영역은 항상 객체생성시에 초기화를 위해 처음으로 실행됨
Simple3 Secondary 생성자

이 영역은 항상 객체생성시에 초기화를 위해 처음으로 실행됨
Simple3 Overloading Secondary 생성자 : 100

//시작함수
fun main(){

    //주 생성자와 보조 생성자를 동시에 사용할 때.. [즉, 주 생성자를 오버로딩하고 싶다면...]
    var s5= Simple4()       //주 생성자 호출
    var s6= Simple4(1000)   //보조 생성자 호출
    
 }//main 함수 종료...

//주 생성자와 보조 생성자를 동시에 사용할 때..[즉, 주 생성자를 오버로딩하고 싶다면...]
class Simple4 constructor(){ //1. 주 생성자

    init {
        println("Simple4 init")
    }

    //2. 보조 생성자 - 주 생성자가 명시적으로 표기되어 있다면 반드시 주 생성자를 보조생성자에서 호출해야만 함. (Overloading)
    // [보조생성자 뒤에 : this()]
    constructor(num:Int) : this(){
        println("Simple4 secondary constructor!!!!!!!")
        println()
    }
}


//**출력**
Simple4 init
Simple4 secondary constructor!!!!!!!

//시작함수
fun main(){

    //참고. constructor키워드 생략가능
    var s7= Simple5()
    
 }//main 함수 종료...

class Simple5 (){   // 클래스명 Simple5 옆에 constructor 키워드 없이 소괄호 () 만 작성함

    init {
        //주 생성자가 호출될 때 실행되는 영역
        println("Simple5 primary constructor!!")
        println()
    }
    
}


//**출력**
Simple5 primary constructor!!

//시작 함수
fun main(){

}//main함수 .. 영역 끝

//1) 함수의 정의
//함수를 정의할 때 리턴타입의 위치에 fun 키워드를 사용  -- 파라미터와 리턴이 없는 함수
fun show(){
    println("show function")
    println()
}

//시작 함수
fun main(){

    //함수호출 - 파라미터에 값 전달  - 정수, 문자열 전달
    output(100, "Hello")

}//main함수 .. 영역 끝

//파라미터를 가진 함수 ( 파리미터명 : 자료형 ) - var, val 키워드 명시 X , 자동 val로 지정됨 (자료형 생략 불가)
fun output(a:Int, b:String){   //전달된 정수, 문자열을 받기위해 Int, String 변수로 지정
    println(a)
    println(b)    
    println()
}

//**출력**
100
Hello

fun output(a:Int, b:String){
    println(a)
    println(b)
    
    //파라미터 값 변경 시도해보기
    a=50 //ERROR - 매개변수는 자동 val
    println()
}

//시작 함수
fun main(){

    //리턴을 하는 함수 호출   - 두 정수 50, 30을 sum함수에 전달하고 연산된 결과 리턴값을 num변수로 받기
    var num= sum(50, 30)
    println("sum함수의 결과값 : $num ")

}//main함수 .. 영역 끝


//리턴하는 함수 [ 리턴타입을 함수()뒤에 : 후에 작성 ]
fun sum(a:Int, b:Int) :Int{  
    return a+b
}

//**출력**
sum함수의 결과값 : 80

//시작 함수
fun main(){

    //리턴이 없는 함수의 리턴을 받으면?? void가 아니라 Unit이라는 자료형이 됨.
    var x= display()
    println(x)

}//main함수 .. 영역 끝


//리턴타입이 없는 함수
fun display(){
    println("display!!");
}

//**출력**
display!!        //display()함수 안에 있는 println() 에 의해 출력된 글씨
kotlin.Unit      //main()함수의 x 변수의 출력에 의한 글씨.. Unit 타입이라는 것을 알 수 있음.

//시작 함수
fun main(){

    // getData()함수의 return 값을 받기
    val data= getData()
    println(data)  // 출력 : Hello

}//main함수 .. 영역 끝

//기본적인 return을 가진 함수
fun getData(): String{
    return "Hello"
}

//시작 함수
fun main(){

    // 단순화된 함수의 리턴값 받기  -- 사용법은 일반 return 키워드 함수 사용과 다른 점 없음
    val data2= getData2()
    println(data2)  // 출력 : Hello

}//main함수 .. 영역 끝

fun getData2():String = "Hello"

//시작 함수
fun main(){

    //함수 호출하면서 정수값 5를 전달하여 결과 받기 
    val data3= getData3(5)
    println(data2)  // 출력 : Good    

}//main함수 .. 영역 끝

//좀더 복잡한 리턴 코드가 있는 함수  -- 파라미터로 값을 받아 조건에 따라 리턴값이 다른 함수
fun getData3(num:Int): String{
    if( num < 10 ) return "Good"  -- 전달받은 5가 10보다 작기에 Good 리턴
    else return "Bad"
}

//시작 함수
fun main(){

    //함수 호출하면서 정수값 15를 전달하여 결과 받기 
    val data4= getData4(15)
    println(data4)  // 출력 : Bad    

}//main함수 .. 영역 끝

//할당연산자로 조건에 따른 리턴도 가능   -- if 표현식 이용
fun getData4(num:Int): String = if(num<10){
    "Good"
} else {
    "Bad"
}

//시작 함수
fun main(){

    aaa()   //일반함수 호출

}//main함수 .. 영역 끝

//기본적인 함수
fun aaa(){
    println("aaa")
}

//익명함수 - 함수의 이름이 없는 함수 [ 당연히 그냥 이름만 지우면 에러 - why? 함수의 기능은 있지만 호출할 이름이 없으니까.
fun (){...}  //ERROR

//bbb 변수에 이름없는 함수(익명함수)를 대입
val bbb= fun(){
    println("bbb")
}

//시작 함수
fun main(){

    bbb()   //익명함수를 참조하는 변수명을 이용하여 함수 호출

}//main함수 .. 영역 끝

//bbb 변수에 이름없는 함수(익명함수)를 대입
val bbb= fun(){
    println("bbb")
}

//시작 함수
fun main(){

    ccc()   //명시적으로 익명함수의 자료형[()->리턴타입]이 지정된 참조변수.ccc 이름을 통해 익명함수 호출

}//main함수 .. 영역 끝

//[ 익명함수의 자료형 : () -> 리턴타입 ]  ** 리턴타입이 없으면 Unit [자바의 void역할]
val ccc:()->Unit = fun(){
    println("ccc")
}

//시작 함수
fun main(){

    ddd()   //fun()키워드 생략한 익명함수 호출 [ {} 까지는 생략불가 ]

}//main함수 .. 영역 끝

//익명함수 축약표기법
val ddd:()->Unit = {
    println("ddd")
}

val ddd2:()->Unit = println("ddd2") //ERROR

//시작 함수
fun main(){

    eee()   //익명함수를 가진 변수의 자료형을 명시하지 않고 추론하도록..하고 사용

}//main함수 .. 영역 끝

//변수의 자료형은 자동 추론이 되니까 익명함수를 참조하는 변수의 자료형은 생략가능
val eee= {
    println("eee")
}

//시작 함수
fun main(){

    fff("Hello") //파라미터를 전달받는 익명함수 호출 - 문자열을 전달받아 그 글자의 글자수를 출력해주는 함수 [리턴값은 없는 함수 ]

}//main함수 .. 영역 끝

//파라미터를 전달받는 익명함수 [리턴값은 없는 함수 ]
val fff= fun(s:String){
    println("글자수:" + s.length)
}

//**출력**
글자수:5

//시작 함수
fun main(){

    ggg("Nice")  //익명함수의 자료형을 명시한 참조변수를 이용한 호출
    
}//main함수 .. 영역 끝

//이 익명함수를 가진 참조변수도 명시적으로 자료형을 명시할 수 있음. [ 파라미터:String 1개, 리턴타입 : Unit ]
val ggg:(String)->Unit = fun(s:String){
    println("글자수:" + s.length)
}

//**출력**
글자수:4

//시작 함수
fun main(){

    hhh("God")   //fun()키워드 생략한 익명함수 호출 [ { } 안에서 파라미터 작성하는 코드 필요 ]
    
}//main함수 .. 영역 끝

//파라미터를 전달받는 함수도 fun()키워드를 생략할 수 있음. 단, { }안에 익명함수의 자료형[()->리턴타입] 같은 형식으로 코딩 필요
val hhh:(String)->Unit = {
    s -> println("글자수:" + s.length)  // "s->" 의 s가 이 익명함수의 파라미터 변수이름 ( s:String 처럼 자료형명시 해도 됨 )
}

//**출력**
글자수:3

//시작 함수
fun main(){

    iii("He")    //파라미터가 1개라면 { }안에서 생략가능 - 단, 만약 그 파라미터를 사용하고자 한다면 익명함수의 특별한 키워드 "it" 사용
    
}//main함수 .. 영역 끝

//혹시 파라미터가 1개뿐이라면 "s->" 생략해도 됨.
val iii:(String)->Unit = {
    println("iii")
    //단, 만약 그 파라미터를 사용하려면.. 익명함수의 특별한 변수 "it" 키워드 사용 [ it변수의 자료형은 참조변수에 명시한 익명함수 자료형(String) 으로 자동 선언됨
    println("글자수:" + it.length)
}

//**출력**
iii
글자수:2

val iii2= {
    println("글자수:"+it.lenght) //ERROR   - it 을 인식하지 못함
}

//{} 안에서 파라미터를 생략하지 않았더라도 익명함수의 참조변수 자료형을 자동 추론되게 할 수 없음. 즉, 파라미터가 있을때는 익명함수의 자료형을 참조변수에 명시해야함.
val iii3= {
    //s -> println("글자수:" + s.length)  // ERROR
    s:String -> println("글자수:" + s.length)  // OK - 많이 활용되지는 않음.
}

//시작 함수
fun main(){

    jjj("sam", 20)  //파라미터 여러개인 익명함수 호출 [ "it"키워드 불가 ]
    
}//main함수 .. 영역 끝

//파라미터 여러개도 당연히 가능 [ 파라미터가 여러개일때는 "it" 키워드는 사용 불가 ]
val jjj:(String, Int) -> Unit = {
        name, age -> println("name: $name    age: $age")
}

//**출력**
name: sam   age: 20

//시작 함수
fun main(){

    val number= kkk()  // 리턴타입이 있는 익명함수 호출  [ number의 타입은 자동추론 ]
    println( number )  // 출력 : 10  
    
}//main함수 .. 영역 끝

//리턴타입이 있는 익명함수 [파라미터 없고 리턴타입이 Int인 익명함수]
val kkk= fun():Int{
    return 10
}

//시작 함수
fun main(){

    val number2:Int= lll()  // 익명함수의 자료형을 명시한 참조변수를 이용한 호출 [명시적으로 자료형 지정]
    println( number2 )  // 출력 : 20  
    
}//main함수 .. 영역 끝

//리턴타입이 있는 익명함수를 참조하는 변수의 자료형 명시적으로 지정
val lll: ()->Int = fun():Int{
    return 20
}

//시작 함수
fun main(){

    val number3:Int= mmm()  // fun()키워드를 생략한 익명함수 호출 - [ return 키워드도 삭제해야 함 ]
    println( number3 )  // 출력 : 30  
    
}//main함수 .. 영역 끝

//리턴타입이 있는 익명함수의 fun()키워드 생략하는 축약형 
val mmm: ()->Int = {
    30     // - [ * 주의 : return 키워드를 제거해야 함 *]
}

//시작 함수
fun main(){

    val number4:Int= nnn()  // fun()키워드를 생략한 익명함수의 {}안에 실행문이 여러줄인 함수 호출 [ 가장 마지막 실행문이 리턴값 ]
    println( number4 )  // 출력 : 50  
    
}//main함수 .. 영역 끝

//만약 {}안에 실행문이 여러개 라면? - 마지막 실행문의 값이 return 값
val nnn: ()->Int = {
    30
    println("중간 글씨") //{}영역은 실행문 작성 영역이므로 당연히 중간에 이렇게 리턴값이 아닌 실행문이 있어도 됨. 단, 이 println()이 마지막 실행문이면 에러. [리턴타입이 안 맞아서]
    40
    50 //이 값이 리턴값
    //println("중간 글씨") //ERROR  -- 이 함수의 리턴타입이 Int여서 println()함수가 마지막 값일 수 없음
}

//**출력**
중간 글씨
50

//시작 함수
fun main(){

    val add= ooo(5,3)   //파라미터와 리턴타입이 모두 있는 익명함수 호출 [두수를 전달받아 덧셈결과를 리턴하는 함수]
    println(add)    //출력 : 8
    
}//main함수 .. 영역 끝

//파라미터와 리턴타입이 같이 있는 익명함수 [두 수를 전달받아 덧셈결과를 리턴하는 함수 ]
val ooo:(Int, Int) -> Int = fun(a:Int, b:Int):Int{
    return a+b
}

//시작 함수
fun main(){

    val add2= ppp(4,6)  //fun()키워드 생략한 파라미터와 리턴타입이 같이 있는 익명함수 호출
    println(add2)   //출력: 10
    
}//main함수 .. 영역 끝

//fun()키워드 생략한 파라미터와 리턴타입이 같이 있는 익명함수 [두 수를 전달받아 덧셈결과를 리턴하는 함수 ] : {}안에 익명함수 타입(Int,Int)->Int 형태로 코딩 , return 키워드 역시 생략
val ppp:(Int, Int) -> Int = {
        a, b -> a+b      // (Int,Int)->Int 형태로 코딩 , return 키워드 역시 생략
}

//기본적인 함수 [ String 입력을 받아 글자수를  Int 로 리턴해 주는 기능 함수]
fun stringLength(str:String): Int{
    return str.length
}

//익명함수 [함수를 stringLength2라는 변수에 넣는 것 (String) -> Int 는 String를 매개변수로 받아  Int를 리턴해 준다는 표기법 ]
val stringLength2: (String) -> Int = fun(str:String):Int{
    return str.length
}

//익명함수 축약형 [ fun() , return 키워드 생략 ]
val stringLength3: (String) -> Int = {
        str -> str.length
}

//파라미터가 1개이므로 생략한 익명함수 축약형 [ fun() , return 키워드 및 파라미터 생략 ]
val stringLength4: (String) -> Int = {
    it.length      // 생략된 파라미터 1개를 대체하는 it 변수
}

//시작 함수
fun main(){

    //파라미터와 리턴타입이 다른 익명함수 사용의 마지막 연습
    val len= stringLength("android")
    println(len)       //출력: 7

    //익명함수로 만든 함수 호출
    val len2= stringLength2("kotlin")
    println(len2)      //출력: 6

    //축약표현 익명함수 호출
    println( stringLength3("nice") )   //출력: 4
    println( stringLength4("web") )    //출력: 3
    
}//main함수 .. 영역 끝

//정수를 전달받아 출력하는 익명함수를 저장하는 sss 변수
var sss= fun(a:Int){
    println("sss : $a")
}
var ttt= sss //위에서 만든 익명함수 sss 를 ttt변수가 참조하면 ttt()로 함수호출 가능함.

//시작 함수
fun main(){

    sss(100)
    ttt(200)
    
}//main함수 .. 영역 끝

//**출력**
sss : 100     // sss변수에 의해 호출된 출력
sss : 200     // ttt변수에 의해 호출된 출력

//문자열을 파라미터로 받아 출력해 주는 람다 함수를 저장하는 xxx 변수
var xxx:(String)->Unit= { println(it) }

//xxx 변수가 참조하는 람다함수를 yyy변수에 대입
var yyy= xxx

//시작 함수
fun main(){

    xxx("Hello world")
    yyy("Nice to meet you")
    
}//main함수 .. 영역 끝

//**출력**
Hello world         // xxx변수에 의해 호출된 출력
Nice to meet you    // yyy변수에 의해 호출된 출력

//'고차함수' : 함수의 파라미터로 다른 함수를 사용하는 것을 고차함수라고 부름 [다른변수에 함수를 대입할 수 있듯이]
// 두번째 파라미터 aaa는 익명함수를 인자로 받겠다고 표시
fun getLength(str:String, aaa: (String)->Int ): Int{
    return aaa(str) //전달받은 함수(aaa)의 파라미터로 첫번째 파라미터인 str을 전달하면서 함수호출하고 결과 return
}

//시작 함수
fun main(){

    //함수는 다른 함수를 인수로 취할 수 있습니다. 다른 함수를 인수로 사용하는 함수를 고차 함수라고 합니다. 이 패턴은 자바에서 콜백 인터페이스를 사용할 때와 동일한 방식으로 구성요소 간에 통신하는 데 유용합니다.
    val len3= getLength("android",stringLength3) //아래 만든 익명함수를 2번째 파라미터에 전달
    println(len3)  //출력: 7
    
}//main함수 .. 영역 끝


//5.17-3)익명함수 축약형 [ fun() , return 키워드 생략 ]
val stringLength3: (String) -> Int = {
        str -> str.length
}

//'고차함수' : 함수의 파라미터로 다른 함수를 사용하는 것을 고차함수라고 부름 [다른변수에 함수를 대입할 수 있듯이]
// 두번째 파라미터 aaa는 익명함수를 인자로 받겠다고 표시
fun getLength(str:String, aaa: (String)->Int ): Int{
    return aaa(str) //전달받은 함수(aaa)의 파라미터로 첫번째 파라미터인 str을 전달하면서 함수호출하고 결과 return
}

//시작 함수
fun main(){

    //함수는 다른 함수를 인수로 취할 수 있습니다. 다른 함수를 인수로 사용하는 함수를 고차 함수라고 합니다. 이 패턴은 자바에서 콜백 인터페이스를 사용할 때와 동일한 방식으로 구성요소 간에 통신하는 데 유용합니다.
    val len3= getLength("android",stringLength3) //아래 만든 익명함수를 2번째 파라미터에 전달
    println(len3)  //출력: 7
    
    //2번째 파라미터 자리에서 익명함수[String받아 Int를 리턴해주는]를 그 자리에서 설계하여 전달해보기
    val len4= getLength("kotlin", { str -> str.length })
    println(len4)  //출럭: 6 
    
}//main함수 .. 영역 끝

//시작 함수
fun main(){

    //함수는 다른 함수를 인수로 취할 수 있습니다. 다른 함수를 인수로 사용하는 함수를 고차 함수라고 합니다. 이 패턴은 자바에서 콜백 인터페이스를 사용할 때와 동일한 방식으로 구성요소 간에 통신하는 데 유용합니다.
    val len3= getLength("android",stringLength3) //아래 만든 익명함수를 2번째 파라미터에 전달
    println(len3)  //출력: 7
    
    //2번째 파라미터 자리에서 익명함수[String받아 Int를 리턴해주는]를 그 자리에서 설계하여 전달해보기
    val len4= getLength("kotlin", { str -> str.length })
    println(len4)  //출럭: 6 
    
    //전달되니 문자열을 Int 타입으로 형변환하는 함수를 전달받아 기능 다르게 동작하도록 해보기
    val len5= getLength("450",{ str -> str.toInt() }) //이런식으로 원래 의도와 다른 함수를 전달하여 기능이 바뀌게 할 수도 있음.
    println(len5 + 3)  //출력: 453    ~ 450+3
    
}//main함수 .. 영역 끝

// ** 코틀린문법에서는 람다식으로 표현된 함수의 파라미터를 () 밖에 작성하는 방식을 권장함. [마치 함수정의 하듯이]
val len6= getLength("ios"){ str -> str.length }
println(len6)

// ** 람다함수의 파라미터가 1개이므로 str-> 를 생략하고 it 이라는 특별한 변수명으로 대체 가능함.
val len7= getLength("mobile"){ it.length }
println(len7)

//시작 함수
fun main(){

    //함수 파라미터의 default value
    zzz(5,3) 
    zzz() //a,b 가 모두 default 값으로 적용됨.
    zzz(10) //b는 default 값으로 적용됨.
    //혹시 특별하게 b에게 10을 적용하고 싶다면.. 함수 파라미터 선택 적용
    zzz(b=5) //호출할때 변수명 지정
    
}//main함수 .. 영역 끝


//함수 파라미터의 default value
fun zzz(a:Int=1000, b:Int=2000){   //a에 값이 전달되지 않으면 1000, b에 값이 전달되지 않으면 2000
    println("a: $a , b: $b")
}

//**출력**
a: 5 , b: 3
a: 1000 , b: 2000
a:10 , b: 2000
a:1000 , b: 5

//시작 함수
fun main(){

    //함수 파라미터의 지정을 통하여 값 전달 순서를 변경할 수도 있음.
    xxxxx("korea", "seoul")
    xxxxx(city = "newyork", nation = "usa")
    
}//main함수 .. 영역 끝

//첫번째 파라미터 nation만 default 값 지정
fun xxxxx(nation:String="korea", city:String){
    println(nation)
    println(city)
    println()
}

//**출력**
korea
seoul

usa
newyork

var arr:Array<Int> = arrayOf(10,20,30) //정수형 배열요소 3개짜리 배열객체 및 참조변수

var arr = arrayOf(10,20,30) //데이터타입 생략을 통한 자동추론 가능함 Array<Int>

println(arr[0])  // arr배열의 0번방 요소 값 출력 : 10
println(arr[1])  // arr배열의 1번방 요소 값 출력 : 20
println(arr[2])  // arr배열의 2번방 요소 값 출력 : 30

println(arr[3])  //인덱스번호가 틀리면 Exception발생

arr[0]= 100        //arr배열의 0번방에 100 대입
println(arr[0])    //출력: 100

//마치 자바의 ArrayList 요소 값 얻어오기 처럼...사용가능   
println(arr.get(0)) //출력 : 100
println(arr.get(1)) //출력 : 20
println(arr.get(2)) //출력 : 30
println()

arr.set(1, 200)     //배열 1번방에 200을 대입
println(arr.get(0)) //출력 : 100
println(arr.get(1)) //출력 : 200
println(arr.get(2)) //출력 : 30

println("배열의 길이 : ${arr.size}")  //출력 : 배열의 길이 : 3

for(i in 0 until 3){   // 0..3쓰면 OutOfIndex Exception발생함
    println(arr.get(i))
}

//**출력**
100
200
30

//배열요소값 for문으로 출력하기 (Java의 foreach문 같은 코드)
for(n in arr){ //n은 인덱스번호가 아님.... 주의!!! 요소임.
    println(n) 
}

//**출력**
100
200
30

for(i in arr.indices){   //i는 인덱스번호를 저장하는 Int형 제어변수
    println(i)
}

//**출력**
0
1
2

for( (i, v) in arr.withIndex() ){    // (인덱스번호, 요소값)  - 순서변경 불가, 소괄호 필수
    println( "[ $i ] : $v ")
}

//**출력**
[ 0 ] : 100
[ 1 ] : 200
[ 2 ] : 30

arr.forEach {     //배열 요소의 개수만큼 {} 영역이 실행됨
    println(it)   //{}영역 안에서 it 이라는 이름의 숨겨진 변수가 요소값을 가지고 있음
}

//**출력**
100
200
30

var arr2= arrayOf(10, "Hello", true)  // Int, String, Boolean  ==> Array<Any> 타입으로 추론

println(arr2[0])   //출력 : 10
println(arr2[1])   //출력 : Hello
println(arr2[2])   //출력 : true

arr2[0]= 20           //0번방의 값을 10 -> 20으로 변경
arr2.set(1, "bbb")    //1번방의 값을 "Hello" -> "bbb"로 변경
arr2[2]= 3.14         //기존 자료형을 변경해도 됨. Boolean --> Double [Any타입 이므로]

println( arr2[0] + 5 ) //ERROR - arr2[0]의 값은 20 이기에 산술 덧셈 + 5 가 가능해 보이지만 본인이 Int가 아니라 Any로 인식하여 산술연산 불가

println( arr2[0] as Int + 5)        //요소를 as 연산자로 Int로 변환해서 사용해야 함. [ 참조타입의 형변환 연산자 as ]
println( arr2[1] as String + "AAA") //요소를 String으로 변환하여 문자열 결합 "bbb"+"AAA"

var arr3= arrayOf<Int>(10,20,30) //다른 자료형은 넣으면 error

var arr4= intArrayOf(10,20,30)

var arr5: IntArray        //Int형 배열 Array 참조변수
arr5= intArrayOf(1,2,3)

val arr6= arrayOfNulls<Double>(5)  //요소 개수가 5개인 null값을 가지고 만들어진 배열
for(t in arr6){
    println(t)
}

//**출력**
null
null
null
null
null

arr6= arrayOfNulls<Double>(3) //ERROR - val 읽기전용 변수의 참조값 변경 불가능

val arr7:Array<Float?> = arrayOfNulls<Float>(3); //null배열을 만들때 참조변수의 타입을 명시할때 제네릭 자료형에 ?(nullalbe) 키워드 필요함.

//var arrr:Int[] = arrayOf(10,20) //error
var arrr:Array<Int> = arrayOf(10,20) //Array타입을 명시할때는 반드시 <>제네릭을 표시해야함.
//var arrr2:Array<Int>= arrayOf(100,200) // <> 다음에 = 대입연산자를 곧바로 붙이면 에러. 띄어쓰기 필요 [ **주의**]

val list:List<Int> = listOf(10,20,30,20) //중복데이터[20] 허용 [*주의* 제네릭 <> 타입에 = 대입연산자가 붙어 있으면 에러. 띄어쓰기 해야함.
for( i in 0..3) {
    println( list.get(i) ) // .get(인덱스번호)메소드를 통해 요소의 값 얻어오기
}

//**출력** 
10
20
30
20    //중복 데이터 존재 확인

//값의 추가/삭제/변경에 관련된 기능메소드가 없음
list.add(20)      //error - add()메소드 없음
list.remove(0)    //error - remove()메소드 없음
list.set(1, 200)  //error - set()메소드 없음

val set:Set<Double> = setOf(3.14, 5.55, 2.22, 5.55, 1.56) //중복데이터[5.55]는 자동으로 저장안됨.
for( e in set) println(e)  

//**출력**
3.14
5.55
2.22
1.56
//중복 데이터 5.5가 저장되어 있지 않음

val map:Map<String, String> = mapOf( Pair("title","Hello"), Pair("msg","nice to meet you.") ); //Pair()객체를 이용하여 [키,벨류] 쌍으로 요소 추가
println("요소개수 : ${map.size}")  //요소 개수 확인해보기
for ( (key, value) in map){      //키와 벨류값을 받아오는 for-in .. (key, value) 소괄호 필수. 순서중요
    println("$key : $value")
}

//**출력**
요소개수 : 2
title : Hello
msg : nice to meet you.

val map2:Map<String, String> = mapOf( "id" to "mrhi", "pw" to "1234" )  // key to value
for( (k, v) in map2) println( "$k : $v")  // (키,벨류)의 변수명은 원하는 단어로 변경가능

//**출력**
id : mrhi
pw : 1234

val aaaa:MutableList<Int> = mutableListOf(10,20,30)  // 요소개수 3개짜리 리스트객체 생성
println("요소개수 ${aaaa.size}")    //출력: 요소개수 3

aaaa.add(40)

aaaa.add(0,50)

println("요소개수 ${aaaa.size}")  //출력: 요소개수 5

aaaa.set(1,200)   //1번방에 200 설정

aaaa[1] = 200   //1번방에 200 설정

for( e in aaaa) println(e)

//**출력**
50
200
20
30
40

val bbbb:MutableSet<Double> = mutableSetOf<Double>()  //셋의 초기 요소개수를 0개로 생성할 수 있음
println("요소개수 ${bbbb.size}")  //출력: 요소개수 0

bbbb.add(5.55)
bbbb.add(3.14)
bbbb.add(5.55) //중복데이터는 자동 무시

println("요소개수 ${bbbb.size}")  //출력: 요소개수 2
for( e in bbbb) println(e)

//**출력**
5.55
3.14

val cccc:MutableMap<String, String> = mutableMapOf("name" to "sam", Pair("tel", "01012345678"))  //to연산자와 Pair()를 동시에 사용해도 문제없음
println("요소개수 ${cccc.size}")  //출력: 요소개수 2

cccc.put("addr", "seoul")
println("요소개수 ${cccc.size}")  //출력: 요소개수 3

for( (k,v) in cccc) println( "$k : $v")

//**출력**
name : sam
tel : 01012345678
addr : seoul

// Java의 ArrayList 같은 배열
val arrList:ArrayList<Any> = arrayListOf<Any>(10, "Hello", true)
for( e in arrList) println(e)
println()
/**출력**
10
Hello
true
*******/


//요소 추가 및 삭제
arrList.add(20)
arrList.add(3.14) //원래 있던 자료형이 아닌 것이 추가되면 에러였으나 이제 가능함
arrList.forEach { println(it) } //리스트객체의 forEach 기능사용하기 [한번 해보기]
println()
/**출력**
10
Hello
true
20
3.14
*******/

//특정 위치에 추가하기
arrList.add(0, "Nice")
for( e in arrList){
    println(e)
}
println()
/**출력**
Nice
10
Hello
true
20
3.14
*******/

//인덱스번호로 지우기
arrList.removeAt(0)
for( e in arrList){
    println(e)
}
println()
/**출력**
10
Hello
true
20
3.14
*******/

//요소값으로 지우기
arrList.remove(3.14)
for( e in arrList){
    println(e)
}
println()
/**출력**
10
Hello
true
20
*******/


//요소개수나 set(), get()은 동일하게 존재함
println("요소개수 : ${arrList.size}")
arrList.set(0,20) //코틀린은 set()보다는 아래처럼 []인덱싱을 이용하여 설정하는 방식을 권장함
//arrList[0]=20
println("0번요소의 값 :  ${ arrList.get(0) }") //변수명이 아니라 함수를 호출하는 것도 가능함
//println("0번요소의 값 :  ${ arrList[0] }") //코틀린은 []인덱싱 방식을 권장함
println()
/**출력**
요소개수 : 4
0번요소의 값 :  20
********/


val hashSet: HashSet<Any> = hashSetOf(100, "Good", false)
hashSet.add(200)
hashSet.add("Good") //중복데이터 자동 무시
println("요소개수 : ${hashSet.size}")
for( e in hashSet) println(e)
println()
/**출력**
요소개수 : 4
200
100
Good
false
********/

val hashMap: HashMap<String, String> = hashMapOf("apple" to "사과", Pair("house", "집"))
hashMap.put("car","자동차")
hashMap.put("car","차") //같은 key 를 사용하면 마지막 값으로 변경
for ( (k,v) in hashMap) println("$k : $v")
println()
/**출력**
apple : 사과
house : 집
car : 차
*********/

val arrays= arrayOf( arrayOf(10,20,30),  arrayOf("aa", "bb"), arrayOf(true, false))  //1차원배열 3개를 가진 2차원배열 객체 1개 생성

for( ar in arrays){
    for( e in ar){
        print(e)
        print("   ")
    }
    println()
}
println()

//**출력**
10   20   30   
aa   bb   
true   false

val arrays2= mutableListOf<MutableList<Int>>( mutableListOf<Int>(10,20,30), mutableListOf<Int>(100,200,300,400) )
println("2차원배열 arrays2의 사이즈 : ${arrays2.size}")  //2차원배열 arrays2의 사이즈 : 2

for( i in 0 until arrays2.size ){
   
}

or

for ( index in arrays2.indices ){   //인덱스 번호들 얻어오기
   println(" arrays[$index] 리스트요소의 사이즈 : ${arrays2[index].size}  ")
}

//**출력**
 arrays[0] 리스트요소의 사이즈 : 3  
 arrays[1] 리스트요소의 사이즈 : 4

arrays2.add(  mutableListOf(1000,2000) )
for( li in arrays2 ){
    for( e in li){
        print("$e, ")  //1차원 배열의 요소값 출력
    }
    println()
}
println()

//**출력**
10, 20, 30, 
100, 200, 300, 400, 
1000, 2000,

val aaaaa:List<String?> = listOf(null, "nice")
for ( e in aaaaa ) println(e)
println()
/**출력**
null
nice
********/

val aaaaa2:List<String?> = listOfNotNull(null, "aaa") //null값 저장이 자동으로 무시됨
for( e in aaaaa2) println(e)
println()
/**출력**
aaa
********/

val bbbbb: Set<String?> = setOfNotNull(null,"good"); //null 무시
for( e in bbbbb) println(e)
println()
/**출력**
good
********/

// map 방식은 NotNull 관련 함수가 없음.
//val ccccc: Set<String?> = mapOfNotNull(); //존재하지 않음

// mutableXXX()도 NotNull 관련 함수가 없음.

println(10 + 3.14)  //출력: 13.14    - Int + Double ==> 10.0(Dobule) + 3.14(Double)

println(10 + true) //ERROR   - Int + Boolean (X)
println(10 + 'A') //ERROR    - Int + Char (X)  ~ 자바와 다르게 Char타입은 정수 65로 인식되지 않음

var n4 = 10    //자동추론
if (n4 is Int) {   //Int가 맞으면 true
    println("n4변수는 Int타입 입니다.")
}

var s3: String = "Hello"
if (s3 is String) println("s3변수는 String 타입입니다.")  //String 맞기에 true

if (s3 is String?) println("s3변수는 String 타입입니다.")

if( s3 !is String) println("s3변수는 String 타입이 아닙니다.")

if( n4 is String){ } //ERROR  - Incompatible types: String and Int

var obj:Any    //Any타입이기에 어떤 데이터도 참조 가능

obj= 10   //Int 데이터

// Any타입 변수에 저장된 데이터의 타입을 체크
if(obj is Int) println( "${obj}는 Int입니다.")
if(obj is Double) println( "${obj}는 Double입니다.")

//결과 : 10는 Int입니다.

obj= 10.5  //Double 데이터 
if(obj is Int) println( "${obj}는 Int입니다.")
if(obj is Double) println( "${obj}는 Double입니다.")

//결과 : 10.5는 Double입니다.

class Person{
    //코틀린에서는 멤버변수를 속성[Property]라고 명명함.
    //주의!! 프로퍼티는 반드시 초기화가 되어 있어야 함.
    var name:String = "sam"
    var age= 20
}

var p= Person()   //코틀린에서는 객체를 생성하는 키워드 new 를 명시하지 않음
if(p is Person){
    println( p.name + "  " + p.age )  //출력: sam 20   
}

var p= Person()
if(p is Person){
    println( p.name + "  " + p.age )
    println( "이름 : ${p.name}    나이: ${p.age}")
}

//**출력**
이름 : sam   나이: 20

var obj2:Any
obj2= Person()
obj2.name="aaa" //에러는 아니지만 Android Studio편집기에서 name변수의 존재를 알려주지 않음. [다만, 업캐스팅 되어 있다면 .연산자로 자식객체의 멤버를 강제로 명시하여 사용이 가능함(자동 형변환 - 권장하지 않음)]

if(obj2 is Person){  // is의 참 영역 안에서는 obj2가 Any타입이 아니라 Person타입의 참조변수인것으로 편집기가 인식함.
    println( obj2.name + "  " + obj2.age )
    println( "이름 : ${obj2.name}    나이: ${obj2.age}")
}

println( 7 | 3)             //ERROR -    | ( OR 비트연산자) 없음
println( 7.or(3) )          // OR 비트연산에 대응하는 메소드가 Int 타입에 존재함
println( 7 or 3 )           // OR 메소드를 가독성 좋게 마치 연산자처럼 표기하는 것이 가능함.

println( true and false )   // & AND 비트연산에 대응하는 and 연산자

//println( 3.14 and 5.55 )  //ERROR - Double 타입은 비트연산 안됨
//println( "aaa" or "bbb" ) //ERROR - String 타입은 비트연산 안됨

var str= (10>5)? "Hello" : "Nice" //ERROR : 삼항연산자 문법이 없음

var str= if(10>5) "Hello" else "Nice"    //참이면 "Hello" 거짓이면 "Nice"
println(str)   //결과: Hello

str= if(10<5){
    "zzzzz"
    "aaaaa"    //참이면 이 문자열이 str에 대입됨
}else{
    "qqqqq"
    println("ggggg") //당연히 이렇게 출력문 같은 코드가 있어도 됨.
    "bbbbb"    //거짓이면 이 문자열이 str에 대입됨
}

println(str)  

//**출력**
ggggg    <-- else{} 영역안에 있는 println("ggggg") 실행문에 의한 출력
bbbbb    <-- 조건문 밖의 println(str) 실행문의 의한 출력

str= if(10>5){
    "zzzzz"
    "aaaaa"
}else{
    "qqqqq"
    println("ggggg") //당연히 이렇게 출력문 같은 코드가 있어도 됨.
    "bbbbb"
    println("ggggg") //ERROR - 마지막이 있으면 당연히 에러 [ str의 자료형이 String이어서 에러임. Any였다면 에러 아님. 참고로 println()함수의 자료형은 Kotlin.Unit 타입임]
}

var h:Any?= null

//문법이 없어서 switch를 쓰면 에러
//switch(h){   }  //ERROR

h=10
when(h){   //h값으로 분기
    10-> println("aaa")   //h가 10일때 실행
    20-> println("bbb")   //h가 20일때 실행
}

h=10
when(h){
    10-> println("aaa")
    20-> println("bbb")
    //자료형이 달라도 상관없음
    "Hello"-> println("Hello")
    true-> println("true")
}

var nn:Int= 100   //정수형 변수 nn 선언
h=10
when(h){
    10-> println("aaa")
    20-> println("bbb")
    //자료형이 달라도 상관없음
    "Hello"-> println("Hello")
    true-> println("true")

    //변수가 있어도 됨 (첫줄에 있는 변수 nn이 100을 가지고 있음)
    nn-> println("100을 가지고 있습니다.")
}

var nn:Int= 100   //정수형 변수 nn 선언
h=10
when(h){
    10-> println("aaa")
    20-> println("bbb")
    //자료형이 달라도 상관없음
    "Hello"-> println("Hello")
    true-> println("true")

    //변수가 있어도 됨 (첫줄에 있는 변수 nn이 100을 가지고 있음)
    nn-> println("100을 가지고 있습니다.")
    
    //2개이상의 조건을 묶을 수 있음
    30,40-> println("30 or 40 입니다.")
}

var nn:Int= 100   //정수형 변수 nn 선언
h=10
when(h){
    10-> println("aaa")
    20-> println("bbb")
    //자료형이 달라도 상관없음
    "Hello"-> println("Hello")
    true-> println("true")

    //변수가 있어도 됨 (첫줄에 있는 변수 nn이 100을 가지고 있음)
    nn-> println("100을 가지고 있습니다.")
    
    //2개이상의 조건을 묶을 수 있음
    30,40-> println("30 or 40 입니다.")
    
    //switch문의 default역할 : 실행할 코드가 여러줄이면 {}로 묶어서...
    else->{
            println("ccc")
            println("end")
    }
}

h=20
var result= when(h){
    10->"Hello"
    20->"Nice"
    else->{
        println("else")
        "BAD"
    }
}
println(result)  //출력: Nice

when(h){
    is Int -> println("Int 타입입니다.")        //h의 자료형이 Int면 분기되어 실행
    is String -> println("String 타입입니다.")  //h의 자료형이 String이면 분기되어 실행
    else -> println("else")                  //Int, String 이 아닐때 실행
}

h=85
when{    //()가 생략되어 있음!!
    h>=90 && h<=1000-> println("A학점 입니다")
    h>=80 -> println("B학점 입니다.")
    h>=70 -> println("C학점 입니다.")
    h>=60 -> println("D학점 입니다.")
    else -> println("F학점 낙제 입니다.")
}

h=85
when{
    //h>=90 && h<=100-> println("A학점 입니다")
    h in 90..100 -> println("A학점 입니다") // 90..100 == 90~100 범위
    h>=80 -> println("B학점 입니다.")
    h>=70 -> println("C학점 입니다.")
    h>=60 -> println("D학점 입니다.")
    else -> println("F학점 낙제 입니다.")
}

for(var i=0; i<5; i++){} //ERROR - 이런 문법이 없음

for(i in 0..5){ //i변수 앞에 var쓰면 에러
    println(i)
}

//**출력**
0
1
2
3
4
5

for(i in 3   ..    10){ //..양옆의 공백은 상관없음  - 3~10
    println(i)
}

//**출력**
3
4
5
6
7
8
9
10

for(i in 0 until 10){ // 0 ~ 9
    println(i)
}

//**출력**
0
1
2
3
4
5
6
7
8
9

for(i in 0..10 step 2){ //0~10까지 2씩 증가
    println(i)
}

//**출력**
0
2
4
6
8
10

for(i in 10 downTo 0) println(i) //10~0까지 1씩 감소

//**출력**
10
9
8
7
6
5
4
3
2
1
0

for(i in 10 downTo 0 step 2) println(i) //10~0까지 2씩 감소

//**출력**
10
8
6
4
2
0

for (n in 0..5){
    if(n==3) break
    print("$n    ")   //반복할 때 마다 제어변수 n 출력 - 줄바꿈 안함
}

//**출력**
0    1    2

for(y in 0..5){         //0~5까지 6번 반복 
    print("$y : ")      //제어변수 y 값 출력 [ 문자열 탬플릿 : 문자열 " "안에서 $y 로 변수 인식 ]
    for(x in 0..10){    //0~10까지 11번 반복
        if(x==6) break  //6이 되면 안쪽 반복문만 멈춤
        print("$x    ") //제어변수 y 값 출력
    }
    println()
}

//**출력** 
0 : 0    1    2    3    4    5
1 : 0    1    2    3    4    5
2 : 0    1    2    3    4    5
3 : 0    1    2    3    4    5
4 : 0    1    2    3    4    5
5 : 0    1    2    3    4    5

KKK@ for(y in 0..5){        //for의 지점에 KKK 라벨 지정
    print("$y : ")
    for(x in 0..10){
        if(x==6) break@KKK  //"KKK" Label의 for문을 break
        print("$x    ")
    }
    println()
}

//**출력**
0 : 0    1    2    3    4    5      //바깥쪽 KKK반복문이 종료되어 전체 반복 종료

println("Hello" + " Kotlin") //출력: Hello Kotlin

println( 10 + "Hello") //ERROR

println(10.toString() + " Hello")  //"10"+" Hello" -->  출력: 10 Hello

println("Hello" + 10)  //"Hello" + "10"  -->  출력: Hello10

var nnn1 = 50
var nnn2 = 30
//println( num1 +" + "+ num2 +" = " + num1+num2) //ERROR - 이렇게 작성할 수 없음. [숫자가 처음이라서]
println(nnn1.toString() + " + " + nnn2.toString() + " = " + (nnn1 + nnn2))//이렇게 형변환 하거나
println("" + nnn1 + " + " + nnn2 + " = " + (nnn1 + nnn2)) //이렇게 "" 빈 문자열을 먼저 써서 덧셈 해아함.

println("  $nnn1  +  $nnn2   =   ${nnn1 + nnn2} ") //이렇게 " " 사이에 $키워드로 변수명임을 표시하고 사용하는 방식 사용

var name = "sam"
var age = 20
println("이름 : $name \n나이 : $age")

// *출력*
//이름 : sam
//나이 : 20

var num:Int = 10
println(num)   //결과 : 10

var num2:Double = 3.14
println(num2)  //결과 : 3.14

var num3:Float
num3= 5.23f     //float형 실수형 숫자값은 뒤에 f 키워드 필요. 없으면 double 실수 값으로 인식하여 에러
println(num3)   //결과 : 5.23

num = 20;
num2 = 20.5
num3 = 10.88F   //float을 의미하는 F는 대소문자 구분없이 사용가능
println(num)    //결과: 20
println(num2)   //결과: 20.5
println(num3)   //결과: 10.88

num= 3.14  //ERROR   [Int변수에 Double대입]
num2= 50   //ERROR   [Double변수에 Int대입] - 자동형변환 없음

a= (Int)3.14 //ERROR 이런식의 자바 형변환 문법 없음.

num = 3.14.toInt()        // Double --> Int
num2 = 50.toDouble()      // Int --> Double  
println(num)      //결과: 3
println(num2)     //결과: 50.0

//문자열 String 객체
var s:String= "Hello"
println(s)      //결과: Hello

var s2:String= String("Hello") //ERROR - 단순 "문자열" 객체를 생성할때 String()생성자를 사용할 수 없음. [String() - String() 생성자는 Buffer나 byte 배열을 String객체로 생성할때만 사용함]

var str:String = "123"    //문자열 "123"
//var n:Int= str //error - Int변수에 String 대입 불가능

var m:Int = str.toInt()  // String --> Int 형변환 
println(m)    //결과: 123


var str2:String = "5.64"   //문자열 "5.64"   
var m2:Double = str2.toDouble()   //String --> Double 형변환
println(m2)   //결과: 5.64

val n1:Int= 100
//n1=200 //error - 읽기전용 val변수이기에 값을 변경하려하면 에러발생
println(n1)   //결과: 100

val n2:Boolean= true
//n2= false //error - 읽기전용 val변수이기에 값을 변경하려하면 에러발생
println(n2)   //결과: true

val n3:String     //val 변수를 만들면서 초기화를 하지 않음.
n3= "Nice"        //이때 "Nice"로 초기화 됨
//n3= "Good" //error - 값 변경 불가능
println(n3)  //결과: Nice

var aa=10 //Int
println(aa)

var bb=3.14 //Double
println(bb)

var cc=3.14f //Float
println(cc)

val dd=true //Boolean
println(dd)

val ee= 'A' //Char
println(ee)

val ff= "Hello" //String
println(ff)

var gg  //error   - 자료형을 추론할 수 없기에 오류
gg=10

val hh  //error   - 자료형을 추론할 수 없기에 오류
hh= "aaa"

var a3 = 5_000_000
println(a3) //출력: 5000000  출력은 그냥 원래대로 구분자없이 숫자만 보여짐

var v: Any     //Any타입의 참조변수 선언 - 어떤 값도 대입 가능
v = 10   //Int값 대입 
println(v) //출력: 10

v = 3.14       //Double형 값 대입도 가능
println(v) //출력: 3.14

v = "Hello"    //String 값 대입 가능
println(v) //출력: Hello

var n2: Int  = null   //ERROR
var s: String = null //ERROR

var nn: Int? = null       // Int 일까 ? 라는 물음표를 통해 null 일수도 있다는 표식을 추가
var s2: String? = null    // String 일까 ? 라는 물음표를 통해 null 일수도 있다는 표식을 추가
println(nn)   //출력: null
println(s2)   //출력: null

var bbb:String?= "Hello"    // String? 이기에 null값을 저장할 수 있는 non nullable variable
println( bbb.length )   //ERROR - null safety 연산자 필요

var bbb:String?= "Hello"   // String? 이기에 null값을 저장할 수 있는 non nullable variable
//println( bbb.length ) //ERROR - null safety 연산자 필요
println( bbb?.length )  //OK - null safety 연산자 ?.      출력: 5

var t = null  // --------- 자동 추론으로 Any? 로 지정됨
println(t) //출력 : null

println("Hello" + " Kotlin") //출력: Hello Kotlin

println( 10 + "Hello") //ERROR

println(10.toString() + " Hello")  //"10"+" Hello" -->  출력: 10 Hello

println("Hello" + 10)  //"Hello" + "10"  -->  출력: Hello10

var nnn1 = 50
var nnn2 = 30
//println( num1 +" + "+ num2 +" = " + num1+num2) //ERROR - 이렇게 작성할 수 없음. [숫자가 처음이라서]
println(nnn1.toString() + " + " + nnn2.toString() + " = " + (nnn1 + nnn2))//이렇게 형변환 하거나
println("" + nnn1 + " + " + nnn2 + " = " + (nnn1 + nnn2)) //이렇게 "" 빈 문자열을 먼저 써서 덧셈 해아함.

println("  $nnn1  +  $nnn2   =   ${nnn1 + nnn2} ") //이렇게 " " 사이에 $키워드로 변수명임을 표시하고 사용하는 방식 사용

var name = "sam"
var age = 20
println("이름 : $name \n나이 : $age")

// *출력*
//이름 : sam
//나이 : 20