Kotlin
- 카멜 표기법을 권장한다.
001 변수와 자료형
- var 변경이 가능
- val 변경이 불가능
- class 매부 프로퍼티 : 속성
- 그외 로컬 변수라고 한다.
- 자료형? 를 사용할경우 null을 혀용하겠다는 의미로 사용된다.
package Kotlin2020
fun main(args : Array<String>){
val a: Int = 10 // variable : 변할 수 있는 변수 방법 -> let (js)
val b: Int = 20 // value : 변할 수 없는 변수 선언 방법 -> const (js)
val c: Char = 'a';
val s: String = "String 입니다";
val f: Boolean = true;
}
002 형변환과 배열
- 형변환을 하기 위해서는 to자료형() 형변환 함수를 지원
- 암시적 형변환을 지원하지 않습니다.
- 명시적 형변환 : 변환될 자료형을 개발자가 직접 지정
package Kotlin2020
fun main(args: Array<String>) {
var intArr = arrayOf(1,2,3,4,5)
val nullArr = arrayOfNulls<INT>(4)
intArr[2] = 8
println(nullArr[2])
}
003 타입추론과 함수
- 자료형이 없이 변수를 초기화 한다면 알아서 추론된다.
- 함수 : 특정한 동작을하거나 원하는 결과값을 가지기 위해서 사용한다.
- 단일표현식 함수 : fun add2(a: Int, b: Int, c:Int) = a + b + c
package Kotlin2020
fun add(a: Int, b: Int, c:Int): Int{
return a + b + c
}
fun add2(a: Int, b: Int, c:Int) = a + b + c
fun main(args: Array<String>) {
val result: Int = add(10,20,30)
println(result)
}
004 조건문과 비교연산
- if ~ else : 중괄호를 한 줄 이라면 생략이 가능하다.
- 비교연산자 ( >, <, >=, <=, ==)
- 자료형 ( 변수 is 자료형 ) 자료형이 맞는지 확인
- 다중 조건문 when -> swich 문과 비슷 하다고 생각하면된다.
package Kotlin2020
fun main(args: Array<String>) {
var a = 10;
if(a> 100){
println("$a 입니다.")
}else{
println("안뇽 만나서 반가웡")
}
doWhen(1)
doWhen("GI")
doWhen(12L)
doWhen(12.3)
}
fun doWhen(a: Any){
when(a){
1-> println("1 입니다.")
"GI"-> println("GI 입니다.")
is Long -> println("Long type 입니다.")
!is Long -> println("logn type이 아닙니다.")
else -> println("어떤 조건도 만족하지 않습니다.")
}
}
005 반복문과 증감연산
- ++, --
- ++v 전위 연산자 : 값을 증가시키고 적용시킨다
- v++ 후휘 연산자 : 실행하고 다음에 값을 증가 시킨다.
package Kotlin2020
fun main(args: Array<String>) {
var a = 0;
while(a < 5){
println(++a) // 1,2,3,4,5
}
println()
a = 0
while(a < 5){
println(a++) // 0,1,2,3,4
}
println()
for(i in 0..10){
println(i)
}
println()
for(i in 0..10 step 3){
println(i)
}
println()
for(i in 100 downTo 30 step 30){
println(i)
}
}
006 논리연산자
- &&, ||, !
package Kotlin2020
fun main(args: Array<String>) {
for(i in 1..10){
if(i == 3) break;
println(i)
}
for(i in 1..10){
if(i == 3) continue
println(i)
}
loop@for(i in 1..10){
for(j in 1..10){
if(i == 2 && j == 4 ) break@loop
println("$i : $j")
}
}
}
007 클래스
- *var, val 등을 붙이면 자체 속성으로 선언이 된다.
- 클래스는 그 값과 그 값을 사용하는 기능을 묶어 놓은 것이다.
- 속성 + 함수(메소)로 구현되어 있다.
- 생성자 : 새로운 인스턴스를 만들기 위해 호출하는 함수.
- 인스턴스 생성시 필요한 구문을 하도록 한다. init 함수
- 보조생성자 : 기본생성자와 다른 생성자를 제공하여 인스턴스 생성시 편의를 제공하거나 추가적인 기능을 제공하는 역할을 합니다.
- constructor 키워드 사용
- 기본 생성작의 초기값을 주고 사용을 원할때만 사용하는게 좋아 보인다
- class Person(var name : String, var age: Int) 라고한다면
- construcor(name: String):this(name, 39) => 만약 나이를 넣지 않고 초기화 한다면 기본값을 39 로 하겠다.
package Kotlin2020
fun main(args: Array<String>) {
val person1 = Person("gi", 920105,1)
val person2 = Person("vv", 920106, 2)
val person3 = Person("dj", 920106, 3)
val person4 = Person("cc", 920106, 29)
person4.greeting()
// person1.greeting()
}
//이렇게 변수 키워드를 적어줘야 함수 내부에서 변수로 사용이 가능합니다.
class Person(var name: String , val birthDay : Int, var age:Int){
init{
println("${this.name} , ${this.birthDay} $age")
}
//보조 생성자를 사용하기 위해서는 무조건 기본 생성자를 초기화를 해줘야 한다. :this(기본생성자의 필요)
constructor(name: String, age:Int):this(name, 1997, age){
println("보조 생성자가 사용되었습니다.")
println("${name} 입니다. -> ${birthDay} : ${age}")
}
fun greeting(){
println("${name} 입니다. -> ${birthDay}")
}
}
006 클래스 상속
- 기존 클래스를 확장하여 새로운 속성이나 함수를 만들어야 할 떄
- 공통점을 뽑아 관리를 편하게 하기 위해서
- super class & sub class
- 'open' 상속을 허용하기 위한 키워드
- 서브클래스는 수퍼 클래스에 존재하는 속성과 '같은 이름'의 속성을 가질 수 없음
- 그렇기 때문에 생성시 처기값에 변수 키워드(var, val)를 사용하지 않는다.
- 서브 클래스가 생성될 때는 반드시 수퍼클래스의 생성자까지 호출되어야 한다.
- class 자식클래스 () : 부모클래스() {}와 값이 사용해서 꼭 부모 클래스의 초기 값을 전달해 줘야 한다.
- 서브클래스는 수퍼 클래스에 존재하는 속성과 '같은 이름'의 속성을 가질 수 없음
- 자식 클래스만의 독자적인 기능 추가하는 것이 가능핟.
package Kotlin2020
fun main(args: Array<String>) {
val a = Animal("동물", 2,"고래")
val dog1 = Dog("멍멍이", 5)
val cat1 = Cat("나폴레옹",2)
a.greeting()
println()
dog1.greeting()
dog1.bark()
println()
cat1.greeting()
cat1.bark()
}
open class Animal(var name: String, var age: Int, var type: String){
fun greeting(){
println("안녕 하세요 ${name} 입니다. ${age}, ${type} 입니다.")
}
}
class Dog(name: String, age: Int ) : Animal(name, age, "dog"){
fun bark(){
println("$name bow - bow ")
}
}
class Cat(name: String, age: Int) : Animal(name, age, "cat"){
fun bark(){
println("${name} mew - mew")
}
}
007 오버라이딩과 추상화
-
수퍼클래스에서 허용만 한다면 같은 이름과 형태를 가진 함수를 재정의 할 수 있다
-
추상화란? : "abstract" 키워드 사용 -> 무조건 오버라이팅 해줘야 해야 한다.
- 선언부만 있고 깃능이 구현되지 않은 추상함수
- "추상함수"를 포함하는 "추상 클래스"로 구성된다.
-
인터페이스 사용가능 : 구현부가 있는 함수 + 없는 함수를 동시에 사용하능하나 생성자가 없을 뿐이다. -> 자바랑은 조금 다른 부분이네
- 인터페이스에서 구현부가 있는 함수 : open 함수로 취급 -> 오버라이딩 가능
- 인터페이스에서 구현부가 없는 함수 : abstract 함수로 취급 -> 무조건 구현 해줘야 한다.
- 그렇기 때문에 키워드를 사용하지 않아도 된다.
- 또 한 여럿 인터페이스를 상속 받을 수 있다.
-
오버라이딩은 이미 구현이 끝난 함수의 기능을 서브 클래스에서 변경해야 할 때 그리고 추상화는 실제 구현은 서브클래스에서 일임할 때 사용하는 기능이며
인터 페이스는 서로다른 기능들을 구현할 때 여러개를 물려주어야 할 떄 유용한 기능입니다.
package Kotlin2020
fun main(args: Array<String>) {
val t = Tiger()
t.eat()
t.eat("고기")
val c = Benz()
c.drive()
c.stop()
println()
val m = Me()
m.eat()
m.run()
}
open class Animal {
open fun eat() {
println("음식을 먹습니다.")
}
}
class Tiger : Animal() {
fun eat(food: String) {
println("${food}를 먹습니다.")
}
override fun eat() {
println("타이거가 음식을 엄청나게 맛나게 먹고 있습니다.")
}
}
abstract class Car {
abstract fun drive()
fun stop() {
println("정지 합니다.")
}
}
class Benz : Car() {
override fun drive() {
println("자동차가 출발 합니다.")
}
}
interface Runner {
fun run()
}
interface Eater {
fun eat() {
println("음식을 먹습니다.")
}
}
class Me : Runner, Eater {
override fun run() {
println("달리기하기")
}
override fun eat(){
println("dkdkdk")
}
}
008 변수, 함수, 클래스의 접근범위와 접근제한자는?
- 스코프와 접근제한자.
- 스코프 외부에서는 스코프 내부의 멤버를 '참조연산자(.)'로만 접근이 가능하다.
- 동일 스코프 내에서는 멤버들을 공유 할 수 있다.
- 접근제한자 : 변수, 함수, 클래스, 맨 앞에 붙여 사용됩니다.
- public, internal, private,protected
- 패키지 스코프에서
- public(기본값) : 어떤 패키지에서도 접근 가능.
- internal : 같은 모듈 내에서만 접근 가능.
- private : 같은 파일 내에서만 접근이 가능.
- protected : 사용하지 않음.
- 클래스 스코프에서는
- public(기본값) : 클래스 외부에서 늘 접근 가능
- private : 클래스 내부에서만 접근 가능
- protected : 클래스 자신과 상속받은 클래스에서 접근 가능
- internal : 사용하지 않음.
package Kotlin2020
val a1 = "피키지 스코프"
class B {
val a = "스코프 a class"
fun print(){
println(a)
}
}
fun main(args: Array<String>) {
var a1 = "함수 스코프"
println(a1)
B().print()
}
009 고차함수와 람다 함수
- 고차함수는 함수를 변수처럼 사용가능하다는 느낌이며, ::함수명 으로 사용한다.
- 즉, 변수가 되는 쪽이 고차함수 입니다.
- 고차함수 함수를 '인스턴스처럼' 취급하는 방법
- 함수를 '파라미터'로 넘겨 줄 수 있다.
- '결과값으로 반환' 받을 수 있는 방법이다.
- 함수의 형식을 자료형으로 나타내기
- (자료형, 자료형) -> 반환형
- b(::a)와 같이 ::a 파라미터로 전달할 함수 로 사용
- 람다함수
- 람다함수는 그 자체가 고차 함수이다.
- 별도의 연산자 없이도 변수에 담을 수 있다.
package Kotlin2020
fun main(args: Array<String>) {
b(::a)
val c : (String) -> Unit = {str:String
-> println("$str <-- 이거는 람다 함수에서 실행")
}
b(c)
}
//1. 파라미터로 받아보기
fun a(str: String){
println("$str <-- 이거는 a의 값입니다.")
}
//2. 고차함수의 파라미터로 받아볼수 있도록 한다.
//기술한 형태와 같은 형식의 함수는 모두 파라미터로 받을 수 있다.
fun b(function: (String) -> Unit){
function("b의 값이 들어 갔어")
}
011 스코프 함수
- 람다 함수도 여러 구문의 사용이 가능하다.
- 여러줄로 표현이 가능하며, 마지막 줄이 반환 값이 된다.
- 파라미터가 없다면, 실행할 구문만 나열하면 된다.
- val c : () -> Unit = {println("Hello world")}
- 파라미터가 하나 뿐이라면 it 사용이 가능하다.
- val c : (String) -> String = { "$it 반값 습니다"}
- 스코프함수란?
- 함수형 언어의 특징을 좀 더 편리하게 사용할 수 있도록 기본 제공하는 함수들
- 클래스의 인스턴스를 '스코프함수'에 전달하면, 인스턴스의 속성이나 함수를 스코프 함수 내에서 편하게 사용할 수 있도록 하는 기능
- apply, run, with, also, let
- apply : 인스턴스를 생성한 후 변수에 담기전에 초기화 과정을 수행할 떄 사용하며, 인스턴스를 다시 반환한다. 인스턴스를 생성할 때 인스턴스의 값에 변화를 준 다음 생성하기를 원할 때 사용한다.
- run : apply와 마찬가지로 참조 연산자를 사용하지 않도 된다는 것은 같으나, 일반 람다 함수 처럼 맨 마지막의 결과 값을 리턴 한다. 인스턴스가 만들어 진후에 인스턴스의 함수나 속성을 스코프 내에서 사용해야 할 때 유용하다.
- with : run 과 동일한 기능을 하나, 사용법만 다르다. with(a){} 이렇게 인스털스를 파라미터로 받는다.
- also / let: apply와 run과 같은 동작을 하는 스코프 함수이나, 해당 스코프 외부에서 선언된 변수가 있다면 그 변수를 우천 참조하기 때문에 자신의 변수를 it. 키워드를 참조하여 접근한다.
- 함수형 언어의 특징을 좀 더 편리하게 사용할 수 있도록 기본 제공하는 함수들
package Kotlin2020
fun main(args: Array<String>) {
val a = Book("GIBOOK", 30000).apply {
name = "[초특가]"+name
discount()
}
println(a.name)
println(a.price)
println()
println("여기 아래서 부터는 run을 사용한 값을 출력하는 부분 입니다.")
// let를 사요해보기
val price = 1000 // 이렇게 선언 할 경우 아래 run 스코프 내부에서 불러지는 price 값이 되어 버려
// 기존 인스턴스의 값을 불러 올 수 없게 된다.
// 이렇때는 let 스코프 함수를 사용하여 it. 으로 접근할 수 있도록 처리 한다.
val letResult : String = a.let{
it.discount()
"현재 ${it.name}책 값은 ${it.price} "
}
val runReuslt : String = a.run{
discount()
"현재 ${name}책 값은 ${price} "
}
println(letResult)
println(runReuslt)
println()
val b: String = Book("AM_BOOK",100000).run{
name+" LOVE"
}
println(b)
}
// apply 사용해보기
class Book(var name : String, var price: Int){
fun discount(){
price -= 2000
}
}
012 오브젝트
- 생성자 없이 객체를 직접 만들어내는 object
- 클래스는 인스턴스 객체를 만들어 내기위한 틀이기 때문에 내부에 있는 속성이나 함수를 사용하기 위해서는
생성자를 통하여 실체가 되는 인스턴스 객체를 만들어 사용해야 한다. - 그러나 여러개의 인스턴스를 만들 필요없이 하나의 객체 만으로 공톡적인 속성과 함수를 사용해야하는
코드에서는 굳이 class를 사용할 필요 없이 사용이 가능하다. - 클래스 내부에서도 object(Companion Object) 를 만들어 사용할 수 있다.
- 클래스의 인스턴스 기능은 그대로 사용하면서 인스턴스 간에 공통으로 사용할 속성과 함수를 만드는 기능이다.
- 기존의 Static 멤버 : 클래스 내부에서 별도의 영역에 고정적으로 존재하여 인스턴스를 생성하지 않아도 공용으로 사용 가능한 속성이나 함수 라고 볼 수 있다.
package Kotlin2020
import java.util.zip.CheckedOutputStream
object Counter {
var count = 0;
fun up() {
count++
}
fun down() {
if (count > 0) {
count--
}else{
print("count의 최솟값인 0 입니다.")
}
}
}
fun main(args: Array<String>) {
println(Counter.count)
Counter.up()
Counter.up()
Counter.up()
println(Counter.count)
Counter.down()
Counter.down()
Counter.down()
Counter.down()
val ja = foodPoll("짜장")
val jm = foodPoll("짬뽕")
ja.counter()
ja.counter()
ja.counter()
jm.counter()
println()
println("ja : ${ja.count}")
println("jm : ${jm.count}")
println("Total : ${foodPoll.total}")
}
class foodPoll(val name : String){
companion object {
var total = 0
}
var count = 0
fun counter(){
total++
count++
}
}013 옵져버 패턴
- 이벤트가 일어나는 것을 감시하는 감시자.
- 키의 입력, 터치의 발생, 데이터의 수신등 함수로 직접 요청하지 않았지만 시스템 또는 루틴에 의해서 발생하게되는 동작들을 '이벤트'라고 부르며
이 이벤트가 발생할 떄만다 '즉각적으로 처리'할 수 있도록 만드는 패턴을 '옵저버 패턴이라고 부른다'
- 키의 입력, 터치의 발생, 데이터의 수신등 함수로 직접 요청하지 않았지만 시스템 또는 루틴에 의해서 발생하게되는 동작들을 '이벤트'라고 부르며
- 두 개의 클래스가 필요하다.
- 이벤트를 수신 하는 클래스 / 이벤트의 발생 및 전달을 하는 클래스
- 두 개의 클래스 사이에 인터페이스를 끼워넣어 주며 이를 '옵져버' 코틀린에서는 '리스너'라고 부른다.
package Kotlin2020
fun main(args: Array<String>) {
EventPrinter().start()
}
/*
* 1. 이벤트를 수신해서 출력하는 EventPrinter
* 2. 숫자를 카운트 하며 5의 배수 마다 이벤트를 발생시킬 Counter
* 3. 두 개를 연결시킬 인터페이스 EventListener 를 만들어 본다.
*
* */
//이벤트가 발생할 때 숫자를 반환해 준다.
interface EventListener {
fun onEvent(count: Int) // 추상함수 만들기.
// 리스너를 통해 이벤트를 반환하는 함수 이름은 관례적으로 'on'이라는 규칙을 따른다.
}
//이 벤트가 발생하는 Counter 클래스의 구현.
class CounterEvent(var listener: EventListener) {
fun count() {
for (i in 1..100) {
if (i % 5 == 0) listener.onEvent(i)
}
}
}
// 이벤트를 전달 받아 화면에 출력할 EventPrinter 클래스의 구현.
class EventPrinter:EventListener{
override fun onEvent(count: Int) {
print("${count}-")
}
fun start(){
val counter = CounterEvent(this) // * this는 키원드가 사용된 '객체 자신'을 참조하는 키워드 입니다.
//EventPrinter 객체 자신을 나타내지만 받는쪽에서는 이벤트 리스너만 요구했기 떄문에
//이벤트 리스너 구현부만 넘겨 주게 된다.
//이를 객체지향의 다형성 이라고 한다.
counter.count()
}
}
///////////////////////////익명 객체 방법
class EventPrinter{
fun start(){
val counter = CounterEvent(object : EventListener{
override fun onEvent(count: Int) {
print("${count}-")
}
})
counter.count()
}
}
014 다형성
- 콜라를 콜라 자체로 볼 수 있지만 음료라는 개념으로도 볼 수있게 만드는 것이 '디형성'의 개념이다.
- up-casting / down-casting
- down-casting 별도의 연산자 필요 as / is
- as : 변수를 호홛되는 자료형으로 변환해주는 캐스팅 연산자로
- var a : Drink = Cola() -> a as Cola : 콜라의 자료형이 된다.
- is : 변수가 자료형에 호환되는지를 먼제 '체크한 후 변환'해주는 개스팅 연산자로
- 조건문 내에서 사용되는 특직이 있다. if (a is Cola){}
package Kotlin2020
fun main(args: Array<String>) {
var a = Drink()
a.drink()
var b : Drink = Cola()
b.drink()
if(b is Cola){
b.washDishes()
}
var c = b as Cola
c.washDishes()
b.washDishes()
}
open class Drink{
var name = "음료"
open fun drink(){
println("${name} 마십니다.")
}
}
class Cola : Drink(){
var type = "콜라"
override fun drink() {
println("$name 중에 $type 을 마십니다.")
}
fun washDishes(){
println("${type}로 설거지를 합니다.")
}
}
015 제너릭
- 함수나 클래스를 선헌할 때 고정적인 자료형 대신 실제 자료형으로 대체되는 타입 패러미터를 받아 사용하는 방법입니다.
- 를 사용하는 것이 관례 T U V 순으로
- 사용법
- 함수에 제너릭을 사용하는 방법
- fun testFunc(var param: T){}
- testFunc(1) -> fun testFunc(var param: Int){} 자동으로 추론
- 클래스에서 제너릭을 사용하는 방법
- class testClass
- testClass() -> 인스턴스를 생성할 때
- class TestClass (var pref: T)
- TestClass(1) -> class TestClass(var pref: Int) 차동으로 추론
- 함수에 제너릭을 사용하는 방법
package Kotlin2020
fun main(args: Array<String>) {
UsingGeneric(A1()).doShout()
UsingGeneric(B1()).doShout()
UsingGeneric(C1()).doShout()
doShouting(B1())
}
fun <T: A1> doShouting(t: T){
t.shout()
}
open class A1 {
open fun shout(){
println("A Shout")
}
}
class B1: A1(){
override fun shout() {
println("B Shout")
}
}
class C1: A1(){
override fun shout() {
println("C Shout")
}
fun say(){
println("sayyyy")
}
}
class UsingGeneric<T:A1>(var t : T){
fun doShout(){
t.shout()
}
}
016 컬렉션 list set map
- List는 '데이터를 모아 관리하는' 컬렉션 클래스를 상속하는 가장 단순한 형태의 서브 클래스
- List / MutableList
- List : 생성시에 넣은 객체를 대체, 추가, 삭제 할 수 없음.
- MutableList : 수정가능
- listOf 또는 mutableListOf
- add(data), add(index, data)
- remove(data), remove(index, data)
- shuffle()
- sort()
package Kotlin2020
fun main(args: Array<String>) {
val a = listOf(1,2,3,4)
for(i in a){
println(i)
}
val b = mutableListOf(1,2,3,4,5)
println(b)
b.add(5)
println(b)
b.add(1,0)
b.shuffle()
println(b)
}
017 문자열 String
package Kotlin2020
fun main(args: Array<String>) {
val test1 = "Text.Kotile.String"
println(test1.length)
println(test1.toLowerCase())
println(test1.toUpperCase())
val test2 = test1.split(".")
println(test2)
println(test2.joinToString())
println(test2.joinToString("-"))
println(test1.substring(5..10))
/*
* null check 가능한 함수
*
* isNullOrEmpty()
* isNullorBlank()
* */
/*
* startWith("")
* endWith("")
* contains("")
*
*
* */
}018 null 값을 처리하는 방법
- nullable
- ?. : null safe -> 객체가 널인지 확인하고 뒤 를 실행하지 않음
- ?: : elvis -> 연산자 우측 사용
- !!. : non-null assertion -> 컴파일이 아닌 런타임 시간에 의도적으로 널 에러 확인
- 변수의 동일성 내용의 동일성 vs 객체의 동일성
- 내용의 동일성 : 메모리상에 위치가 다르다고 하더라고 내용이 같다면 같다. ( == )
- 객체의 동일성 : 메모리상에 같은 객체를 가르키고 있으면 같다. ( === )
package Kotlin2020
fun main(args: Array<String>) {
var a : String ? = "sd"
// a?.run{
// println(toUpperCase())
// println(toLowerCase())
// }
var v1 = Product("콜라",1000)
var v2 = Product("콜라",1000)
var v3 = v1;
var v4 = Product("사이다",1000)
println(v1 == v2)
println(v1 === v2)
println(v1 === v3)
println(v1 == v3)
println(v1 == v4)
println(v1 === v4)
}
class Product(val name : String, val price : Int){
override fun equals(other: Any?): Boolean {
if(other is Product){
return other.name == name && other.price == price
}else{
return false
}
}
}019 함수의 argument / infix
- 오버 로딩을 지원한다.
- 이름이 같다고 하더라고 파라미터가 다르다면 다른 함수로 동작하게 할 수 있다.
package Kotlin2020
fun main(args: Array<String>) {
read(1)
read("HH")
deliveryItem("장건일", destination = "학교")
sum(1,2,3,4,12,1,231,2,41,24,3)
}
fun read(x: Int){
println("number $x")
}
fun read(x:String){
println("감사합니다. $x")
}
//
fun deliveryItem(name : String, count: Int= 1 ,destination: String = "집"){
println("$name $count $destination")
}
//
fun sum(vararg number: Int){
for(i in number){
println(i)
}
}
//
infix fun Int.mul(x:Int):Int = this * x
020 중첩 클래스 vs 내부클래스
- 중첩클래스 : 내용을 공유할 수 없는 별도의 클래스 OuterClass.Nested 로 중첩 클래스로 접근이 가능
- 내부 클래스 : inner 키워드 사용 : 외부 클래스의 속성과 함수의 사용이 가능하다.
- this@OuterClassName 으로 접근이 가능
package Kotlin2020
fun main(args: Array<String>) {
Outer.Nested().say()
var Outer = Outer()
val inner = Outer.Inner()
inner.say()
inner.say2()
Outer.text ="Changed Test"
inner.say2()
}
class Outer{
var text = "Outer Class"
class Nested{
fun say(){
println("Nexted Class")
}
}
inner class Inner{
var text = "Inner Class"
fun say(){
println(text)
}
fun say2(){
println(this@Outer.text) //외부 클래스의 값에 접근이 가능해진다.
}
}
}021
022 Data Class / Enum Class
- Data Class : 데이터를 다루는 최적화 기능 5가지
- equals()
- toString()
- hashcode()
- copy()
- componentsX()
- Enum Class :
package Kotlin2020
fun main(args: Array<String>) {
var a = Gclass("s",1)
println(a == Gclass("s",1))
println(a.hashCode())
println(a)
var b= Data("d",2)
}
class Gclass(val name: String, val id: Int)
data class Data(val name: String, val id: Int)
023 컬렉션 Set 과 Map
- Set : list와 달리 순서가 정렬되지 않으며, 중복이 허용되지 않는다.
- contains("ㅇ")와 같이 존재 한지만 확인이 가능합니다.
- MutableSet 이 존재 합니다.
- Map : key : value 쌍으로 이루어져 있습니다.
- put(key, value)
- remove(key)
package Kotlin2020
fun main(args: Array<String>) {
val a = mutableSetOf("바나나","사과","김치")
for(item in a){
println("${item}")
}
a.add("사과")
a.add("귤")
println(a)
val b = mutableMapOf("d" to "11","d2" to "22" )
for(e in b){
println("${e.key} : ${e.value}")
}
}024 컬렉션에 사용하는 함수들 001
- 함수형 언어의 특징을 가지고 있기 때문에 컬렉션 함수를 사용할 수 있다.
- forEach{it -> }
- filter{it -> } 반환
- map{it-> } 변경후 반환 js랑 똑같은 사용법
- any{it -> it == 0} 하나라도 맞으면 true
- all{it -> it == 0} 모두 조건에 맞으면 true
- none{it -> it == 0} 하나도 조건에 맞지 않으면 true
- first() and first{it -> 조건} 첫 번째를 반환해 주거나, 조건에 맞는 첫 번째 값을 반환 해준다. (find로 사용가능)
- last() and last{it > 3 } first와 반대 (firndLast로 사용가능)
- count() and count{it > 7} 전체 또는 조건에 맞는 것의 갯 수
package Kotlin2020
fun main(args: Array<String>) {
val nameList = listOf("박수영", "김지수", "김다현", "신유나","김지우")
nameList.forEach{println(it)}
println()
val newNameList = nameList.map{name -> "welcome , $name"}
println(newNameList)
val kimList = nameList.filter{it.contains("장")}
println(kimList)
}025 컬렉션에 사용하는 함수들 002
- 함수형 언어의 특징을 가지고 있기 때문에 컬렉션 함수를 사용할 수 있다.
- associateBy : 아이템에서 key를 추출하여 map으로 변환하는 함수
- groupBy : key가 같은 아이템끼리 배열로 묶어 map으로 만드는 함수
- partition : 아이템에 조건을 걸어 두개의 컬렉션으로 나누어 줌
- flatMap{} : 아이템마다 만들어진 컬렉션을 합쳐서 반환하는 함수
- getOrElse(8){50} : collection 내부에 index = 8 이 있으면 해당 값을 반환하고 없다면 중괄호 값을 반환해라
- A collection zip B collection : 컬렉션 두개의 아이템을 1:1로 매칭하여 새 컬렉션을 만들어 줌
package Kotlin2020
fun main(args: Array<String>) {
data class Person(val name : String, val birth : Int)
val personList = listOf<Person>(
Person("유나",1992),
Person("조이",1996),
Person("츄",1999),
Person("유나",2003)
)
val associted = personList.associateBy { it.birth }
println(associted)
val grouped = personList.groupBy { it.name }
println(grouped)
val (over98, upder98) = personList.partition { it.birth > 1998 }
println(over98)
println(upder98)
val numbers = listOf(-3, 7,2,-10,1)
println(numbers.flatMap { listOf(it*10, it+10, it*0) })
println(numbers.getOrElse(1){50})
println(numbers.getOrElse(100){50})
}026 변수의 고급 기술
- 상수를 : const val 컴파일시점에 결정되어 변경이 절대 불가능 하다. 대문자 스네이크 케이스를 사용한다.
- 상수를 사용하는 이유는,
- 변수는 런타임시 객체를 생성하는데 시간을 더 소요하기 떄문에 성능하락을 가져온다.
따라서 늘 고정적으로 사용할 값은 상수를 통해 객체의 생성없이 값을 고정하여 사용하면서 성능을 향상시킬 수 있다.
- 변수는 런타임시 객체를 생성하는데 시간을 더 소요하기 떄문에 성능하락을 가져온다.
- 늦은 초기화 : 코틀린에서 변수를 선얼할 때 자료형만 지정해두고 객체는 나중에 할당하면 컴파일이 되지 않습니다.
경우에 따라서는 변수에 객체를 할당하는 것을 선언과 동시에 하지 못할 경우도 있다.
- lateinit var a : Int 일단 변수만 선언하고 할당은 나중에
- 초기값 할당 전까지는 변수를 사용할 수 없음
- 기본 자료형에는 사용할 수 없음
- ::a.isinitialized : 초기화 여부 확인가능 - lazt
- 사용할때 초기화를 한다.
- val a : int by lazy { 7 }
package Kotlin2020
fun main(args: Array<String>) {
// val foodCourt = FoodCourt()
// foodCourt.searchPrice(FoodCourt.FOOD_STEAK)
// foodCourt.searchPrice(FoodCourt.FOOD_PIZZA)
// foodCourt.searchPrice(FoodCourt.FOOD_CREAM_PASTA)
// val testLateInit = LateInitSample()
// println(testLateInit.getLateInitTest())
// testLateInit.setTextInit("Hello world")
// println(testLateInit.getLateInitTest())
val number : Int by lazy{
println("초기화를 합니다.")
5
}
println("start")
println(number)
println(number)
}
class FoodCourt{
fun searchPrice(foodName: String){
val price = when(foodName){
FOOD_CREAM_PASTA -> 13000
FOOD_PIZZA -> 25000
FOOD_STEAK -> 30000
else -> 0
}
println("${foodName}의 가격은 ${price} 입니다.")
}
companion object{
const val FOOD_CREAM_PASTA = "크림파스타"
const val FOOD_STEAK = "스테이크"
const val FOOD_PIZZA = "피자"
}
}
class LateInitSample{
private lateinit var text: String
fun getLateInitTest(): String {
if(::text.isInitialized)
return text
else
return "기본값"
}
fun setTextInit(std: String){
text = std
}
}
027 비트연산
- 사람이 사용하는 10진법이 아닌 2진법으로 연산할 수 있는기능
- 실무 : 거의 계산에는 사용하지 않으며, 2진법을 이용한 연산 최적화가 필요하다면 컴파일의 기능을 사용하는 경우가 대부분임
package Kotlin2020
fun main(args: Array<String>) {
var bitData : Int = 0b10000 //지정되지 않은 상위비트는 0으로 채워 집니다.
bitData = (1 shl 2)
bitData = (1 shr 2)
bitData = bitData or (1 shl 2) // 1이라는 값을 자측으로 2번 밀기
println(bitData.toString(2))
bitData = bitData or (1 shr 2)// 1이라는 값을 우측으로 2번 밀기
}028 코루틴 @@@@ 비동기 처리
- 여러개의 루틴을 동시에 처리 할 수 있는 방법을 배워 봅니다.
- 비동기 처리 : 코루틴(개발자가 제어할 수 있는 단위 ) import kotlinx.coroutines.*
- GlobalScope vs CorutineScope
- GlobalScope : 프로그램 어디서나 제어, 동작이 가능한기본 범위
- CorutineScope : 특정한 목적의 Dispatcher를 지정하여 제어 및 동작이 가능한 범위
- Dispatcher.Default : 기본적인 백그라운드 동작
- Dispatcher.IO : I/O에 최적화된 동작
- Dispatcher.Main : 메인 스레드에서 동작
- launch{} / async{} : 반환값 여부
- 코루틴은 프로그램 전체가 종료되면 함께 종료 되기 떄문에 실행을 보장하기 위해서는 일정점위 기다리게 한다.
- 루틴을 보장하기 위해 사용하는 함수
- delay() : delay(milisecod: Long) - 밀리세컨드 단위로 루틴을 잠시 대기시키는 함수
- join() : Job.join() - Job의 실행이 끝날떄까지 대기하는 함수
- await() : Defferred.await()의 실행이 끝날때 까지 대기하는 함수
- cancel() : 코루틴 중지
- 코루틴 내부의 delay() 또는 yield() 함수가 사용된 위치까지 수행된 뒤 종료됨.
- cancel()로 인해 속성인 isActive가 false가 되므로 이를 확인하여 수동으로 종료함
- withTimeoutOrNull() : 제한된 시간내에 종료되면 반환값을 아니면 null을 반환
package Kotlin2020
import kotlin.coroutines.*
fun main(){
val scope = GlobalScope
runBlocking {
val a = lanuch{ //JOB
for(i in 1..45){
println(i)
deley(10)
}
}
val b = async{ // DIfferd
"async 종룍"
}
println("async 대기")
println(b.await())
println("launch 대기")
a.join()
println("launch 종료")
}
runBlocking{
val result : String? = withTimeoutOrNull(50){
for(i in 1..1000){
println(i)
delay(10)
}
}
"finish"
}
}
takeaways