bluish wolf

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

문자열: 문자(Char)들을 일렬로 나열한 것

String: 문자열을 저장할 수 있는 타입, 문자 여러개를 큰 따옴표로 감싸면 그 부분은 String 타입이 된다.

package com.practice011

fun main(args: Array<String>): Unit
{
	var str: String = "Hello"
	println(str)	// 출력: Hello

	str = str + "\nKotlin!"
	println(str)	// 출력: Hello\nKotlin!

	println(str[8])	// 출력: t

	val num = 10 * 5 + 3	// 53으로 만든다.
	println(str + num)	// String에 String아닌값을더하면, String으로 출력: Hello\nKotlin!53
}

출력

Hello
Hello
Kotlin!
t
Hello
Kotlin!53

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/index.html

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

문자타입: 문자를 저장할 수 있는 타입

package com.practice010

fun main(args: Array<String>): Unit
{
	var ch: Char = 'A'
	println(ch)		// 출력: A

	ch = '\uAC00'	// 유니코드 사용
	println(ch)		// 출력: 가

	ch = '한'
	//println(ch.toInt())	// 출력 54620, 유니코드 매핑되는 int값
}

'A'  : 문자 한개를 작은따옴표로 감싸면 char 타입 

'\uAC00' : 코틀린에서는 Unicode 사용

https://home.unicode.org/

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice009

fun main(args: Array<String>): Unit
{
	println(0.1f + 0.1f + 0.1f)		//출력 : 0.3
	println(0.1f + 0.1f + 0.1f + 0.1f + 0.1f + 0.1f + 0.1f + 0.1f + 0.1f + 0.1f)	
	// 출력: 1.0000001
	// 0.1 을 10번 더했다고 1이 아닌 1.0000001 이 출력된다.연산할수록 오차가 거듭되기때문에
	println(0.1f * 10)	// 출력: 1.0, 곱하기 연산은 1번이기때문에 온전하게 값이 출력
}

실수 값은 2진수 유효숫자로 표현되기 때문에 때에 따라 정한 값을 가리킬 수 없다.

실수계산시에는 대략적인 값만 얻을수도 있음

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

출처: https://kotlinlang.org/docs/reference/basic-types.html

정수를 저장할수 있는 타입 Int, 실수를 저장할 수 있는 Double 타입이외도 더 많은 종류의 타입이 존재.

부동소숫점 방식 Floating Point: 실수를 표현하는 방식. 

package com.practice008

// 소실수를 표현하는 방식: 부동소수점(Floating Point) 방식

fun main(args: Array<String>): Unit
{
	val a: Byte = 125	// Byte타입 변수 선언, Int 타입이지만, Byte범위내라서 ok
	val b: Short = (100 + 200) * 100	//Short 타입변수 선언, 소괄호먼저, 범위내 ok
	var c: Int = 12_4354_6538	// Int 타입변수 선언, 언더스코어(_)는 숫자를 좀더 알아보기 쉽게표현, 
	//println(c)	// 고대로출력해보면 , 1243546538 나온다
	c = 0xFF_88_88	// 변수 c에 담긴 값을 16진수로 인식 
	c = 0b01010010_01100011_01110101_01000101	// 2진수로 인식
	var d: Long = -543_7847_3984_7238_4723	// Long 타입변수 선언, Int값을 넘으면 자동으로 Long타입

	c = a + b	// Int 타입 = Byte타입+Short타입, 결과는 byte와 short 모두 int 범위내이므로 결과는 Int타입
	d = c + 10L	// 정수값(정수리터럴)에 L을 붙이면 무조건 Long타입이 된다. 결과값도 long 범위내이므로 long타입

	var e: Float = 67.6f	// f를 붙이는건 float 타입 
	val f: Double = 658.4	// Doulbe 선언과 동시에 저장
	e = (e + f).toFloat()	// e+f를 더하면 Double타입 720.056 이 나오기때문에 float 타입으로 e를 변환
	println(e)		// 출력 : 726.0, 기존에 저장된 67.6은 지워진다.
}

출력

726.0

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice007

// 비트 연산자
fun main(args: Array<String>): Unit
{
	println(15 and 7)	// 15와 7을 비트단위로 and 연산 , 15&7, 출력 7
	println(5 or 2)		// 5와 2를 비트단위 or 연산, 5|2, 출력 7
	println(15 xor 5)	// 15와 5를 비트단위 xor 연산, 15^5 ,출력 10
	println(32767.inv())	// 32767를 비트단위로 반전, 출력 -32768
	println(1 shl 3)	// 1을 왼쪽으로 3칸 시프트, 1<<3 , 출력 8
	println(8 shr 1)	// 8을 오른쪽으로 1칸 시프트, 8>>1, 출력 1
	println(-17 ushr 2)	// 부호 유지하고, -17을 오른쪽 2칸 시프트, -17 >>>2 , 출력  1073741819
}

## 코틀린의 비트연산자는 기존의 익숙한 c/c++ 이나 java와 다르게 문자로 되있다.

