├── .github
└── FUNDING.yml
├── .gitignore
├── .idea
├── encodings.xml
├── kotlinc.xml
├── libraries
│ ├── KotlinJavaRuntime.xml
│ └── KotlinJavaRuntime__2_.xml
├── misc.xml
├── modules.xml
├── vcs.xml
└── workspace.xml
├── KotlinTutorials.iml
├── README.md
├── kotlin2023.jpeg
└── src
└── main
└── kotlin
├── AbstractClass.kt
├── ArithmeticOperators.kt
├── Arrays.kt
├── AssignmentOperators.kt
├── BasicTypes.kt
├── Break.kt
├── Class-Objects.kt
├── CompanionObject.kt
├── Comparison-EqualityOperators.kt
├── Constructor.kt
├── Continue.kt
├── DataClass.kt
├── ExtensionFunction.kt
├── ForLoop.kt
├── Functions.kt
├── Getters-Setters.kt
├── Global-LocalVariables.kt
├── HelloWorld.kt
├── Increment-DecrementOperators.kt
├── InfixFunction.kt
├── Inheritance.kt
├── InnerClass.kt
├── Input-Output.kt
├── InterfaceSample.kt
├── LogicalOperators.kt
├── MapExample.kt
├── MethodOverloading.kt
├── MultiformFunction.kt
├── NestedClass.kt
├── NestedifExpression.kt
├── NullSafety.kt
├── OperatorOverloading.kt
├── Player.kt
├── Range.kt
├── RecursiveFunction.kt
├── SealedClass.kt
├── TopLevelMethod.kt
├── TypeConversion.kt
├── Variables.kt
├── VisibilityModifiers.kt
├── When.kt
├── WhileLoop.kt
├── do...whileLoop.kt
├── if..else..ifExpression.kt
├── ifExpression.kt
├── inOperator.kt
├── main.kt
└── toplevelmethod
└── Simple.kt
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 |
3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
4 | patreon: # Replace with a single Patreon username
5 | open_collective: # Replace with a single Open Collective username
6 | ko_fi: # Replace with a single Ko-fi username
7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: www.buymeacoffee.com/halilozel1903
14 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | KotlinTutorials.iml
--------------------------------------------------------------------------------
/.idea/encodings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/.idea/kotlinc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/.idea/libraries/KotlinJavaRuntime.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/.idea/libraries/KotlinJavaRuntime__2_.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/workspace.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
21 |
22 |
23 |
24 |
25 | {
26 | "lastFilter": {
27 | }
28 | }
29 |
30 |
36 |
37 |
38 |
39 |
40 | {
41 | "customColor": "",
42 | "associatedIndex": 4
43 | }
44 |
45 |
46 |
47 |
48 |
49 |
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 | 1622382505686
125 |
126 |
127 | 1622382505686
128 |
129 |
130 |
131 |
132 | 1622382640756
133 |
134 |
135 |
136 | 1622382640756
137 |
138 |
139 | 1622382699799
140 |
141 |
142 |
143 | 1622382699799
144 |
145 |
146 | 1622382936795
147 |
148 |
149 |
150 | 1622382936795
151 |
152 |
153 | 1622383211699
154 |
155 |
156 |
157 | 1622383211699
158 |
159 |
160 | 1652474758215
161 |
162 |
163 |
164 | 1652474758215
165 |
166 |
167 | 1657898275510
168 |
169 |
170 |
171 | 1657898275510
172 |
173 |
174 | 1658246742941
175 |
176 |
177 |
178 | 1658246742941
179 |
180 |
181 | 1658248022961
182 |
183 |
184 |
185 | 1658248022961
186 |
187 |
188 | 1658248323958
189 |
190 |
191 |
192 | 1658248323958
193 |
194 |
195 | 1658248534658
196 |
197 |
198 |
199 | 1658248534658
200 |
201 |
202 | 1658248719637
203 |
204 |
205 |
206 | 1658248719637
207 |
208 |
209 | 1658248809989
210 |
211 |
212 |
213 | 1658248809989
214 |
215 |
216 | 1658354353751
217 |
218 |
219 |
220 | 1658354353751
221 |
222 |
223 | 1658354843555
224 |
225 |
226 |
227 | 1658354843555
228 |
229 |
230 | 1658355494119
231 |
232 |
233 |
234 | 1658355494119
235 |
236 |
237 | 1658355606875
238 |
239 |
240 |
241 | 1658355606875
242 |
243 |
244 | 1662306040501
245 |
246 |
247 |
248 | 1662306040501
249 |
250 |
251 | 1662314207411
252 |
253 |
254 |
255 | 1662314207411
256 |
257 |
258 | 1662314895975
259 |
260 |
261 |
262 | 1662314895975
263 |
264 |
265 | 1662315360477
266 |
267 |
268 |
269 | 1662315360477
270 |
271 |
272 | 1662315365103
273 |
274 |
275 |
276 | 1662315365103
277 |
278 |
279 | 1662316276154
280 |
281 |
282 |
283 | 1662316276154
284 |
285 |
286 | 1662325377433
287 |
288 |
289 |
290 | 1662325377433
291 |
292 |
293 | 1668949766596
294 |
295 |
296 |
297 | 1668949766596
298 |
299 |
300 | 1668949833704
301 |
302 |
303 |
304 | 1668949833704
305 |
306 |
307 | 1671830191591
308 |
309 |
310 |
311 | 1671830191591
312 |
313 |
314 | 1671830262436
315 |
316 |
317 |
318 | 1671830262436
319 |
320 |
321 | 1673456366131
322 |
323 |
324 |
325 | 1673456366131
326 |
327 |
328 | 1673456784687
329 |
330 |
331 |
332 | 1673456784687
333 |
334 |
335 | 1673456926640
336 |
337 |
338 |
339 | 1673456926640
340 |
341 |
342 | 1673457062399
343 |
344 |
345 |
346 | 1673457062399
347 |
348 |
349 | 1675428039863
350 |
351 |
352 |
353 | 1675428039863
354 |
355 |
356 | 1675428949156
357 |
358 |
359 |
360 | 1675428949156
361 |
362 |
363 | 1675429330233
364 |
365 |
366 |
367 | 1675429330233
368 |
369 |
370 | 1675429814344
371 |
372 |
373 |
374 | 1675429814344
375 |
376 |
377 | 1675430002100
378 |
379 |
380 |
381 | 1675430002100
382 |
383 |
384 | 1675430367940
385 |
386 |
387 |
388 | 1675430367940
389 |
390 |
391 |
392 | 1697999529598
393 |
394 |
395 |
396 | 1697999529598
397 |
398 |
399 |
400 | 1704623171010
401 |
402 |
403 |
404 | 1704623171010
405 |
406 |
407 |
408 | 1704623185776
409 |
410 |
411 |
412 | 1704623185776
413 |
414 |
415 |
416 | 1704623344210
417 |
418 |
419 |
420 | 1704623344210
421 |
422 |
423 |
424 | 1704624150985
425 |
426 |
427 |
428 | 1704624150985
429 |
430 |
431 |
432 |
433 |
434 |
435 |
436 |
437 |
446 |
447 |
448 |
449 |
450 |
451 |
452 |
453 |
454 |
455 |
456 |
457 |
458 |
459 |
460 |
461 |
462 |
463 |
464 |
465 |
466 |
467 |
468 |
469 |
470 |
471 |
472 |
473 |
474 |
475 |
476 |
477 |
478 |
479 |
--------------------------------------------------------------------------------
/KotlinTutorials.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Kotlin Tutorials 👨🏻💻
2 |
3 | 
4 |
5 | # What is Kotlin❓
6 |
7 | `Kotlin` is a cross-platform, statically typed, general-purpose programming language with type inference. `Kotlin` is designed to interoperate fully with `Java` and the `JVM` version of Kotlin's standard library depends on the `Java` Class Library, but type inference allows its syntax to be more concise.
8 |
9 | You can access the article from the link below: 👇🏼
10 |
11 | https://medium.com/@halilozel1903/kotlin-nedir-43e312d2dca6
12 |
13 | ## The goal of the project 🎯
14 | Starting from the most basic topics about Kotlin, learning advanced topics by myself and creating an interactive project by sharing the information I have learned with you.
15 |
16 | ## Project Content 🛠
17 | It's a project that contains various information and examples about the basics of programming with Kotlin.
18 |
19 | ## Project Subjects 🔖
20 | - [Hello World](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/HelloWorld.kt)
21 | - [Basic Types](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/BasicTypes.kt)
22 | - [Arithmetic Operators](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/ArithmeticOperators.kt)
23 | - [Assignment Operators](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/AssignmentOperators.kt)
24 | - [Comparison-Equality Operators](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Comparison-EqualityOperators.kt)
25 | - [Increment-Decrement Operators](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Increment-DecrementOperators.kt)
26 | - [Logical Operators](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/LogicalOperators.kt)
27 | - [In Operator](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/inOperator.kt)
28 | - [Input-Output](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Input-Output.kt)
29 | - [Type Conversion](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/TypeConversion.kt)
30 | - [If Expression](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/ifExpression.kt)
31 | - [If..Else..If Expression](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/if..else..ifExpression.kt)
32 | - [Nested If Expression](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/NestedifExpression.kt)
33 | - [When Expression](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/When.kt)
34 | - [While Loop](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/WhileLoop.kt)
35 | - [Do...While Loop](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/do...whileLoop.kt)
36 | - [For Loop](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/ForLoop.kt)
37 | - [Arrays](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Arrays.kt)
38 | - [Range](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Range.kt)
39 | - [Null Safety](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/NullSafety.kt)
40 | - [Break](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Break.kt)
41 | - [Continue](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Continue.kt)
42 | - [Functions](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Functions.kt)
43 | - [Function Overloading](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/MethodOverloading.kt)
44 | - [Multiform Function](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/MultiformFunction.kt)
45 | - [Top Level Method](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/TopLevelMethod.kt)
46 | - [Recursive Function](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/RecursiveFunction.kt)
47 | - [Infix Function](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/InfixFunction.kt)
48 | - [Class and Objects](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Class-Objects.kt)
49 | - [Constructor](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Constructor.kt)
50 | - [Getters & Setters](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Getters-Setters.kt)
51 | - [Operator Overloading](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/OperatorOverloading.kt)
52 | - [Inheritance](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/Inheritance.kt)
53 | - [Visibility Modifiers](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/VisibilityModifiers.kt)
54 | - [Abstract Class](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/AbstractClass.kt)
55 | - [Interfaces](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/InterfaceSample.kt)
56 | - [Nested Class](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/NestedClass.kt)
57 | - [Inner Class](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/InnerClass.kt)
58 | - [Data Class](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/DataClass.kt)
59 | - [Sealed Classes](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/SealedClass.kt)
60 | - [Companion Objects](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/CompanionObject.kt)
61 | - [Extension Function](https://github.com/halilozel1903/KotlinTutorials/blob/master/src/main/kotlin/ExtensionFunction.kt)
62 |
63 | ## Resources 📚
64 | 1. https://kotlinlang.org/docs/kotlin-docs.pdf
65 | 2. https://www.programiz.com/kotlin-programming
66 | 3. https://www.tutorialspoint.com/kotlin/
67 | 4. https://www.geeksforgeeks.org/kotlin-programming-language/
68 |
69 | ## Support 💸
70 | If this project help 💁 you can buy me a cup of coffee. ☕
71 |
72 | [](https://www.buymeacoffee.com/halilozel1903)
73 |
74 |
75 | ## License ℹ️
76 | ```
77 | MIT License
78 |
79 | Copyright (c) 2023 Halil OZEL
80 |
81 | Permission is hereby granted, free of charge, to any person obtaining a copy
82 | of this software and associated documentation files (the "Software"), to deal
83 | in the Software without restriction, including without limitation the rights
84 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
85 | copies of the Software, and to permit persons to whom the Software is
86 | furnished to do so, subject to the following conditions:
87 |
88 | The above copyright notice and this permission notice shall be included in all
89 | copies or substantial portions of the Software.
90 |
91 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
92 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
93 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
94 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
95 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
96 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
97 | SOFTWARE.
98 | ```
99 |
100 |
101 |
--------------------------------------------------------------------------------
/kotlin2023.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halilozel1903/KotlinTutorials/32b78d606cb962e836720892a4e9b5c04a0a8bdc/kotlin2023.jpeg
--------------------------------------------------------------------------------
/src/main/kotlin/AbstractClass.kt:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | Abstract keyword is used to declare abstract classes in Kotlin.
4 | An abstract class cannot be instantiated. You can inherit subclasses from them.
5 | */
6 |
7 | abstract class Person(name: String) {
8 |
9 | init {
10 | println("My name is $name.")
11 | }
12 |
13 | fun showNumber(number: Int) {
14 | println("My Number : $number")
15 | }
16 |
17 | abstract fun showPosition(position: String)
18 | }
19 |
20 | class BasketballPlayer(name: String) : Person(name) {
21 | override fun showPosition(position: String) {
22 | println(position)
23 | }
24 | }
25 |
26 | /*
27 | Properties and methods of an abstract class are non-abstract unless you explicitly
28 | use abstract keyword to make them abstract.
29 | */
30 |
31 | fun main() {
32 | val basketballPlayer = BasketballPlayer("Halil Ozel")
33 | basketballPlayer.showPosition("Guard")
34 | basketballPlayer.showNumber(34)
35 | }
--------------------------------------------------------------------------------
/src/main/kotlin/ArithmeticOperators.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Aritmetik Operatörler
4 |
5 | + : Toplama
6 |
7 | - : Çıkarma
8 |
9 | * : Çarpma
10 |
11 | / : Bölme
12 |
13 | % : Mod Alma
14 |
15 | */
16 |
17 | fun main() {
18 |
19 | val number1 = 28.0 // number1 değeri verildi.
20 |
21 | val number2 = 7.0 // number2 değeri verildi.
22 |
23 | var result: Double = number1 + number2 // sonuç değeri tanımlandı. // toplama işlemi yapıldı.
24 |
25 | println("$number1 + $number2 = $result")
26 | // javascript veya php gibi dilleri kullandıysanız bu tip yazdırma ile karşılaşmanız olasıdır.
27 | // İlerleyen derslerde ayrıntılı olarak açıklanacaktır.
28 |
29 |
30 | result = number1 - number2 // çıkartma işlemi yapıldı.
31 |
32 | println("$number1 - $number2 = $result") // çıkartma işleminin sonucu ekranda gösterildi.
33 |
34 |
35 | result = number1 * number2 // çarpma işlemi yapıldı.
36 |
37 | println("$number1 * $number2 = $result") // çarpma işleminin ekranda gösterildi.
38 |
39 |
40 | result = number1 / number2 // bölme işlemi yapıldı.
41 |
42 | println("$number1 / $number2 = $result") // bölme işleminin ekranda gösterildi.
43 |
44 |
45 | result = number1 % number2 // mod alma işlemi yapıldı.
46 |
47 | println("$number1 % $number2 = $result") // mod sonucu ekranda gösterildi.
48 |
49 | // + operatörü ayrıca String değerlerinin birleştirilmesi için kullanılır.
50 |
51 | val start = "Talk is cheap. " // baş cümle
52 | val middle = "Show me the code. " // orta cümle
53 | val end = "- Linus Torvalds" // sözün yazarı
54 |
55 | val sentence = start + middle + end // cümle değişkeninde onları birleştirdik.
56 | println(sentence) // birleştirilen string ifadeler ekranda gösterildi.
57 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Arrays.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Array, Kotlin'deki Int, String vb. türden benzer verilerden oluşan bir koleksiyondur.
3 |
4 | */
5 |
6 | fun main() {
7 |
8 | val myArray = Array(5) { 0 } // 5 elemanı olan ve elemanlarıda 0 olan bir dizi tanımı
9 |
10 | myArray[0] = 1 // 0.indis 1 olarak güncellendi.
11 |
12 | for (element in myArray) {
13 | println(element) // array'in elemanları ekranda gösterildi.
14 | }
15 |
16 | val my_array: Array = arrayOf(1, 2, 3, 4, 5) // int türünde bir array tanımı
17 |
18 | println(my_array[0]) // dizinin 0.indisini getir.
19 |
20 | println(my_array[2]) // dizinin 2.indisini getir.
21 |
22 | println(my_array.size) // dizinin boyutu
23 |
24 |
25 | val array_2: Array = arrayOf("Halil", "İbrahim", "Özel") // string türde bir array tanımı
26 |
27 | println(array_2.isNotEmpty()) // dizinin elemanları varsa yani dizi boş değilse
28 |
29 | val any_array: Array =
30 | arrayOf(1, true, 19.00, "halil") // any belli bir tür belirtmeden bütün türlerden kullanmaya izin verir.
31 |
32 | println(any_array.isEmpty()) // dizinin içeriği boş mu ? diye kontrol edilir.
33 | }
--------------------------------------------------------------------------------
/src/main/kotlin/AssignmentOperators.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Atama operatörleri
4 |
5 | a +=b a = a + b
6 | a += b a = a + b
7 | a *= b a = a * b
8 | a /= b a = a / b
9 | a %= b a = a % b
10 |
11 | */
12 |
13 |
14 | fun main() {
15 | var a = 10
16 | val b = 5
17 |
18 | val sonuc: Int = a + b // sonuc değişkenine a ve b değerler toplamı atandı.
19 |
20 | println(sonuc) // sonuc değişkeni 15 olarak bulundu.
21 |
22 | a += b // a değerine b değeri eklenip a değerine atandı.
23 |
24 | println(a) // a sonucu 15
25 | }
--------------------------------------------------------------------------------
/src/main/kotlin/BasicTypes.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Kotlin, Java gibi statik olarak yazılmış bir dildir.
3 | Yani, derleme zamanı sırasında bir değişkenin tipi bilinir.
4 | */
5 |
6 |
7 | /*
8 | Kotlin'deki yerleşik tipler şu şekilde kategorize edilebilir:
9 |
10 | Numbers
11 | Characters
12 | Booleans
13 | Arrays
14 |
15 | */
16 |
17 | /*
18 |
19 | Number Type:
20 |
21 | Kotlin'deki sayılar Java'ya benzer.
22 | Sayıları temsil eden 6 yerleşik tip vardır :
23 |
24 | - Byte
25 | - Short
26 | - Int
27 | - Long
28 | - Float
29 | - Double
30 |
31 | */
32 |
33 | fun main() {
34 |
35 | /*
36 | Byte
37 |
38 | Byte veri türü -128 ila 127 (8 bit imzalı ikili tamsayı) değerlerine sahip olabilir.
39 | Bir değişkenin değerinin [-128, 127] içinde olacağından emin olduğunda,
40 | belleği kaydetmek için Int veya diğer tamsayı veri türleri yerine kullanılır.
41 |
42 | */
43 |
44 |
45 | val range: Byte = 111 // byte türünde bir değişken tanımlandı.
46 | println("range : $range") // değişken değeri -128 ile 127 arasında bir değer olduğu için ekrana range değerini yazar
47 |
48 | // val rangeTwo : Byte = 133 Ya bunu toByte ile byte dönüştür ya da int tipine dönüştür
49 |
50 |
51 | /*
52 |
53 | Short
54 |
55 | Short veri tipi -32768 ile 32767 arasında değerlere sahip olabilir
56 | (16 bit imzalı iki tamamlayıcı tamsayı).
57 | Değişkenin değerinin [-32768, 32767] içinde olacağından emin olduğunda,
58 | belleği kaydetmek için diğer tamsayı veri türleri yerine kullanılır.
59 |
60 | */
61 |
62 |
63 | val temp: Short = 12345 // temp değeri Short tipinin aralığında olduğu için sıkıntı olmayacaktır.
64 | println("temp : $temp") // ekrana içeriği bastırılıyor.
65 |
66 |
67 | /*
68 |
69 | Int
70 |
71 | Int veri türü -2^31 ile 2^31-1 arasında değerlere sahip olabilir ^
72 | (32 bit imzalı iki tamamlayıcı tamsayı).
73 |
74 | */
75 |
76 |
77 | val result: Int = 1000000 // int turunde bir değişken tanımlandı.
78 | println(result) // ekrana sonucu bastırıldı.
79 |
80 |
81 | /*
82 |
83 | Eğer türünü açıkça belirtmeden bir değişkene -2^31 ila 2^31-1 arasında bir tamsayı atadığınızda,
84 | değişken Int türünde olacaktır.^
85 |
86 |
87 | */
88 |
89 | val number = 1903 // tipi belirtilmezse int türünde işleme tabi tutulur.
90 |
91 |
92 | /*
93 |
94 | Long
95 |
96 | Uzun veri tipi -2^63 ila 2^63-1 arasında değerlere sahip olabilir ^
97 | (64 bit imzalı iki tamamlayıcı tamsayı).
98 |
99 | */
100 |
101 | val score: Long = 9999 // long tipinde bir değişken tanımlandı.
102 | println(score) // score değeri ekranda gösterildi.
103 |
104 | /*
105 | Bir değişkeni 2 ^ 31-1'den büyük veya -2 ^ 31'den küçük bir değişkene
106 | (türünü açıkça belirtmeden) atarsanız, değişken Long tipi olacaktır.
107 | */
108 |
109 |
110 | // distance değişkeni long türünde , ctrl+shift+p tuşlarına basarak değişkenin tipini öğrenebilirsiniz
111 | val distance = 10000000000
112 |
113 |
114 | // Benzer şekilde, değişkenin Long türünde olduğunu belirtmek için büyük harf L'yi kullanabilirsiniz.
115 |
116 | val newValue = 100L // long tipinde bir değişkendir.
117 |
118 |
119 | // Double : çift hassasiyetli bir 64-bit kayan noktalı sayıdır.
120 |
121 | val examNote: Double = 99.9 // noktalı sayılarda kullanılır.
122 | println("examNote : $examNote") // 0.01 puanı nereden kırdın be Zalım hoca :)
123 |
124 |
125 | // Float : Veri tipi tek hassasiyetli bir 32 bit kayan noktadır.
126 |
127 | val coldValue: Float = -10F // f parametresiyle birlikte kullanılır.
128 | println(coldValue) // değişkenin içeriği ekranda gsöterilir.
129 |
130 | /*
131 | Yukarıdaki programda 19.5 yerine 19.5F kullandık.
132 | Bunun nedeni, 19.5'in bir Double değişken olmasıdır ve Float'ın bir değişkenine Double değerini atayamazsınız.
133 | Derleyicinin 19.5'i Float olarak ele alması için, değişkenin sonunda F'yi kullanmanız gerekir.
134 | */
135 |
136 |
137 | var myNumber: Number = 1903 // int tipinde
138 |
139 | println(myNumber) // 1903
140 |
141 | myNumber = 19.03 // double tipinde
142 |
143 | println(myNumber) // 19.03
144 |
145 | myNumber = 1903F // float tipinde
146 |
147 | println(myNumber) // 1903.0
148 |
149 | myNumber = 1903L // long tipinde
150 |
151 | println(myNumber) // 1903
152 |
153 |
154 | // Char : Kotlin'de bir karakteri temsil etmek için Char tipleri kullanılır.
155 |
156 | val character: Char = 'A' // char türünde bir değişken tanımlandı.
157 |
158 | println(character) // karakter değeri ekranda gösterildi.
159 |
160 |
161 | // Java'da ascii tablosundaki değeri verilip ona göre karşılığı elde edilebilir.
162 |
163 | // char letter = 65;
164 |
165 | // Ama Kotlin böyle bir işleme izin vermez hatalı kullanım olduğunu bildirir.
166 |
167 |
168 | // Boolean : Veri türü, true veya false olmak üzere iki olası değere sahiptir.
169 |
170 | val state: Boolean = true // true ya da false sonuclarını atayabiliriz.
171 | println(state) // durum sonucu
172 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Break.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Break : Döngüden çıkılmasını sağlayan bir komuttur.
3 |
4 | */
5 |
6 |
7 |
8 | fun main() {
9 |
10 | for (i in 1..10) { // 1 den 10'a kadar dön
11 |
12 | if (i == 8) // i değeri 8'e eşitse
13 | break // kır ve döngüden çık
14 |
15 | println(i) // i değerlerini ekranda göster.
16 | }
17 |
18 |
19 | for (char in "Halil&Özel") { // String bir ifade
20 |
21 | if (char == '&') // bu karakteri gördüğünde
22 | break // kır ve döngüden çık
23 | print(char) // break olmadan önceki değeri ekranda göster
24 | }
25 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Class-Objects.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Before you create objects in Kotlin, you need to define a class.
3 | A class is a blueprint for the object.
4 | We can think of class as a sketch (prototype) of a house. It contains all the details about the floors,
5 | doors, windows etc. Based on these descriptions we build the house. House is the object.
6 | Since, many houses can be made from the same description, we can create many objects from a class.
7 | */
8 |
9 |
10 | class Lamp {
11 |
12 | // property data member
13 | private var isOn: Boolean = false
14 |
15 | // member function
16 | fun turnOn() {
17 | isOn = true
18 | }
19 |
20 | // member function
21 | fun turnOff() {
22 | isOn = false
23 | }
24 |
25 | fun displayLightStatus(lamp: String) {
26 | if (isOn) println("$lamp lamp is on.")
27 | else println("$lamp lamp is off.")
28 | }
29 | }
30 |
31 | /*
32 | When class is defined, only the specification for the object is defined; no memory or storage is allocated.
33 | To access members defined within the class, you need to create objects. Let's create objects of Lamp class.
34 | */
35 |
36 | fun main() {
37 |
38 | val lamp1 = Lamp() // create lamp1 object of Lamp class
39 | val lamp2 = Lamp() // create lamp2 object of Lamp class
40 |
41 | lamp1.turnOn()
42 | lamp2.turnOff()
43 |
44 | lamp1.displayLightStatus("lamp1")
45 | lamp2.displayLightStatus("lamp2")
46 | }
--------------------------------------------------------------------------------
/src/main/kotlin/CompanionObject.kt:
--------------------------------------------------------------------------------
1 | /*
2 | In Kotlin, if you want to write a function or any member of the class that can be called without having the
3 | instance of the class then you can write the same as a member of a companion object inside the class.
4 | */
5 |
6 | class CallMe {
7 | companion object {
8 | fun callMe() = println("You're calling.")
9 | const val NAME = "Halil Ozel"
10 | }
11 | }
12 |
13 | fun main() {
14 | CallMe.callMe()
15 | println("Name: ${CallMe.NAME}")
16 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Comparison-EqualityOperators.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | > : küçüktür
4 | < : büyüktür
5 | >= : büyük eşittir
6 | <= : küçük eşittir
7 | == : eşittir
8 | != : eşit değildir.
9 |
10 | */
11 |
12 |
13 | fun main() {
14 | val a = -12
15 |
16 | val b = 12
17 |
18 | // if kontrol yapısı sonraki derslerde anlatılacaktır.
19 | val max = if (a > b) { // eğer a b den büyükse
20 | println("a is larger than b.") // a b den daha büyüktür.
21 | a // ekrana a değeri ekrana basar.
22 | } else { // diğer durumlar için
23 | println("b is larger than a.") // b a dan daha büyüktür.
24 | b // ekrana b değeri ekrana basar.
25 | }
26 |
27 | println("max = $max") // max değeri ekranda yazdırılıyor.
28 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Constructor.kt:
--------------------------------------------------------------------------------
1 | /**
2 | In Kotlin, constructor is a block of code similar to method. Constructor is declared with the same name
3 | as the class followed by parenthesis '()'. Constructor is used to initialize the variables at the time of object creation.
4 | */
5 |
6 | class Student(val name: String, var id: Int)
7 |
8 | fun main() {
9 | val student = Student("Halil", 34)
10 |
11 | println("Name = ${student.name}")
12 | println("Id = ${student.id}")
13 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Continue.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Continue : Döngü yine çalışmaya devam eder. Ancak belirli bir şart sağlandığında, döngü içinde
4 | bulunan sonraki satırlara geçmeden döngü başa gider. Bazı değerleri çalıştırır.
5 | */
6 |
7 |
8 |
9 |
10 | fun main() {
11 |
12 | for (i in 1..10) { // i 1'den 10'a kadar dön
13 |
14 | if (i == 8) { // i değeri 8 ise
15 |
16 | continue // 8 değerini geç
17 | }
18 |
19 | println(i) // elemanları ekranda göster.
20 | }
21 |
22 |
23 | for (char in "Halil&İbrahim") { // string türde bir ifade kadar dön
24 |
25 | if (char == '&') { // bu karakter varsa
26 |
27 | print(" ") // boşluk bırak
28 |
29 | continue //o kısmı atla devam et
30 | }
31 |
32 | print(char) // çıktıyı ekranda bastır.
33 | }
34 |
35 | }
--------------------------------------------------------------------------------
/src/main/kotlin/DataClass.kt:
--------------------------------------------------------------------------------
1 | /**
2 | Kotlin has introduced the concept of Data Class, whose main purpose is to simply hold data without the
3 | boilerplate code needed in Java to create a POJO Class. Kotlin’s solution enables us to avoid writing getters, setters,
4 | equals, and hashCode methods, so it makes the model classes cleaner & more readable.
5 |
6 | */
7 |
8 | fun main() {
9 | val player = Player(34, "Halil Ozel", "Besiktas JK")
10 |
11 | println("Player's Name: ${player.name} -> Team: ${player.team} -> Number: ${player.number}")
12 | }
--------------------------------------------------------------------------------
/src/main/kotlin/ExtensionFunction.kt:
--------------------------------------------------------------------------------
1 | /*
2 | In Kotlin, you can also use extension function to extend a class with new functionalities.
3 | Basically, an extension function is a member function of a class that is defined outside the class.
4 |
5 | For example, you need to use a method to the String class that returns a new string with first and
6 | last character removed; this method is not already available in String class.
7 | You can use extension function to accomplish this task.
8 | */
9 |
10 |
11 | fun String.removeFirstLastChar(): String = this.substring(1, this.length - 1)
12 |
13 | fun main() {
14 | val myString = "Hello Kotlin"
15 | val result = myString.removeFirstLastChar()
16 | println("First character is: $result")
17 | }
--------------------------------------------------------------------------------
/src/main/kotlin/ForLoop.kt:
--------------------------------------------------------------------------------
1 | /*
2 | For Döngüsü : Belirli aralıklarla tekrar eden işlemleri çok kolay ve en az kod yazılacak şekilde kullanılır.
3 |
4 | Syntax :
5 |
6 | for (x in koleksiyon){
7 | // kodlar buraya yazılır.}
8 |
9 | - Döngüde belirtilen alana : dizi,liste,range veya string ifadeler gelebilir.
10 |
11 | */
12 |
13 | fun main() {
14 |
15 |
16 | // 1 den 10'a kadar ekranda "We Love Kotlin" mesajı bastır.
17 |
18 | for (i in 1..10) {
19 |
20 | println("We Love Kotlin")
21 | }
22 |
23 |
24 | // name değişkenine adımı yazdırıp onun karakterlerini ekranda tek tek gösteriyoruz.
25 |
26 | val name = "Halil İbrahim Özel" // name değeri verildi.
27 |
28 | for (ad in name) {
29 |
30 | if (!ad.equals(name.last())) { // son eleman değilse
31 | print("$ad,") // name değerini virgüllerle ile yaz.
32 | } else { // bu şartında dışında bir durumsa
33 | println(ad) // direkt name karakterlerini yaz
34 | }
35 | }
36 |
37 |
38 | // Bu örneğimizde array tanımlanıyor. Tanımlanan array değerlerini toplanıp sonucu ekranda gösteriliyor
39 |
40 | val sayilar = arrayOf(3, 4, 5, 6) // array tanımı
41 | var toplam = 0 // toplam değişkeni
42 |
43 | for (num in sayilar) { // sayılar dizisinin içeriği kadar gez
44 |
45 | toplam += num // dizi elemanları toplanıyor.
46 | }
47 |
48 | println("Toplam : $toplam") // dizi içinde toplanan değerler ekranda gösteriliyor.
49 |
50 |
51 | // Son örneğimizde iç içe for döngülerinde 1 den 3'e kadar dönüp onların toplamını ekranda gösteriyoruz.
52 |
53 | for (i in 1..3) { // i değeri 1 den 3 kadar
54 |
55 | for (j in 1..3) { // j değeride 1 den 3 e kadar
56 |
57 | println("$i + $j = ${i + j}") // dıştaki for çalışıyor ve sonra içteki for'a girip işlemleri yapıyor.
58 | // Sonrada değerler yazdırılıyor.
59 | }
60 | }
61 |
62 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Functions.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Değişkenlerde olduğu gibi atama operatörü ile metoda bir değer atanmıştır.
3 | Metot çağrıldığında yaş bilgisi ekrana yazılır.
4 | */
5 |
6 | fun myAge() = 21
7 |
8 | fun main() {
9 |
10 |
11 | //metod çağrıldı.
12 | println("My Age : ${myAge()}")
13 |
14 |
15 | println("Main metodu")
16 | showMessage() // fonksiyon çağırımı
17 |
18 |
19 | sumFun() // metodu çağır
20 |
21 |
22 | print("mesaj yazınız : ") // mesaj yazınız bildirimi
23 | val message: String = readLine()!! // kullanıcıdan değer al
24 | showMessage(message) // alınan değeri metoda yolla
25 |
26 |
27 | print("1. sayıyı giriniz : ") // 1. sayıyı al
28 | val number1: Double = readLine()!!.toDouble()
29 |
30 | print("2.sayıyı giriniz : ") // 2. sayıyı al
31 | val number2: Double = readLine()!!.toDouble()
32 |
33 | val sum: Double = sumComingNumbers(number1, number2) // girilen değerleri metoda yolladık.
34 |
35 | println("sayıların toplamı :" + sum) // toplam değerini yazdır.
36 |
37 |
38 | }
39 |
40 |
41 | // Parametre almayan metotlar
42 |
43 |
44 | fun showMessage(): Unit {
45 |
46 | println("Merhaba bu ilk fonksiyon")
47 |
48 | }
49 |
50 |
51 | // sumFun() 1 ile 10 arasındaki sayıların toplamını bulan ve ekrana yazdıran parametre almayan bir metoddur.
52 |
53 | fun sumFun(): Unit {
54 |
55 | var sum = 0 // toplam değeri için değişken tanımlandı.
56 |
57 | for (i in 1..10) { // for loop ile toplanacak sayı değerlerini topladık
58 | sum += i
59 | }
60 |
61 | println("sayıların toplamı : $sum") // toplam değeri yazdır.
62 |
63 | }
64 |
65 |
66 | // Parametre alan metodlar
67 |
68 | fun showMessage(commingMessage: String): Unit {
69 |
70 | println(commingMessage) // yollanan değeri ekranda yazdır.
71 |
72 | }
73 |
74 |
75 | // double tipinde x ve y değerleri tanımlanmıştır. metot return olarak Double tipinde bir değer döndürür.
76 | fun sumComingNumbers(x: Double, y: Double): Double {
77 |
78 | return x + y // gelen x ve y değerleri toplanıp return ile gönderilir.
79 | }
80 |
81 |
--------------------------------------------------------------------------------
/src/main/kotlin/Getters-Setters.kt:
--------------------------------------------------------------------------------
1 | // In Kotlin, a property don’t require explicit getter or setter methods:
2 |
3 | // var author: String = "Frank Herbert"
4 |
5 | // This is the same as defining the following get() and set() methods:
6 |
7 | var author: String = "Frank Herbert"
8 | get() {
9 | return field
10 | }
11 | set(value) {
12 | field = value
13 | }
14 | // The default getter and setter is a familiar pattern we see in Java, but in Kotlin,
15 | // we don’t have to create a private backing field for the property.
--------------------------------------------------------------------------------
/src/main/kotlin/Global-LocalVariables.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Değişkenler verileri tutan sembolik kavramlardır. Uygulama içinde değişkenler global ve yerel olmak
4 | üzere ikiye ayrılır. Global değişkenlere uygulama içinde herhangi bir yerden erişim sağlanır.
5 | Local değişkenlere ise sadece tanımlandıkları kod bloğu içinden erişilebilir.
6 |
7 | */
8 |
9 |
10 | var globalNumber = 12 // bu değişken global olduğu için verilen metotların hepsi bu değişkeni kullanabilir.
11 |
12 | fun fun1(): Unit {
13 |
14 | // bu değişken local olduğu için sadece fun1 metodu bu değişkene erişilebilir.
15 | // Diğer kod bloklarından erişilemez.
16 | var localNumber = 21
17 | println("fun1-global değişken : $globalNumber")
18 | }
19 |
20 |
21 | fun fun2(): Unit {
22 | println("fun2-global değişken : $globalNumber")
23 | // println("fun2-global değişken : $localNumber")
24 | }
25 |
26 | fun main() {
27 |
28 | println("main-global değişken : $globalNumber")
29 | // println("main-global değişken : "+localNumber)
30 | fun1()
31 | fun2()
32 | }
--------------------------------------------------------------------------------
/src/main/kotlin/HelloWorld.kt:
--------------------------------------------------------------------------------
1 | fun main() { // main fonksiyonu
2 |
3 | print("Hello World !!!") // print ekrana yazdırma metodu
4 |
5 | println("Hello World") // println alt satıra geçmek için kullanılır.
6 |
7 | }
8 |
9 | /*
10 | // Hello World Program
11 |
12 | class HelloWorldKt { // class tanımlanır.
13 |
14 | public static void main(String[] args) { // class içerisine metod tanımlanır.
15 | System.out.println("Hello, World!"); // metod içerisinde ekrana yazdırılır.
16 |
17 | }
18 | }
19 |
20 | */
--------------------------------------------------------------------------------
/src/main/kotlin/Increment-DecrementOperators.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | önden arttırma : ++a // önce değeri arttır sonra işlemi yap.
4 | önden azaltma : --a // önce değeri azalt sonra işlemi yap.
5 | arkadan arttırma : a++ // önce işlemi yap sonra arttırma
6 | önden azaltma : a-- // önce işlemi yap sonra azaltma
7 | -a : elemanı negatif yapar.
8 | +a : elemanı pozitif yapar.
9 | !a : a ya eşit olmama durumu
10 | */
11 |
12 |
13 | fun main() {
14 |
15 | var number = 5 // değişken tanımlandı.
16 | println(number) // değer ekranda gösterildi.
17 |
18 | ++number // number değeri 1 arttırıldı.
19 | println(number) // değer ekranda gösterildi.
20 |
21 | number-- // number değeri 1 azaltıldı.
22 | println(number) // değer ekranda gösterildi.
23 |
24 |
25 | }
--------------------------------------------------------------------------------
/src/main/kotlin/InfixFunction.kt:
--------------------------------------------------------------------------------
1 | /*Kotlin provides infix notation with which we can call a function with the class object without using
2 | a dot and parentheses across the parameter. Using infix function provides more readability to
3 | a function similar to other operators like in, is, as in Kotlin.*/
4 |
5 | class Check {
6 | // user defined infix member function
7 | infix fun dataType(types: Any): Any {
8 | val type = when (types) {
9 | is String -> "String"
10 | is Int -> "Integer"
11 | is Double -> "Double"
12 | is Char -> "Char"
13 | is Float -> "Float"
14 | else -> "Invalid"
15 | }
16 | return type
17 | }
18 | }
19 |
20 | fun main() {
21 | val check = Check()
22 | // call using infix notation
23 | val result = check dataType "Halil"
24 | println(result)
25 | }
26 |
27 |
28 |
--------------------------------------------------------------------------------
/src/main/kotlin/Inheritance.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Inheritance is one of the key features of object-oriented programming.
3 | It allows user to create a new class (inherited class) from an existing class (base class).
4 |
5 | The derived class inherits all the features from the base class and can have additional features of its own.
6 | */
7 |
8 |
9 | open class Human(age: Int, name: String) {
10 | init {
11 | println("My name is $name.")
12 | println("My age is $age")
13 | }
14 | }
15 |
16 | class Developer(age: Int, name: String) : Human(age, name) {
17 |
18 | fun writeCodes() {
19 | println("I write code in Halil Company.")
20 | }
21 | }
22 |
23 | class FootballPlayer(age: Int, name: String) : Human(age, name) {
24 | fun playFootball() {
25 | println("I play for Besiktas JK.")
26 | }
27 | }
28 |
29 | fun main() {
30 | val developer = Developer(25, "Halil")
31 | developer.writeCodes()
32 |
33 | println()
34 |
35 | val footballPlayer = FootballPlayer(38, "Ricardo")
36 | footballPlayer.playFootball()
37 | }
38 |
39 | /*
40 | If the class has a primary constructor, the base must be initialized using the parameters of
41 | the primary constructor. In the above program, both derived classes have two parameters age and name,
42 | and both these parameters are initialized in primary constructor in the base class.
43 | */
--------------------------------------------------------------------------------
/src/main/kotlin/InnerClass.kt:
--------------------------------------------------------------------------------
1 | class Outside {
2 | val outside = "Outside Nested class."
3 |
4 | /*
5 | class Inner {
6 | // Error! cannot access member of outer class.
7 | // fun doNotCallMeUp() = Let's do this!
8 | }*/
9 |
10 | // Inner classes carry a reference to an outside class and can access outside class members.
11 | inner class Inner {
12 | fun tellMe() = outside
13 | }
14 | }
15 |
16 | /*
17 | The nested classes do not have access to the outer class instance.
18 | */
19 |
20 | fun main() {
21 |
22 | val outer = Outside()
23 | println("Outside : ${outer.Inner().tellMe()}")
24 |
25 | // println(outer.Nested.doNotCallMeUp()) -> Classifier 'Nested' does not have a companion object, and thus must be initialized her.
26 |
27 | val inner = Outside().Inner()
28 | println("Inner : ${inner.tellMe()}")
29 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Input-Output.kt:
--------------------------------------------------------------------------------
1 | fun main() {
2 |
3 | println("1. println "); // ln eki işlemi yap sonra alt satıra geç anlamında kullanılır.
4 | println("2. println ");
5 |
6 | print("1. print "); // print metodu ise işlemi yap herhangi bir atlama vs olmadan devam et
7 | print("2. print");
8 |
9 |
10 | val score = 99
11 |
12 | println("score") // score
13 | println(score) // 99
14 | println("score : $score") // score : 99
15 | println("$score") // 99
16 | println("score : $score") // score : 99
17 |
18 | /*
19 |
20 | Ekranda değeri göstermek için birden farklı yol bulunmaktadır :
21 |
22 | 1- Direkt değişken değeri verilir
23 |
24 | 2 - String ifade ile kullanıp daha sonra + işaretini koyup yanına değişken adı verilir.
25 |
26 | 3 - Çift tırnaklar arasına $ işaretinin yanına değişken eklenir. Bu yöntem PHP ve Javascript dillerinde de mevcuttur.
27 |
28 | 4- String ifadeler içinde hem değişken adı hem içeriği $ işareti ile kullanılarak yapılabilir.
29 | */
30 |
31 |
32 | // Kotlinde kullanıcıdan bir veri veya değer almak için readLine() metodu kullanılır.
33 |
34 |
35 | print("What is your name : ") // adını girmesi için bir soru soruldu.
36 |
37 | val name = readLine() // readLine metoduyla adını okunuyor
38 |
39 | println("My name is $name") // ekranda adı yazdırılıyor
40 |
41 |
42 | // Eğer alınan değer String bir ifadeden farklı ise readLine()!!.toX şeklinde kullanılır.
43 | // X yerine değişkenin türü : Int,Float,Double vs
44 |
45 | print("How old are you : ") // kaç yaşındasınız sorusu soruldu.
46 | val age = readLine()!!.toInt() // int türünde değer okuması yapıldı.
47 | println("I am $age years old") // okunan değer ekranda gösterildi.
48 |
49 |
50 | }
--------------------------------------------------------------------------------
/src/main/kotlin/InterfaceSample.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Kotlin interface is similar to interface in Java.
3 | They can contain definitions of abstract methods as well as implementations of non-abstract methods.
4 | Interface cannot contain any state.
5 | */
6 |
7 | interface MyInterface {
8 |
9 | val seasonNumber: Int
10 |
11 | fun askQuestion(): String
12 |
13 | fun sayHi() {
14 | println("Hey, Fellas!")
15 | }
16 | }
17 |
18 |
19 | class InterfaceSample : MyInterface {
20 | override val seasonNumber: Int = 2
21 | override fun askQuestion() = "Biscuit or Cookie"
22 | }
23 |
24 | fun main() {
25 |
26 | val interfaceSample = InterfaceSample()
27 |
28 | println("season Number = ${interfaceSample.seasonNumber}")
29 |
30 | interfaceSample.sayHi()
31 |
32 | println(interfaceSample.askQuestion())
33 | }
--------------------------------------------------------------------------------
/src/main/kotlin/LogicalOperators.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | && and(ve) : true - true koşulu için true değeri döndürür. Geri kalan işlemler için false döndürür.
4 |
5 | || or(veya) : false - false koşulu için false değeri döndürür. Geri kalan işlemler için true döndürür.
6 |
7 | */
8 |
9 |
10 | fun main() {
11 |
12 |
13 | val a = true
14 |
15 | val b = true
16 |
17 | println(a && b) // true - true : true
18 | println(!a && b) // false - true : false
19 | println(a && !b) // true - false : false
20 | println(!a && !b) // false - false : false
21 |
22 | println("------------------------------")
23 |
24 | println(a || b) // true - true : true
25 | println(!a || b) // false - true : true
26 | println(a || !b) // true - false : true
27 | println(!a || !b) // false - false : false
28 |
29 |
30 | }
--------------------------------------------------------------------------------
/src/main/kotlin/MapExample.kt:
--------------------------------------------------------------------------------
1 | fun main() {
2 |
3 | val mapOne = mapOf(7 to "Ricardo Quaresma", 34 to "Hugo Almeida", 31 to "Simao Sabrosa")
4 | println("map-1: ${mapOne[34]}")
5 |
6 | val mapTwo = hashMapOf(19.93 to true, 19.97 to false, 19.95 to true)
7 | val mapFour = hashMapOf()
8 | println(mapTwo.contains(19.95))
9 | println(mapFour.contains("Halil"))
10 | mapFour.clear()
11 | println(mapFour)
12 |
13 | for (entity in mapTwo) { // map içindeki bulunan key-value olarak entity değişkenine atanır.
14 | println(entity) //entity içinde key-value birlikte olduğu için ekranda da beraber çıktı verir.
15 | }
16 |
17 | val mapYears = mutableMapOf()
18 |
19 | mapYears.put('b', 2015)
20 | mapYears.put('j', 2016)
21 | mapYears.put('k', 2021)
22 |
23 | println(mapYears)
24 | }
--------------------------------------------------------------------------------
/src/main/kotlin/MethodOverloading.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Overloading : İsimleri aynı ancak parametre tipleri farklı olan metotlara denir.
4 | Metot isimleri aynı ve parametreler farklı olmalıdır.
5 |
6 | */
7 |
8 |
9 |
10 | // gelen sayıyı return ile döndürür.
11 | fun mix(x: Int): Int {
12 |
13 | return x
14 | }
15 |
16 | // gelen iki sayıyı toplar ve sonucunu return ile döndürür.
17 | fun mix(x: Int, y: Int): Int {
18 |
19 | return x + y
20 | }
21 |
22 | // gelen üç sayıyı toplar ve sonucu return ile döndürür.
23 | fun mix(x: Int, y: Int, z: Int): Int {
24 |
25 | return x + y + z
26 | }
27 |
28 | fun main() {
29 | // her metot tek tek çağrılır.
30 | println("mix(x):" + mix(10))
31 | println("10+20 : " + mix(10, 20))
32 | println("10+20+30 :" + mix(10, 20, 30))
33 | }
--------------------------------------------------------------------------------
/src/main/kotlin/MultiformFunction.kt:
--------------------------------------------------------------------------------
1 | // Çok Biçimli Metodlar : İsimleri aynı , parametre tipleri farklı olan yapılardır.
2 |
3 |
4 | // showInformation() 3 metodun parametre tipleri farklı olduğu için bu metoda çok biçimli metod deniliyor.
5 |
6 | // bu metot ile kişinin ismi alınır ve print ile ekrana yazılır.
7 | fun showInformation(name: String): Unit {
8 | println("İsminiz : $name")
9 | }
10 |
11 | // bu metot ile kişinin yaş bilgisi alınır ve print ile ekrana yazılır.
12 | fun showInformation(age: Int): Unit {
13 | println("Yaşınız : $age")
14 | }
15 |
16 |
17 | // bu metot ile kişinin doğum tarihi alınır ve print ile ekrana yazılır.
18 | fun showInformation(birth: Long): Unit {
19 | println("Doğum Tarihiniz : $birth")
20 | }
21 |
22 | fun main() {
23 |
24 | // her metod tek tek ilgili parametreleriyle çağrılır.
25 |
26 | showInformation("Halil")
27 | showInformation(21)
28 | showInformation(birth = 1997)
29 |
30 |
31 | }
--------------------------------------------------------------------------------
/src/main/kotlin/NestedClass.kt:
--------------------------------------------------------------------------------
1 | class External {
2 |
3 | val lowInfo = "This is Outside Nested Class."
4 |
5 | class Nested {
6 | val highInfo = "This is Inside Nested Class."
7 | fun callMeUp() = "Function call from inside Nested Class."
8 | }
9 | }
10 |
11 | /*
12 | Kotlin allows you to define a class within another class known as nested class.
13 | */
14 |
15 | fun main() {
16 |
17 | // Accessing member of Nested class
18 | println(External.Nested().highInfo)
19 |
20 | // Accessing member of External class
21 | val external = External()
22 | println(external.lowInfo)
23 |
24 | // Creating object of Nested class
25 | val nested = External.Nested()
26 | println(nested.callMeUp())
27 | }
--------------------------------------------------------------------------------
/src/main/kotlin/NestedifExpression.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | İç içe if kullanımı birçok yerde bizlere kolaylık sağlıyor. Örneğin 3 adet sayıyı karşılaştırma
4 | işleminde rahatlıkla iç içe if else kullanıp sonucu elde edebiliri.
5 | */
6 |
7 | fun main() {
8 |
9 | val n1 = 3
10 | val n2 = 5
11 | val n3 = -2
12 |
13 | val max = if (n1 > n2) { // n1 değeri n2 değerinden büyükse
14 | if (n1 > n3) // n1 değeri n3 değerinden büyükse
15 | n1 // n1 max değerdir.
16 | else // yoksa
17 | n3 // n3 değeri maximumdur.
18 | } else { // n2 değeri n1 değerinden büyükse
19 | if (n2 > n3) // n2 değeri n3 değerinden büyükse
20 | n2 // n2 değeri max
21 | else // n3 değeri n2 den büyükse
22 | n3 // n3 değeri maximum
23 | }
24 |
25 | println("max = $max") // sonuç değeri ekranda gösteriliyor.
26 |
27 | }
--------------------------------------------------------------------------------
/src/main/kotlin/NullSafety.kt:
--------------------------------------------------------------------------------
1 | fun main() {
2 |
3 | val name: String? = null // name değişkeni String veya null da olabilir.
4 |
5 | println(name) // null değer dönderir.
6 |
7 | println(name?.length) // güvenli bir şekilde ekranda gösterme içerisinde null olabilir diye belirttik.
8 |
9 | // println(name!!.length) null olup olmaması önmeli değil kullanımıdır. Null Pointer Exception fırlatır.
10 |
11 |
12 | var sayi: Int? // int türünde ama null değerde olabilir.
13 | sayi = 10
14 | println(sayi) // sayi değeri ekranda gösterildi.
15 |
16 | sayi = null // int türündeki değişkene null değer atandı.
17 | println(sayi) // sayi değeri ekranda gçsterdik.
18 | println(sayi.toString().length) // sayi değerini stringe dönüştür ve uzunluğunu bul
19 |
20 | }
--------------------------------------------------------------------------------
/src/main/kotlin/OperatorOverloading.kt:
--------------------------------------------------------------------------------
1 | /*
2 | You can also define how operator works for objects by overloading its corresponding function.
3 | For example, you need define how + operator works for objects by overloading plus() function.
4 |
5 | */
6 |
7 | fun main() {
8 |
9 | val numbersOne = Numbers(3, 5)
10 | val numbersTwo = Numbers(7, 1)
11 |
12 | val sum: Numbers = numbersOne + numbersTwo
13 | println("sum = (${sum.numberOne}, ${sum.numberTwo})")
14 | println(Numbers().numberOne)
15 | println(Numbers().numberTwo)
16 | }
17 |
18 | class Numbers(val numberOne: Int = 19, val numberTwo: Int = 3) {
19 |
20 | // Overloading plus function
21 | operator fun plus(numbers: Numbers): Numbers {
22 | return Numbers(numberOne + numbers.numberOne, numberTwo + numbers.numberTwo)
23 | }
24 | }
25 |
26 | /*
27 | - When you overload operators, you should try to maintain the original spirit of the operator.
28 | - Unlike languages like Scala, only a specific set of operators can be overloaded in Kotlin.
29 | */
--------------------------------------------------------------------------------
/src/main/kotlin/Player.kt:
--------------------------------------------------------------------------------
1 | data class Player(
2 | var number: Int,
3 | var name: String,
4 | var team: String
5 | )
6 |
--------------------------------------------------------------------------------
/src/main/kotlin/Range.kt:
--------------------------------------------------------------------------------
1 | /*
2 | Range : Türkçe Aralık anlamındadır.
3 | Örnek verirsek elimizde bir değer var ve bu değerin belirttiğimiz aralıkta mı yoksa değil mi ?
4 | onun cevabını kolayca bulmamız için geliştirilmiş bir yapıdır.
5 |
6 | */
7 |
8 | fun main() {
9 |
10 | var sayilar = 1..20 // 1 den 20 ye kadar ileri
11 | var adanZye = 'a'..'z' // z den a ya kadar ileri
12 |
13 | var sayilarTersten = 20 downTo 1 // 20 den 1 e kadar geriye
14 | var harfleTersten = 'z' downTo 'a' // z den a ya kadar geriye
15 |
16 |
17 | var oneToTwenty = 1.rangeTo(20) // 1 den 20 ye kadar
18 |
19 | var oneToTwentyReverse = 20.downTo(1) // 20 den geriye doğru aralık büyükten küçüğe doğru ise kullanılır.
20 |
21 |
22 | val beserBeserSayilar = 0.rangeTo(100).step(5) // 5 er 5 er 100'e kadar
23 |
24 |
25 | var beserBeserSayilarReverse = (100 downTo 5).step(5) // 5 er 5 er 100'e kadar
26 |
27 | println(beserBeserSayilar.first) // ilk elemanı
28 | println(beserBeserSayilar.last) // son elemanı
29 | println(beserBeserSayilar.step) // kaçar kaçar işlem yapılıyor.
30 |
31 | for (i in 1 until 5) { // until : 1 den 5 e kadar anlamında kullanılır. (..) yerine kullanılabilir.
32 |
33 | println(i) // ekranda i değerleri gösterildi.
34 | }
35 | }
--------------------------------------------------------------------------------
/src/main/kotlin/RecursiveFunction.kt:
--------------------------------------------------------------------------------
1 | var i = 5 // global değişken tanımı
2 |
3 | /*
4 | Bir metot kendi kendine çalıştırılabiliyorsa bu metotlara özyinelemeli metotlar denir.
5 | Değişken sıfır veya sıfırdan büyük olduğu sürece metot ekrana mesaj yazdıktan sonra
6 | kendisini çağırır. Her çağrımda i değişkeni azalır.
7 |
8 | */
9 |
10 | fun rekursif(): Unit {
11 |
12 | i-- // i değeri bir azalır.
13 |
14 | // i değişkeni bir azaldıktan sonra sıfır veya sıfırdan büyükse ekrana mesaj yazdır ve kendini tekrar çağır.
15 | if (i >= 0) {
16 | println("rekursif mesaj")
17 | rekursif()
18 | } else { // i değişkeni sıfırdan küçükse mesaj bastır.
19 | print("rekursif sonu")
20 | }
21 |
22 |
23 | }
24 |
25 | fun main() {
26 | rekursif() // rekürsif metot önce main() içinden çağrılmalıdır.
27 | }
--------------------------------------------------------------------------------
/src/main/kotlin/SealedClass.kt:
--------------------------------------------------------------------------------
1 | /*
2 | A sealed class defines a set of subclasses within it.
3 | It is used when it is known in advance that a type will conform to one of the subclass types.
4 | Sealed classes ensure type safety by restricting the types to be matched at compile-time rather than at runtime.
5 | */
6 |
7 | sealed class Demo {
8 | object One : Demo() {
9 | fun display() {
10 | println("Object A of Sealed class Demo ")
11 | }
12 | }
13 |
14 | object Two : Demo() {
15 | fun display() {
16 | println("Object B of sealed class Demo")
17 | }
18 | }
19 | }
20 |
21 | fun main() {
22 | val objOne = Demo.One
23 | objOne.display()
24 | val objTwo = Demo.Two
25 | objTwo.display()
26 | }
27 |
28 |
--------------------------------------------------------------------------------
/src/main/kotlin/TopLevelMethod.kt:
--------------------------------------------------------------------------------
1 | import toplevelmethod.Simple
2 | import toplevelmethod.topLevelMethods
3 |
4 |
5 | fun main() {
6 | topLevelMethods() // metoda erişim için projeye doğrudan import edilir.
7 |
8 | val obj = Simple() //metoda erişim için Simple sınıfından bir nesne oluşturup kullanmak gerekir.
9 | print(obj.localMethod())
10 | }
--------------------------------------------------------------------------------
/src/main/kotlin/TypeConversion.kt:
--------------------------------------------------------------------------------
1 | // Tip dönüşümleri
2 |
3 | /*
4 |
5 | Kotlin'de, bir türün sayısal değeri, diğer tür daha büyük olduğunda bile otomatik olarak başka bir türe dönüştürülmez.
6 | Bu durum Javada daha farklı bir durumdur.
7 |
8 | */
9 |
10 | fun main() {
11 |
12 | /*
13 |
14 | Java da,
15 |
16 | int number1 = 55;
17 | long number2 = number1;
18 |
19 | Burada, int türünün number1 değeri otomatik olarak uzunluğuna dönüştürülür ve değişken number2'ye atanır.
20 |
21 | */
22 |
23 |
24 | //val number1: Int = 55
25 | //val number2: Long = number1 // Error: type mismatch.
26 |
27 |
28 | /*
29 |
30 | Long'un boyutu Int'ten büyük olsa da, Kotlin otomatik olarak Int'ten Long'a dönüşmez.
31 |
32 | Bunun yerine, toLong () öğesini kullanmanız gerekir.
33 | Kotlin, sürprizlerden kaçınmak ve tip güvenliği için yapıyor.
34 |
35 | */
36 |
37 | val number1: Int = 55 // int türünde bir değişken tanımlandı.
38 | val number2: Long = number1.toLong() // number1 değişkenini toLong() metodu yardımıyla long türüne dönüştürdük.
39 | println(number2) // dönüştürülen değişken ekranda gösterildi.
40 |
41 |
42 | /*
43 |
44 | Kotlin'de tip dönüşümü için kullanılan işlevlerin listesi:
45 |
46 | toByte()
47 | toShort()
48 | toInt()
49 | toLong()
50 | toFloat()
51 | toDouble()
52 | toChar()
53 |
54 | Bool türler için dönüştürme yoktur.
55 |
56 | Büyük tipten daha küçük tipe dönüşüm vardır.
57 |
58 | Bu dönüşümde değer kaybı olmaktadır.
59 |
60 | */
61 |
62 | val number_1: Int = 545344 // int türünde bir değişken
63 | val number_2: Byte = number_1.toByte() // int türündeki değişken byte türüne dönüştürülüyor.
64 | println("number_1 = $number_1") // 545344
65 | println("number_2 = $number_2") // 64
66 | }
--------------------------------------------------------------------------------
/src/main/kotlin/Variables.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Kotlinde iki tip değişken bulunmaktadır.
4 | Bunlar : var ve val
5 |
6 | var : variable kelimesinden gelmektedir. Değişen değerler için kullanılır.
7 |
8 | val : value kelimesinden gelmektedir. Değişmeyen ya da sabit değerler için kullanılır.
9 |
10 | val değişkenin kullanımı Javada final kelimesine denk gelmektedir.
11 |
12 |
13 | */
14 |
15 |
16 | fun main() {
17 |
18 | val name: String // name adında bir değişken tanımlandı.
19 |
20 | name = "Halil" // tanımlanan değişkene String türünde bir içerik atandı.
21 |
22 | println("My name is :$name") // name değişkeninin içeriğini ekranda gösterir.
23 |
24 | val pi: Double = 3.14 // pi adında Double türünde bir değişken tanımı yapılıp değeri atandı.
25 |
26 | println("pi :$pi") // pi değerini ekrana yazdırır
27 |
28 | /*
29 |
30 | Kotlin Java gibi değişken türünü illa belirteceksin gibi bir zorunluluğu kaldırmıştır.
31 | Kullanıcı ister türünü belirtir isterse belirtmez kod işlendiği anda hangi değişken
32 | türüne ait onu kendisi anlamaktadır.
33 |
34 | Java'da : String name = "Name"
35 |
36 | Kotlin'de : var name = "Name"
37 |
38 | Değişken tanımı yapılınca aşağıdaki gibi yollar izlenilebilir :
39 |
40 | 1 - var name = "Name" // 1. adımda değişken tipini belirtmeden direkt kullanılacak yapı atanır.
41 |
42 | 2 - var name : String // 2. adımda ise öncelikle değişken türünü belirtip daha sonra içerik atanabilir.
43 | name = "Name"
44 |
45 | 3 - var name : String = "Name" // 3. adımda tek satırda hem değişken türü hem de içeriği verilir.
46 | */
47 | }
--------------------------------------------------------------------------------
/src/main/kotlin/VisibilityModifiers.kt:
--------------------------------------------------------------------------------
1 | /**
2 | public: Visible everywhere
3 | private: Visible inside the same class only
4 | internal: Visible inside the same module
5 | protected: Visible inside the same class and its subclasses
6 | */
7 |
8 | // By Default Public Class
9 | class TeamOne {
10 | var number = 100
11 | }
12 |
13 | // Specified with Public modifier
14 | public class TeamTwo {
15 | var number = 200
16 | fun show() {
17 | println("Accessible everywhere")
18 | }
19 | }
20 |
21 | // TeamThree is accessible from same source file
22 | private class TeamThree {
23 | private val number = 50
24 | fun show() {
25 | // We can access number in the same class
26 | println(number)
27 | println("Accessing number successful")
28 | }
29 | }
30 |
31 | // Internal modifier benefits in writing APIs and implementations.
32 | internal class TeamFour {}
33 |
34 | public class TeamFive {
35 | internal val number = 300
36 | internal fun show() {}
37 | }
38 |
39 | open class TeamSix {
40 | // Protected variable
41 | protected val number = 75
42 | }
43 |
44 | // Inherited Class
45 | class TeamSeven : TeamSix() {
46 | fun getValue(): Int {
47 | // Accessed from the subclass
48 | return number
49 | }
50 | }
51 |
52 | fun main() {
53 | val teamOne = TeamOne()
54 |
55 | println("teamOne - Number : ${teamOne.number}")
56 |
57 | val teamTwo = TeamTwo()
58 | teamTwo.show()
59 |
60 | val teamThree = TeamThree()
61 | teamThree.show()
62 |
63 | // println(teamThree.number) -> Can not access 'number': it is private in class TeamThree
64 |
65 | val teamSeven = TeamSeven()
66 | println("Value: " + teamSeven.getValue())
67 | }
68 |
--------------------------------------------------------------------------------
/src/main/kotlin/When.kt:
--------------------------------------------------------------------------------
1 | /**
2 | When yapısı Javada kullanılan switch-case yapısına benzemektedir.
3 | Daha esnek bir yapıya sahip olan When ile daha kolay şartları yapabileceksiniz.
4 | */
5 |
6 | fun main() {
7 |
8 | val a = 12
9 | val b = 5
10 |
11 | print("Enter operator either +, -, * or / : ") // istenilen işlem ile ilgili seçeneği seçiliyor.
12 |
13 | val result = when (val operator = readlnOrNull()) { // seçilen operatör okunuyor.
14 | "+" -> a + b // + ise : toplama işlemi
15 | "-" -> a - b // - ise : çıkarma işlemi
16 | "*" -> a * b // * ise : çarpma işlemi
17 | "/" -> a / b // / ise : bölme işlemi
18 | else -> "$operator operator is invalid operator." // başka bir karakter girilirse
19 | }
20 |
21 | println("result = $result") // sonuç ekranda gösteriliyor.
22 |
23 |
24 | // Birden fazla değere sahip ifadenin içeriğinde bulunup bulunmamasına bakılıyor.
25 |
26 | val n = -1 // değişken tanımlandı.
27 |
28 | when (n) { // n değeri
29 | 1, 2, 3 -> println("n is a positive integer less than 4.") // 1,2,3 den biriyse
30 | 0 -> println("n is zero") // n 0 dır.
31 | -1, -2 -> println("n is a negative integer greater than 3.") // -1,-2 ise negatif
32 | }
33 |
34 |
35 | // range(aralık) belirtilerekde kullanılabilir.
36 |
37 | val j = 100 // j değişkenine 100 değeri atandı.
38 |
39 | when (j) { // j değeri
40 | in 1..10 -> println("A positive number less than 11.") // 1 ile 10 arasında ise
41 | in 10..100 -> println("A positive number between 10 and 100 (inclusive)") // 10 ile 100 arasında ise
42 | }
43 | }
--------------------------------------------------------------------------------
/src/main/kotlin/WhileLoop.kt:
--------------------------------------------------------------------------------
1 | /**
2 | While döngüsü, programın bir bölümünü birkaç kez yinelemek için kullanılır.
3 | Döngü, koşul doğru olana kadar kod bloğunu yürütür.
4 |
5 | Syntax
6 |
7 | while (testExpression) {
8 | // while döngüsünün içindeki kodlar
9 | }
10 | */
11 |
12 |
13 | fun main() {
14 | var i = 1 // i değeri verildi.
15 |
16 | while (i <= 5) { // i 5'e eşit veya 5 ten küçük olana kadar
17 | println("$i") // i değerini yazdır.
18 | ++i // önden arttırım
19 | }
20 |
21 | // 0 dan 10 'a kadar olan sayıların toplamını bulan program
22 | var sum = 0 // toplama değişkeni tanımlandı.
23 | var j = 10 // j değeri verildi.
24 |
25 | while (j != 0) { // j değeri 0 dan farklı ise
26 | sum += j // sum = sum + j; // sum ile j değerini topla
27 | --j // j değerini azalt ve döngüye devam et
28 | }
29 | println("sum = $sum") // toplam değerini yazdır.
30 | }
--------------------------------------------------------------------------------
/src/main/kotlin/do...whileLoop.kt:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | Do-while : While döngüsüne benzemektedir.
4 | Tek farkı ilk önce koşula bakılmadan ilk adım yapılıyor sonrada artık koşul içindeki işlemlere bakılıyor.
5 |
6 | Sytanx :
7 |
8 | do {
9 | // codes inside body of do while loop
10 | } while (testExpression);
11 |
12 | */
13 |
14 | fun main() {
15 |
16 | // Example - 1
17 |
18 | var i = 6 // i değerini tanımladık.
19 | do {
20 | println(i) // i değerini ekrana yazdır.
21 | i++ // i değerini arttır.
22 | } while (i <= 5); // i değeri 5'e eşit veya 5 ten küçükse
23 |
24 |
25 | // Example - 2
26 |
27 | var j = 1 // j değerini tanımladık.
28 | do {
29 | println(j) // koşula bakmadan ilk işlem yapılıyor.
30 | j++ // j değerini arttır.
31 | } while (j <= 5); // koşul devam ettikçe işlemleri yap.
32 |
33 |
34 | }
--------------------------------------------------------------------------------
/src/main/kotlin/if..else..ifExpression.kt:
--------------------------------------------------------------------------------
1 | fun main() {
2 |
3 |
4 | // Pozitif - Negatif Sayı Bulma
5 |
6 | val number = 58 // number değişken tanımı
7 |
8 | val result = if (number > 0) // number 0 dan büyükse
9 | "positive number" // pozitif
10 | else if (number < 0) // number 0 dan küçükse
11 | "negative number" // negatif
12 | else // ya da başka bir değere eşitse yani 0'a eşitse
13 | "zero" // sıfır
14 |
15 | println("number is $result") // sonucun ne olduğu ekranda gösteriliyor.
16 |
17 |
18 | // Üniversite harf notu hesaplama örneği
19 |
20 |
21 | print("Vize notunuz :") // vize notu isteniyor.
22 |
23 | val vize = readLine()!!.toDouble() // vize notu double türde alınıyor.
24 |
25 | print("Final notunuz :") // final notu isteniyor.
26 |
27 | val final = readLine()!!.toDouble() // final notu double türde alınıyor.
28 |
29 | val ortalama = (vize * 0.4) + (final * 0.6) // ortalama hesabı yapılıyor.
30 |
31 | val sonuc = if (ortalama >= 70) //eğer ortalama 70'e eşit ve üstü ise
32 | "AA"
33 | else if (ortalama < 70 || ortalama >= 60) // ortalama 70 den küçük veya 60 a eşit ve büyükse
34 | "BB"
35 | else if (ortalama < 60 || ortalama >= 50) // ortalama 60 dan küçük veya 50 ye eşit ve büyükse
36 | "CC"
37 | else if (ortalama < 50 || ortalama >= 40) // ortalama 50 den küçük veya 40 a eşit ve büyükse
38 | "DD"
39 | else // farklı bir değerde ise
40 | "FF"
41 |
42 | println("Ortalama : " + ortalama) // ortalama değeri
43 | println("Sonuc : $sonuc") // sonuc değeri
44 |
45 | }
--------------------------------------------------------------------------------
/src/main/kotlin/ifExpression.kt:
--------------------------------------------------------------------------------
1 | // if : İngilizce eğer anlamına gelmektedir. Şart sözcüğüdür.
2 | // Örneğin şu yaşındaysam ben gencim tarzında bir mesaj verdirilir.
3 | // Farklı bir yaşta ise diğer bir şart ifadesi olan else devreye girer.
4 |
5 |
6 | fun main() {
7 |
8 |
9 | val number = 10 // number değişkeni tanımlandı.
10 |
11 | val result = if (number > 0) { // eğer number 0 dan büyükse
12 | "Positive number" // pozitif
13 | } else { // eğer 0 dan farklı ise
14 | "Negative number" // negatif
15 | }
16 |
17 | println(result) // sonuç değeri yazdırıldı.
18 |
19 |
20 | val a = 9 // int türünde pozitif bir tam sayı tanımlandı.
21 | val b = -11 // negatif türde bir tam sayı tanımlandı.
22 |
23 | val max = if (a > b) { // eğer a b den büyükse
24 | println("$a is larger than $b.") // a b den büyüktür.
25 | println("max variable holds value of a.") // B max değişkeni
26 | a // 9
27 | } else { // farklı bir durumda ise
28 | println("$b is larger than $a.") // b a dan büyüktür.
29 | println("max variable holds value of b.") // A max değişkeni
30 | b // -11
31 | }
32 | println("max = $max") // max değeri ekranda gösterildi.
33 |
34 |
35 | }
--------------------------------------------------------------------------------
/src/main/kotlin/inOperator.kt:
--------------------------------------------------------------------------------
1 | // in : operatörü bir dizinin ya da yapının içinde herhangi bir eleman bulunuyor mu onu kontrol edilir.
2 | // string bir metod olan contains ile aynı işlevi yapmaktadır.
3 |
4 | fun main() {
5 |
6 | val numbers = intArrayOf(1, 4, 42, -3) // int türünde değerler içeren bir yapı
7 |
8 | if (4 in numbers) { // numbers içinde 4 var mı acaba ?
9 | println("numbers array contains 4") // 4 bulunduğu ile ilgili mesajı yazdırıyoruz
10 |
11 | }
12 |
13 | }
--------------------------------------------------------------------------------
/src/main/kotlin/main.kt:
--------------------------------------------------------------------------------
1 | fun main() {
2 | println("Hello World!")
3 | }
--------------------------------------------------------------------------------
/src/main/kotlin/toplevelmethod/Simple.kt:
--------------------------------------------------------------------------------
1 | package toplevelmethod
2 |
3 | /*
4 |
5 | Herhangi bir sınıf nesne veya arayüz içinde olmadığından dolayı bu metot
6 | top-level metodudur. import ile bu metot doğrudan başka bir projeye eklenebilir.
7 | Bunun için nesne tanımlamaya gerek yoktur.
8 |
9 | */
10 |
11 | fun topLevelMethods(){
12 | println("bu top-level metodunun bir mesajıdır.")
13 | }
14 |
15 | /*
16 |
17 | Bu metot local olduğu ve bir sınıf içinde tanımlandığından dolayı import ile doğrudan
18 | başka bir projeye eklenmez. Bu metoda erişim için Simple sınıfından bir nesne oluşturmak gerekir.
19 |
20 | */
21 |
22 | class Simple {
23 |
24 | fun localMethod(){
25 | println("bu local metodunun bir mesajıdır.")
26 | }
27 | }
--------------------------------------------------------------------------------