fun main(){
//5. 배열 Array $ 컬렉션 Collection
//5.1) 요소의 개수 변경이 불가능한 배열: Array
//int[]aaa= new int[]{10,20,30};
// var aaa:Array<Int> = arrayOf(10,20,30) //띄어쓰기 무조건 하기!!***
var aaa= arrayOf(10,20,30) //자료형 자동 추론
println(aaa[0])
println(aaa[1])
println(aaa[2])
// println(aaa[3]) 실행 중 에러는 예외라 함.
println()
aaa[0]= 100
println(aaa[0])
println(aaa.get(0))
aaa.set(1, 200) //1번방을 200으로 바꿈 //대괄호가 권장사항
println(aaa[0])
println(aaa[1])
println(aaa[2])
println()
//배열의 요소개수
var len:Int =aaa.size
println("배열의 개수 : " +len)
println()
//반복문으로 요소값들 출력
for (i in 0 until aaa.size){
println(aaa[i])
}
println()
//for each
for (e in aaa){ //e는 요소..
println(e)
}
println()
for (index in aaa.indices){ //인덱스 번호..
println(index)
}
println()
for ((i,e) in aaa.withIndex()){ //인덱스번호+ 요소값
println("[$i] : $e")
}
println()
//특이점 )) Any 타입이 존재하기에..
var bbb= arrayOf(10,"sam",true) //자동 추론 -- Array<Any>
println(bbb[0])
println(bbb[1])
println(bbb[2])
println()
// println(bbb[0] + 5 ) //0번방에 정수값이 있지만, 타입을 Any로 인식하여 산술연산이 안됨
println(bbb[0] as Int + 5) //(참조형 자료형)형변환 연산자 as
//권장하진 않음.
//그래서 개발자들은 Any타입이 추론되는 것이 싫어서.. 명시적으로 자료형 표기함
// var ccc:Array<Int> = arrayOf(10,20,"sam") //error
var ccc= intArrayOf(10,20,30) //Int만 되는 배열..
//기본형 자료형은 xxxArrayOf()함수로 이미 존재함
var ddd= doubleArrayOf(3.14,5.54)
//혹시 요소의 값을 null로 주고 싶다면..
var eee: Array<Int?> = arrayOfNulls(3) //3칸짜리 빈 배열..
eee[0]=10
eee[1]=null
//* 배열은 요소의 개수를 변경할 수 없음.
/////////////////////////////////////////////////////////////////////////////////////////////////
//5.2) 요소의 개수 변경이 가능한 배열: Collection [ List, Set, Map ]
//코틀린의 컬렉션은 다시 2종류로 나뉨.
//5.2.1 )) 요소개수의 추가/삭제 및 값 변경도 불가능한 컬렉션 : listOf(), setOf(), mapOf()
//1] List
var list:List<Int> = listOf(10,20,30,20)
for (i in 0 until list.size){
// println(list.get(i))
println(list[i])
}
println()
// list.add() //이런기능 없음
// list[1]= 300 //변경도 안됨 error
//2] Set
var set:Set<Double> = setOf(3.14,5.55,2.22,5.55,1.24)
println("요소개수 : ${set.size}")
for (e in set) println(e)
println()
//3] Map
var map:Map<String,String> = mapOf(Pair("title","hello"), Pair("msg","nice to meet you"))
for ((k,v) in map) println("$k:$v")
println()
val map2:Map<String,String> = mapOf("id" to "mrhi","pw" to "1234")
for ((k,v)in map2) println("$k : $v")
println()
//5.2.2 )) 요소개수의 추가/삭제 및 값 변경도 가능한 컬렉션 : mutableListOf(), mutableSetOf(), mutableMapOf()
//자바의 ArrayList 역할..
//1] MutableList
val aaaa: MutableList<Int> = mutableListOf(10,20,30)
println("요소개수 : ${aaaa.size}")
aaaa.add(40)
aaaa.add(0,50)
println("요소개수 : ${aaaa.size}")
aaaa[1] =200
for (i in 0 until aaaa.size) println(aaaa[i])
println()
//2] MutableSet
val bbbb:MutableSet<Double> = mutableSetOf()
println("요소개수 : ${bbbb.size}")
bbbb.add(3.14)
bbbb.add(5.55)
bbbb.add(3.14)
println("요소개수 : ${bbbb.size}")
//3] MutableMap
val cccc= mutableMapOf<String,String>()
println("요소개수 : ${cccc.size}")
cccc.put("name","sam")
cccc.put("addr","seoul")
cccc.put("addr","busan")
println("요소개수 : ${cccc.size}")
for ((k,v)in cccc) println("$k : $v")
println()
println(cccc.get("name")) //싫어함
println(cccc["addr"])
println()
//2차원 배열
var sss= arrayOf(arrayOf(10,20,30), arrayOf("aa","bb"), arrayOf(true,false,true))
for (arr in sss){
for (e in arr){
print("$e , ")
}
println()
}
println()
}
fun main(){
//6. 함수 Function (자바는 메소드)
show()
show()
output(100,"hello")
var sum:Int= sum(5,3)
println(sum)
println()
//리턴을 안하는 함수의 리턴값은? 코틀린은 명시적으로 리턴을 안하면 Unit 이라는 객체가 리턴
var x= display()
println(x)
println()
/////////////////////////////////////////////////////////////////////////////////////
//코틀린의 특이한 함수 정의 문법소개.. 귀차니즘에서 비롯.. 함수의 단순화
val data= getData()
println(data)
val data2= getData2()
println(data2)
val data3= getData4(15)
println(data3)
val data4= getData4(25)
println(data4)
println()
///////////////////////////////////////////////////////////////////////////////////////
//익명함수
aaa()
//함수를 저장하고 있는 변수의 이름을 통해 함수를 호출할 수 있음.
bbb()
println(bbb)
ddd("ANDROID")
println(eee(10))
println(fff(20))
ggg()
jjj("sam",20)
println(kkk(15))
println(kkk(25))
//함수형 언어의 특징은 함수를 객체처럼 변수에 대입하여 사용 가능
//조금 더 확장해 보면, 변수의 값을 다른 변수에 대입할 수도 있음.
mmm()
nnn()
//고차함수 : 함수의 파라미터가 다른 함수를 받는 함수
sss("hello",fun(){ println("고차함수..") })
sss("hello",fun(){ println("고차함수2..") })
val f={
println("fffff")
}
sss("nice",f)
}
fun sss(a:String,b:()->Unit){
println("a : $a")
b()
}
var mmm:()->Unit=fun(){
println("mmm익명함수")
}
var nnn:()->Unit=mmm
//fun()을 생략하면, 리턴 키워드 생략
var kkk:(Int)->String={
if (it<20) "미성년"
else "성인"
}
var jjj:(String, Int)->Unit = {name,age->
println(name+""+age)
}
var iii:(String)->Unit= {
println(it.length)
}
//파라미터가 있는 익명함수의 fun() 생략
var hhh:(String)->Unit = {s->
println(s.length)
}
//익명함수의 fun()를 쓰는 것도 귀찮음..
var ggg= {
println("gggggg")
}
var fff:(Int)->Int =fun (num:Int):Int{
return num*2
}
var eee=fun (num:Int):Int{
return num*2
}
var ddd:(String)->Unit= fun(s:String){
println("글자수 : ${s.length}")
}
var ccc:()-> Unit = fun(){ //함수의 자료형: (파라미터)->리턴타입 **
println("익명함수2..")
}
//fun (){ //익명함수.. 단, 이름이 없기에 그냥 쓰면 에러
//
//}
var bbb= fun (){
println("익명 함수..")
}
fun aaa(){
println("aaa")
}
fun getData4(num: Int):String = if (num<20) "미성년자" else "성인"
fun getData3(num:Int):String{
if (num<20)return "미성년자"
else return "성인"
}
fun getData2():String= "nice" //할당연산자로 return을 대신함.
fun getData():String{
return "hello"
}
fun display(){
println("display...")
println()
}
fun sum(a:Int,b:Int):Int{ //리턴타입을 함수명()뒤에 : 하고 명시!!
return a+b
}
fun output(a:Int,b:String){ //var, val 키워드 사용금지 !! 무조건 val로 됨 , 자료형 필수!!***
println(a)
println(b)
}
//함수 문법
fun show(){
println("show function")
println()
}
fun main(){
//객체지향
//연관있는 데이터끼리 묶어서 관리하는 기법 - class[설계도면]
//class를 실제로 사용하기 위해 객체 생성
var obj:MyClass =MyClass() //OBJ 참조변수
obj.show()
var obj2= MyClass()
obj2.a=20
obj2.show()
var obj3:MyKotlinClass = MyKotlinClass()
obj3.show()
var obj4:MyKotlinClass = MyKotlinClass()
obj4.a=100
obj4.b=200
obj4.show()
//생성자.. 자바라 너무 다름.!!*******************
//생성자의 종류 2개 : 주생성자, 보조생성자 (프라이머리, 세컨더리)
var s:Simple= Simple()
var s2:Simple2= Simple2(100,200)
s2.show()
//주생성자는 오버로딩이 불가능.!!
// Simple2(10)
//그래서 보조 생성자 등장!!!***
var s3:Simple3 = Simple3()
s3.show()
var s33:Simple3= Simple3("sam",20)
s33.show()
var s4:Simple4= Simple4("ROBIN",25) //주
s4.show()
var ss4:Simple4 = Simple4() //보조
ss4.show()
}
//주생성자 + 보조생성자
class Simple4 constructor(var name:String,var age:Int){
fun show(){
println("$name : $age")
}
//주생성자의 오버로딩 생성자 - 보조생성자를 사용 [주 생성자와 함께 있다면, 주생성자를 호출해야함.]*****
constructor():this("익명",-1){
}
}
class Simple3{
var name:String=""
var age:Int= 0
//보조생성자
constructor(){
println("simple3 보조생성자")
}
//보조생성자 오버로딩 - 보조생성자는 주생성자처럼 파라미터면서 멤버변수인 것을 만들 수 없음.
constructor(name: String,age: Int){
println()
this.name=name
this.age=age
println("simple3보조 생성자 -오버로팅")
}
fun show(){
println(name+": "+age)
}
}
//이런식으로 간결하게 데이터 클래스를 설계할 수 있음.
class Item constructor(var name:String, var age:Int) //constructor 생략가능
//주생성자의 값을 전달 - 주생성자의 var, val키워드를 붙이면 , 파라미터면서 멤버변수임.
class Simple2 constructor(var num:Int, num2:Int){ //var키워드가 없으면 주생성자의 지역변수임.
init {
println("simple2 객체를 생성!!")
// num2= 300 파라미터는 무조건 val...
println(num2)
}
fun show(){
println("멤버변수 num: $num")
// println(num2) //error
}
}
//주생성자 (primary constructor)
class Simple constructor(){
//주 생성자가 호출될 때 실행될 영역
init {
println("Simple 객체 생성!")
}
}
class MyClass{
//멤버변수 [Property: 프로퍼티] - 반드시 초기화 해야만 함
var a:Int= 10
//멤버함수 [Method : 메소드]
fun show(){
println("a : $a")
println()
}
}
class MyKotlinClass { //설계도면
//property
var a:Int=10
var b= 20
//method
fun show(){
println(a)
println(b)
println()
}
}