forked from elfinxx/Keddit_kr
-
Notifications
You must be signed in to change notification settings - Fork 0
/
keddit_2
229 lines (163 loc) · 14.8 KB
/
keddit_2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
Part 2: Syntax, Null Safety and more…
In this Part we are going to focus on understanding some basic syntax of the language and also adding all the code that we need for the MainActivity.kt in order to open our fragment.
이번 장에서는 코틀린의 기본 구문(Syntax)을 이해하고 fragment를 열기 위한 코드를 MainActivity.kt에 추가하는 것에 중점을 두고 진행 됩니다.
Kotlin Syntax
코틀린 구문
Now our MainActivity is a Kotlin file and we are ready to start learning the syntax.
코틀린 파일인 MainActivity를 이용해 구문을 공부해봅시다.
The first time that you see the code it may cause you a little bit of fear but believe me that you are going to love it! ;)
코틀린 코드를 보는게 처음이라 좀 두려울 수 있지만 아마 곧 코틀린을 좋아하게 될거라 확신합니다.
Kotlin is defined in many ways and this is one of them (which I really like) that tries to include the most important characteristics in one sentence:
코틀린이란 언어를 다양한 방법으로 정의할 수 있습니다만 다음 문장이 코틀린의 가장 중요한 특징이 포함되어 있기에 제일 좋아합니다.
Kotlin is a Concise, Safe and Statically typed programming language focused on Interoperability with Java.
코틀린은 자바와 상호 호환되는데 중점을 둔 간결하고 안전한 정적 타입 프로그래밍 언어이다.
Let’s use this definition to start reviewing our generated code. I give you here both MainActivity files: Java and Kotlin files.
이 정의를 갖고 생성된 코드를 살펴보도록 합시다. 자바와 코틀린으로 된 MainActivity 파일들은 다음과 같습니다.
MainActivity.class: Before to be converted
MainActivity.kt
Concise
간결함
Did you notice that the Java file has 19 lines of code and the Kotlin file has only 12?
자바는 19줄이지만 코틀린은 12줄에 불과한 것을 보셨나요?
This is because most of the verbosity of Java was eliminated.
자바의 불필요한 부분을 제거했기 때문에 그렇습니다.
Concise code takes less time to write and to read so this will improve your productivity.
간결한 코드는 읽고 쓰는데 시간을 줄여주고 곧 생산성의 증가로 이어집니다.
Extend and Implement:
Extend와 Implement
The words “extends” and “implement” were replaced by a colon “:” indifferently. In this case we are extending from AppCompatActivity (which is a Java class!)
"extends"와 "implement"라는 단어는 모두 콜론 (:)으로 대체되었습니다. 여기서는 AppCompatActivity(Java class인데도!)를 extend 합니다.
class MainActivity : AppCompatActivity()
Fun — ctions
Fun - ctions
We don’t have our classic “public void methodName()” structure.
기존의 "public void methodName()" 구조가 아닌
Now we define functions inside our class with the “fun” keyword and the return type is added to the end.
"fun" 키워드를 이용해 funtions을 정의하고 반환 타입은 끝에 추가해 줍니다.
But where is the type returned from our “onCreate” method?
근데 "onCreate" 메서드의 리턴 타입은 어디에 있을까요?
override fun onCreate(savedInstanceState: Bundle?) {
In the case that we don’t want to return any value in Java we would use “void”, here the alternative is “Unit” which works in the same way.
값을 리턴하고 싶지 않은 경우 자바에서는 "void"를 사용합니다만 코틀린에서는 "Unit"을 같은 방식으로 사용합니다.
The compiler will know that we are not returning anything so we can omit it.
리턴 타입을 생략함으로써 컴파일러에게 리턴 타입이 없다는 것을 알려줄 수 있습니다.
In the case that we want to add it just do it in this way:
필요하다면 다음과 같은 방법으로 추가해줄 수도 있습니다.
override fun onCreate(savedInstanceState: Bundle?) : Unit {
Also the parameters are in a different order. First you define the name of the variable and then the type.
또한 parameter를 나타낼 때 다른 순서를 가집니다. 가장 먼저 변수의 이름이, 그리고 타입이 옵니다.
Bye Semicolon;
잘가라 세미콜론아
In Kotlin you don’t have to put the semicolon at the end of a sentences but still you can do it if you want (don’t do it).
코틀린에서는 문장 끝에 세미콜론(;)을 붙여줄 필요가 없습니다. 하고 싶으면 해도 됩니다.(하지 마세요)
Values and Variable
값과 변수
The way to define a variable is with the “var” keyword.
변수를 정의하려면 "var" 키워드를 이용합니다.
The type will be inferred from the Context and the same for constants which use the “val” keyword:
변수의 타입은
val price = 100 // Int
price = 30 // don't compile! it's a constant
var total = price * 3 // Int
val name = "Juancho" // String
You can specify the type explicitly:
타입을 명시적으로 지정해줄 수도 있습니다.
val lastname : String = "Keddit" // explicit type definition
var size : Double = 30.0
var time : Float = 15f
Maybe you notice that there are no primitive types, we don’t use “double” but “Double”.
"double"을 사용하지 않고 "Double"을 사용하는 것처럼 primitive 타입을 사용하지 않았다는 걸 볼 수 있었을 것입니다.
This is because everything in Kotlin is an object. For performance, the compiler will transform some of this objects to primitive types internally.
코틀린의 모든 것은 객체(object)이기 때문에 그렇습니다. 성능 향상을 위해 컴파일러는 내부적으로 이런 몇몇 객체들을 primitive 타입으로 변환할 것입니다.
Properties and Fields
Properties와 Fields
In Kotlin you access properties like accessing a field in Java. Instead of calling the getResources() method from an Activity you directly do:
코틀린에서 자바의 필드를 access하는 것처럼 property를 access할 수 있습니다. getResources() 메서드를 호출하는 것 대신 Activity에서 직접 할 수 있는데
resources.getString(R.string.id)
// vs
getResources().getString(R.string.id) // still allowed
You can still call the getResource() method but Android Studio will suggest you to change it:
여전히 getResoucre() 메서드를 호출할 수 있습니다만 안드로이드 스튜디오가 바꿀 수 있다고 제안할껍니다.
It doesn’t mean that you are accessing the field directly, it’s calling the “getResource()” method but in a more convenient way.
이건 filed에 직접적으로 access 할 수 있다는 의미가 아니라 단지 getResource() 메서드를 편리하게 호출할 수 있는 것입니다.
Safe ?: Safe!
This is one of the great things about Kotlin, everything in Kotlin is not nullable unless you specifically declare it in this way.
이번에 설명할 내용은 코틀린의 훌륭한 점 중 하나인데 사용자가 아래의 방법처럼 명시하지 않는 한 코틀린의 모든 것은 nullable 하지 않습니다.
The way to do this is with the “?” question mark which also suggest you that the value could be there or not.
이 값이 없을 수도 있을수도 있다는걸 "?" 물음표를 붙임으로써 나타낼 수 있습니다.
With that being said, let’s see some examples:
한번 다음의 예제를 봐봅시다.
val a : String = null // don't compile!
var b : Int // neither! must be initialized
val ok : String? = null // OK :)
The compiler will be checking the presence of a possible null object, this will prevent us to make the common mistake of getting a “NullPointerException” or well known as the “Billion-dollar mistake” by Tony Hoare.
컴파일러는 null이 될 수 있는 객체가 있는지 체크하여 "NullPointerException"이나 잘 알려진 "Billion-dollar mistake"와 같은 실수를 방지할 수 있게 합니다.
Safe call
To interact with a nullable object is really easy, the “?” question mark will allow you to get the value just in case it exists, otherwise it will ignore it and you are safe to continue running the program:
nullable 객체와 상호작용 하는건 정말 쉽습니다. "?" 물음표를 붙임으로써 값이 존재한다면 얻을 것이고 없다면 무시되어 안전하게 프로그램을 계속 실행할 수 있습니다.
val context : Context? = null
val res = context?.getResources() // not crash, res will be null
Smart cast
If you continue playing with nullable objects maybe you end up doing this:
nullable 객체를 가지고 쭉 이용하길 원한다면 아마 다음과같이 쓸 것입니다.
val context : Context? = null
val res = context?.getResources()
val appName = res?.getString(R.string.app_name)
val shortName = appName?.substring(0, 2)
This is awful, but you can do this in a better way with smart cast. Just check if context is null and inside the if block the context will be considered as a non-nullable object:
이건 좀 구린데요, 대신에 스마트 캐스트를 이용하면 좀 더 낫습니다. context가 널인지 if문으로 체크하고 체크한 if 블럭 내에서는 context는 nullable하지 않은 객체로 취급됩니다.
val context : Context? = null
if (context != null) {
val res = context.getResources() // Don't need '?' anymore
val appName = res.getString(R.string.app_name)
val shortName = appName.substring(0, 2)
}
Elvis Operator ?:
This is the name used for this operator “?:” and you can use it to give an alternative value in case the object is null.
Elvis란 "?:" 연산자의 이름이고 객체가 null일 경우 대체 값을 얻기 위해 사용됩니다.
Its like a short way to perform a null check. In this example “message” could be null, the type is “String?”. In case the object is NOT null we’ll be sending the value of message, otherwise, the value that we provided after the elvis operator:
이 연산자는 null 체크를 수행하기 위한 축약형 표현이라 보면 됩니다. 이 예제에서 message는 null일 수 있기 때문에 타입은 "String?"입니다. 이 경우 message의 값이 null이 아니라면 전달할 것이고 아니라면 elvis 연산자 뒤의 값을 이용하여 전달할 것입니다.
try {
// code...
} catch (e: Throwable) {
Log.e("TAG", e.message ?: "Error message")
}
Note: if you want to know more about null safety, checkout this link:
null safety에 대해 좀 더 자세한 내용을 알고 싶다면 다음의 링크를 참고합시다.
https://kotlinlang.org/docs/reference/null-safety.html
Statically Typed
정적 타입
It means that Kotlin needs to know the Type of everything that you define in the code because the compiler will do a type check during compilation.
정적 타입이란 의미는 코틀린은 컴파일 타임에 타입을 체크하여 컴파일러가 코드에 정의된 모든 것들의 타입을 알 수 있어야 한다는 것입니다.
With the great support that we have in Android Studio (Thanks to JetBrains) the IDE will do a great job helping us to know if we are assigning properly a value to a variable.
변수에 값을 잘 할당될 수 있도록 안드로이드 스튜디오(젯브레인에 ㄱㅅ)라는 의 강력한 지원으로 IDE가 도와주는 역할을 할 것입니다.
Furthermore, we don’t have to specify the type when we create a variable (or a constant in this case). Checkout the toolbar constant, the type is inferred from the context and this is another great feature about Kotlin:
더불어 변수(혹은 상수)를 생성할 때 타입을 지정해줄 필요가 없습니다. 다음 toolbar constant를 보면 타입은 context로부터 추론되는데 이건 코틀린의 또 다른 훌륭한 점 중 하나입니다.
val toolbar = findViewById(R.id.toolbar) as Toolbar
Type inference brings great advantages to the language: Reliability (the compiler verifies the correctness of the program), Maintainability (the code is explained by itself), Tool support (what I mentioned before, static typing enables reliable refactoring, code completion and more) and Performance (in most cases there is no need to figure out at runtime which method needs to be called).
타입 추론은 언어의 신뢰성(컴파일러가 프로그램의 정확성을 검증)과 도구 지원(전에 언급했듯이 정적 타입은 리팩토링 때 신뢰성 및 코드 자동완성 등을 가능하게 함) 및 성능(대부분의 경우 메서드가 호출될 필요가 있는지 런타임 시에 파악할 필요가 없음)에 있어서 큰 장점입니다.
100% Java Interoperability
자바와 100% 호환
This is another great feature about Kotlin, you can use Java code from a Kotlin file and vice-versa.
코틀린 파일에서 자바 코드를 쓰거나 혹은 그 반대의 경우가 가능하다는 건 코틀린의 큰 특징 중 하나입니다.
In the Keddit App we are extending from AppCompactActivity, using the Bundle object in the onCreate method and of course using all the Android SDK to create our App :).
Keddit 앱에서 AppCompatActivity를 extend, onCreate 메서드의 Bundle 객체를 사용하는 것, 앱을 만들 때 Android SDK를 사용하는 것에서 그 예를 찾아볼 수 있습니다.
Also, we are using other Java libraries like Retrofit, Picasso, etc.
또한 이미 자바 라이브러리인 retrofit이나 picasso등을 사용하고 있습니다.
Something really important about this is that Kotlin doesn’t have its own collections library, it relies on Java standard library classes, extending those classes with new functions. This means that you never need to convert objects between Java and Kotlin.
정말 중요한 것 중 하나는 코틀린은 자체적인 collection 라이브러리를 갖지 못하고 자바의 standard library class에 의존하고 있고 이 class들을 새로운 함수로 확장해서 쓰고 있다는 것입니다. 이 말은 Java와 코틀린 사이에 객체를 변환할 필요가 없다는 것입니다.
Updating MainActivity
I just added some methods to the MainActivity to open a fragment which will be creating in the next story and also removed some code that we don’t need in this case all related things to the menu settings.
Checkout the code to see the activity and try to understand these new concepts:
https://github.com/juanchosaravia/KedditBySteps/blob/master/app/src/main/java/com/droidcba/kedditbysteps/MainActivity.kt
Notice how I’m using the Fragment Manager:
val ft = supportFragmentManager.beginTransaction();
// and not getSupportFragmentManager()
The new method “changeFragment()” will allow us to open a fragment inside this activity with a fade animation.
Repository
https://github.com/juanchosaravia/KedditBySteps/tree/v0.2
Conclusion
This is just a small part of some Kotlin concepts, we are going to continue learning more while we continue developing the Keddit App.
If you want to learn more about this concepts, checkout this link which I consider really useful: http://try.kotlinlang.org/
See you in the next story!
Twitter: https://twitter.com/juanchosaravia