ddshl - signed shift left (equivalent of << operator) 
shr - signed shift right (equivalent of >> operator) 
ushr- unsigned shift right (equivalent of >>> operator) 
and - bitwise and (equivalent of & operator) 
or - bitwise or (equivalent of | operator) 
xor - bitwise xor (equivalent of ^ operator) 
inv - bitwise complement (equivalent of ~ operator)

## 추가 샘플 코드

1 shl 2   // Equivalent to 1.shl(2), 출력 = 4
16 shr 2  // 출력 = 4
2 and 4   // 출력 = 0
2 or 3    // 출력 = 3
4 xor 5   // 출력 = 1
4.inv()   // 출력 = -5

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

## 코틀린의 증감 연산자는 다른 언어와 비슷하다 

package com.practice006

// 증감연산자
fun main(args: Array<String>): Unit
{
	var a = 10
	var b = 5

	println(a++ + b)	// a 후위 증가 연산 > b 더한 값 출력 , 15
	println(a)	// a는 이미 증가된 상태라 11
	println(--b)	// 전위 감소하고 난 뒤의 b는, 4

	10.inv()
}

## 출력은 아래와 같다 

15
11
4

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice005

fun main(args: Array<String>): Unit
{
	// + 더하기, - 빼기, * 곱하기, / 나눈 값 몫, % 나눈 나머지 값
	val num: Int = 15 -4 * 3
	val num2: Int = 65 % 7
	val num3: Double = 7.5/5+22.25
	//	val num4: Double = num/num2 + 0.7
	// int 와 double은 상속 관계가 아니므로 캐스팅이 안됨. 그래서 toDouble메소드를 사용해서 변환
	val num4: Double = num.toDouble() /num2 + 0.7
	
	println(num)
	println(num2)
	println(num3)
	println(num4)
}

val num: Int = 15 -4 * 3    [출력: 3]

val num2: Int = 65 % 7     [출력: 2]

val num3: Double = 7.5/5+22.25   [출력:23.75]

// val num4: Double = num/num2 + 0.7 

// int 와 double은 상속 관계가 아니므로 캐스팅이 안됨. 그래서 toDouble메소드를 사용해서 변환해야 한다.

val num4: Double = num.toDouble() /num2 + 0.7   [출력: 1.7]

num(int타입).toDouble (double 타입으로 변환) 

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice004

fun main(args:Array<String>): Unit
{
	val variable = 10 + 12 - 5
	println(variable)
}

변수 뿐만 아니라 리터럴에도 타입이 있다.

그래서 표현식의 결과 값에도 타입이 생긴다. 표현식의 타입을 이해하는게 중요하다.

왜냐하면 변수에 값을 저장하려면 그 변수의 타입과 표현식의 타입이 일치해야한다.

예를 들면 val something:Double = 결과 값이 Double 인 표현식만 가능 

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice003

fun main(args: Array<String>): Unit
{
	// var: 변수 키워드, total: 변수이름(식별자), Int: 변수의 타입
	// var total: Int =0 //처럼 한줄로 선언하고 초기화도 가능하다.
	// 아래 구문은 var 키워드로 total이라는 식별자가 변수를 뜻하고,
    // 그 타입이 Int라고 컴파일러에게 알림	
	var total: Int
	total = 0
	
	// var 는 일반 변수 이고, val은 final 변수로 생각하면 된다.	
	val a: Int = 10 + 53 - 7
	println(a)
	
	val b: Int = 43 + 75 + a
	println(b)
	
	total = a+b
	println(total)
}

변수Variable: 값을 저장해놓은 메모리 공간 

식별자Identifier: 위 코드의 total 처럼 임의로 지어낸 이름. 

        (영문자, 숫자, 언더스코어 _로만 가능, 단 숫자는 맨 앞 금지)

변수 선언의 다음 형태를 기억

var total : Int

var : 변수 키워드

total : 변수 이름 (식별자)

Int 변수 타입

val 키워드: val 로 선언된 변수는 한번 값을 저장하면 나중에 값을 수정할 수 없다.(자바의 final 변수)

var 키워드: 값 수정이 가능하다. (자바의 일반변수)

출처: 초보자를 위한 코틀린(Kotlin) 200제 / 엄민석 지음 | 정보문화사 | 2018년 05월 20일 출간

package com.practice002

fun main(args: Array<String>): Unit
{
	// java와 다르게 단독 표현식  허용
	// 리터럴(Literal): 숫자 자체를 나타내는 부분: 53, 62, 126
	// 연산자Operator: +, -, *, /, %
	//53+62-126
	println(53+62-126)
}

리터럴Literal: 53, 62, 126과 같이 숫자 값 자체를 나타내는 부분

연산자Operator : + 와 - 처럼 계산을 수행하는 기호

피연산자Operand: 각 연산자 양 옆의, 계산을 수행하기 위한 재료가 되는 부분

즉 53, 62, 126은 리터럴이면서 피연산자.

표현식Expression: 53+62-126 처럼 피연산자와 연산자로 이루어진 덩어리가 하나의 값으로 되는 것