Kotlin

1
Yazım Kuralları ⇒
1- Kotlin küçük ve büyük harf duyarlılığı olan bir dildir .
2- Sınıf isimleri her zaman büyük harf ile başlamalıdır . Eğer verilen sınıf ismi birden fazla kelimeden oluşuyorsa o halde her kelimenin ilk harfi büyük olarak
yazılmalıdır .
3- Metod ve değişken isimleri ise küçük harfle başlamalıdır . Eğer birden fazla kelimeden oluşuyor ise ilk kelimeden sonra gelen kelimelerin ilk harfleri büyük
olarak yazılmalıdır .
4- Kotlin ’de öğe isimleri sayisal ifadelerle başlayamaz . Ancak bu ifadeler öğenin ilk karakterinden sonra gelebilir . Örnek : a16şkım256 gibi ...
Yorum Satırı ⇒
Yorum satırı Kod satırları içerisin de yer alan açıklamalardır . Program çalışırken yorum satırlarını okumaz .
Yorum Satırı nasıl yazılır ? // Yorum satırını böyle oluşturabilirsiniz .
Oluşturulan yorum satırı program içerisinde Gri renkte görülür .

/*
Birden fazla satırı Yorum satırına çevirir.
*/
Ayrıca Ekrana yazı yazdırmak için println ( ) kullanabiliriz . Uygulanışı ;
println ( “ Seni çok Seviyorum Şeyma ” ) gibi…
Fare ile seçili bir alanı yorum satırına dönüştürmek isterseniz . Ctrl + Sol Shift + / kısayolunu kullanınız .
Değişken Tanımlama ⇒
Değişkenler kısaca verilerin tutulduğu ve saklandığı yapılar olarak tanımlayabiliriz .
val sayi1 : Int // Int tipinde değişken tanımladık .
Eğer aynı satırda birden fazla boş bir değişken tanımlamak isterseniz değişkenler arasına ; işareti koyunuz . Örnek :
var sayi1 : Int ; var seyma : Int
Bu kısmı sakın unutmayınız . Değer belirterek değişken veri türünü tanımlama nasıl yapılır ?
val sayi = 10 // Değer belirterek değişken tanımladık .
Değer ataması yaparken tür belirtmesine gerek yoktur . Çünkü kotlin dili değerin türüne göre değişken türünü belirleyecektir .
Eğer ki değişkeni tanımlayıp daha sonra kullanacak iseniz tür belirtmelisiniz .
val sayi1 : Int
Peki ya veri ataması yaparken nasıl yapmalıyız ?
sayi1 = 10
val . Değişebilen değerler için kullanılmaktadır .

sayi1 . Kullanıcının belirlediği Değişken ismidir .
= . Atama işlemini gerçekleştiren semboldür .
10 . Atanan Tam sayı veridir .
Belirlediğimiz değişkeni her yerde kullanabiliriz . Kodlar her zaman soldan sağa ve yukarıdan aşağıya doğru okunmaktadır .
Bunun anlamı bir değişkene her zaman için en son verdiğiniz atama geçerli olacaktır .
A- Sabitler ( var | val ) ⇒

var : Kelime olarak Variable anlamına gelir . Değişkene ilk atamayı yaptıktan sonra tekrar atama yapabilirsiniz .
val : Kelime olarak Values anlamına gelir . Değişkene ilk atama harici sonraki kullanımlarda değer atamanıza izin vermez .
2
Ekrana Yazdırma ⇒
Peki ya Ekrana yazdırmak istersek ?
val sayi1 = 10
Bunun için : println ( sayi1 )
Not ; Değer atanmamış değişkenler ekrana yazdırılamaz . Eğer ekrana yazı yazdırmak istiyorsanız .
println ( “ Merhaba Ben Ramazan ” )
Çift tırnaklar içerisine Metinsel ifadeler yazabilirsiniz yada metinsel ifadeyi bir değişkene atadıktan sonra da ekrana yazdırabilirsiniz . Örnek :
val sayi1 = " Ramazan KOLDAŞ "
println ( sayi1 )
Eğer ben metin içerisinde kod çalıştırmak istersem :
val şeyma = “ Şeyma ”
println ( “Ramazan seni çok seviyor $ { şeyma }” ) // İlk olarak $ ( Dolar işareti ) daha sonra blokların içerisine kodları yazınız .
veya
println ( “Ramazan seni çok seviyor $ şeyma ” ) // İlk olarak $ kodları yazınız . Uyarı : Eğer kod bitimi boşluk bırakırsanız String olarak algılanır .
Sayısal Veri Tipleri ⇒

Int ⇒
Tam Sayılar için kullanılan veri tipidir . ( 4 Byte alan kaplar . -2147483648 ile 2147483647 değerler kadarı rakam almaktadır . )
Örnek : val sayi : Int = 83648

-------------------------------------------------------------------------------------------------------------------------
Byte ⇒
Daha küçük ifadeleri içerisine dahil eden veri tipidir. ( -128 ve 126 arası )
Örnek : val bytedeger : Byte = 1

-------------------------------------------------------------------------------------------------------------------------
Short ⇒
Örnek : val bytedeger : Short = 1

-------------------------------------------------------------------------------------------------------------------------
Long ⇒
Örnek : val sayi : Long = 92233720368

-------------------------------------------------------------------------------------------------------------------------
Double ⇒
Hem Tam Sayılar Hem Ondalık Sayılar için kullanılan veri tipidir.
Örnek : val ondaliksayi : Double = 2.7 veya var ondaliksayi : double = 2.7
-------------------------------------------------------------------------------------------------------------------------
Float ⇒
Float ve Double ile aynı amacı taşır fakat Double daha büyüktür . Ayrıca atama yaparken değişken değerinin sonuna f harfi kullanılmaktadır .
Örnek : val sicaklik : Float = 32.5 f

3
Metinsel Veri Tipleri ⇒

Metinsel veri tipleri ise değişkenler içerisine metinsel ifadeler yerleştirebiliriz . Bu Derste Metinsel veri tiplerini konu alacağız .
String ⇒ Metinsel ifadeleri içerir . Uygulanış :
val seyma : String = “ Ramazan ” // String çift tırnak ile yazılır .
Artık seyma adında içerisinde Ramazan değeri olan String bir değişken oluşturduk .
-------------------------------------------------------------------------------------------------------------------------
Boolean ⇒
Karşılaştırma gibi işlemlerde kullanılmaktadır. True ve False döndürmektedir.Uygulanış ;
val sayi1 : Boolean = true veya val sayi1 : Boolean = false
Daha iyi anlaşılsın diye bir Örnek yazalım .
val sayi1 : Boolean
sayi1 = 5 > 1
println ( sayi1 )
5 sayısı 1 den Büyük mü ? Evet büyük . O halde True karşımıza çıkacaktır .
-------------------------------------------------------------------------------------------------------------------------
Char ⇒
Tek harflik metinsel ifadeleri alır . Char içerisine yerleştirilecek harf tek tırnak ile yazılır Uygulanış ;
val sayi1 : Char = ' k ' // Char tek tırnak ile yazılır .
Aritmetik Operatörler ⇒
Programlama dillerinde değişkenleri işlemek için kullanılan Operatörler vardır .
Aritmetik Operatörler , Matematiksel bazlı işlemlerin gerçekleştirilmesi için kullanılan operatörlerdir .
+⇒ Değerler arasında toplama işlemi yapar .

- ⇒ Değerler arasında çıkarma işlemi yapar .
*⇒ Değerler arasında çarpma işlemi yapar .
/⇒ Değerler arasında bölme işlemi yapar .
%⇒ Bir sayının başka bir sayıya olan bölümünden kalanı hesaplar .
++ ⇒ Değeri 1 sayı arttırır .
-- ⇒ Değeri 1 sayı eksiltir .
Aritmetik Operatörler nasıl kullanılır ?
var sayi0 : Int ; var sayi1 = 26
Değişkenleri tanımladıktan sonra sadece sayi1 atama gerçekleştirdik . Şimdi ise değişkenlerin üzerinde işlem yapalım .
sayi0 = sayi1 + 2
Yukarıdaki Örnekte sayi1 için atadığımız değişkeni + 2 ile toplayıp sayi0 tanımladık .
println ( sayi0 )
Tanımladığımız değişkeni ekrana yazdırdık . Program kodları soldan sağa doğru okuduğu için ;
sayi0 = sayi1 + 2
işlemleri böyle yapmak durumundayız . Gerçek hayatta matematikte ise ;
sayi1 + 2 = sayi0
Olarak karşımıza çıkacaktır .

4
Ekrana yazdıracağımız zaman da işlem yapabiliriz .
println ( sayi1 + 2 )
Ama bu işlem atama yapmayacaktır . Sadece ekrana yazdırırken işlem yapmaktadır.
String Toplama İşlemi ⇒
String ifadelerde Toplama işlemi kendinden sonraki gelen aritmetiksel değeri string olarak görmesidir .
Bunun sayesin de Ekrana yazı yazdıracağımız zaman aynı anda birçok şeyi yazdırabiliriz .
val ad = " Ramazan " ; val soyad = " KOLDAŞ "
println ( "Adınız = " + ad + " \n Soyadınız = " + soyad )
Sonuç :
Adınız = Ramazan
Soyadınız = Koldaş
Diye karşımıza çıkacaktır .
Artırma ve Eksiltme Operatörü ⇒
val = 33
sicaklik ++ veya sicaklik --
println ( sicaklik )
Sonuç olarak sicaklik değeri 34 diye işlem gördü ve atandı .
İlişkisel Operatörler ⇒
== ⇒ Karşılaştırma operatörüdür . İki değişkenin değerini kontrol eder , eğer değerler birbirine eşit ise true aksi halde false değeri döndürür .
!= ⇒ Eşit değildir operatörüdür . İki değişkenin değerini kontrol eder , eğer değerler birbirine eşit değil ise true aksi halde false değeri döndürür .
>⇒ Büyüktür operatörüdür . Kendi solundaki değişkenin değerinin sağdaki değişken büyük olup olmadığını kontrol eder .
Büyükse true aksi halde false değeri döndürür .
<⇒ Küçüktür operatörüdür . Kendi solundaki değişkenin değerinin sağdaki değişken büyük olup olmadığını kontrol eder .
Küçükse true aksi halde false değeri döndürür .
>= ⇒ Büyük eşittir operatörüdür . Kendi solundaki değişkenin değerinin sağdaki değişkenin değerine eşit veya büyük olup olmadığını kontrol eder .
Bu şart sağlanırsa true aksi halde false değeri döndürür .
<= ⇒ Küçük eşittir operatörüdür . Kendi solundaki değişkenin değerinin sağdaki değişkenin değerine eşit veya küçük olup olmadığını kontrol eder .
Bu şart sağlanırsa true aksi halde false değeri döndürür .
Bu Operatörler yardımıyla verileri karşılaştırabiliriz . Örneğin :
val sayi1 = 7 > 2
7 sayısı 2 ‘den büyük mü ? Büyük o zaman ekranda true gösterecektir . Gibi bir örnek göstermek mantıklı olur .
İlişkisel operatörleri bir tek aritmetiksel veriler için geçerli değildir . Her anlamda kullanabiliriz . Ayrıca == yerine metinsel ifadeler için
kullanılan .equals ( ) kullanabiliriz .
val büyük : String ; val kücük : String
büyük = " Ramazan "

kücük = " Ramazan "
println ( büyük.equals ( kücük ) ) // Cevap True olacaktır .

5
Atama Operatörleri ⇒
Atama operatörleri bir öğenin değerini başka bir öğeye atamak için kullanılan operatörlerdir .
= ⇒ Atama operatörüdür . Kendi sağında bulunan değişkenin değerini solunda bulunan değişkene atar .
+= ⇒ Ekle ve Ata operatörüdür . Kendi sağında bulunan değişkenin değerini solundaki değişkenin değeri ile toplar ve elde edilen değeri solundaki
değişkene atar .
- = ⇒ Çıkar ve Ata operatörüdür . Kendi sağında bulunan değişkenin değerini solundaki değişkenin değerinden çıkarır ve elde edilen değeri solundaki
değişkene atar .
* = ⇒ Çarp ve Ata operatörüdür . Kendi sağında bulunan değişkenin değerini solundaki değişkenin değeriyle çarpar ve elde edilen değeri solundaki
değişkene atar .
/ = ⇒ Böl ve Ata operatörüdür . Kendi sağında bulunan değişkenin değerini solundaki değişkenin değerine böler ve elde edilen değeri solundaki
değişkene atar .
% =⇒ Mod al ve Ata operatörüdür . Kendi sağında bulunan değişkenin değerini solundaki değişkenin değerine bölümünden kalanı hesaplar ve elde edilen
değeri solundaki değişkene atar .
Mantıksal Operatörler ⇒
İki veya daha fazla koşul bildiren ifadeler için kullanılır .
&& ⇒ Ve anlamına gelmektedir . Ve ifadesin de koşulların hepsi True olmak zorunda aksi halde False gösterir .
|| ⇒ Veya anlamına gelmektedir . Veya ifadesin de koşulların biri True olduğu zaman koşul tümden True gösterir .
False vermesi için koşulların hepsi False olması gerekir .
Örnek :
val esitmi : Boolean ; val büyük : Boolean ; val küçük : Boolean
büyük = 4 >= 6 // Sonuç false .

küçük = 1 < 4 // Sonuç true .
esitmi = büyük && küçük // Ve kullanıldığı için false && true = false olacaktır.
println ( esitmi )
|| ⇒ Veya kullanılırsa geriye true dönecekti .
Veri Dönüştürme ⇒
To kavramının kod olarak genel bir adı bulunmamaktadır . toByte ( ) , toInt ( ) , toString ( ) , toChar ( ) , toLong ( ) , toShort ( ) , toDouble ( ) , toFloat ( )
Bu kavramlar ile değişkeninin değerini daha sonra istenilen değişken türüne çevirebilirsiniz .
Örnek :
val deneme = " 10 " // Çift tırnak kullanıldığı için sayıyı String olarak algıladı .
println ( deneme.toInt ( ) / 2 ) // toInt kavramı ile String değeri İnt çevirdik .
6
Textual functions ( Metinsel işlevler) ⇒

String işlemler için kullanılan kavramları işleyeceğiz .
Temel olarak bakılacak olursa ders boyunca işlediğimiz bütün kavramların hepsi bizim için bir metottur.
Bu metotlar kavrama dönüştürülerek hazır kütüphane şeklinde bize sunulmuştur.
A- To LowerCase ⇒
Lower Case Kavramı string değişkenin içerisinde ki bütün harfleri küçültmeye yaramaktadır . Örnek :
val ad = " RAMAZAN "
println ( ad.toLowerCase ( ) )
Sonuç : ramazan
Görüldüğü üzere değişken içerisinde ki bütün harfler küçük harf oldu .

Birde bunun büyük harf yapma olayı var , Kullanış olarak aynı ama kavram olarak farklıdır . ( toUpperCase ( ) )
B- Ends With ⇒
Bu kavram Contains gibi içerisinde hangi değişkenin olup olmadığını bakmaktadır ama tek farkı string değerin sonuna bakmaktadır .
val isimler : String = " akıl "
println ( isimler.endsWith ( " l " ) )
Sonuç : True
Görüldüğü üzere Ends With kavramı ile string değerin son kısmında “l ” harfi varmı diye bakmış olduk .
Bir de bu kavrama zıt olarak Starts Width kullanımı tamamen aynıdır sadece Starts Width ile string değişkenin ne ile başladığını sorgulamaktadır
Örnek :
val ad = " Ramazan "
println ( ad.startsWith ( " Ram " ) )
Sonuç : True
C- Replace ⇒
Bu kavram değer içeriğini değiştirmeye yaramaktadır .

Kavram da ilk eski değerler seçilip daha sonra yeni değer yazılarak değiştirilmesi sağlanır .
Örnek :
println ( ad.replace ( ' R ' , ' S ' ) )
Sonuç : Samazan
D- Split ⇒
Bu kavram değer içeriğini Char olarak silmektedir . Kavram da değer seçilip daha sonra kesilerek kalan parçalarını yeni bir diziye dizi elemanı olarak
atamaktadır .
Örnek :
println ( ad.split ( " a " ) )
Sonuç : R m z n
Görüldüğü üzere a değerlerini kestikten sonra geri kalan değerlerimiz dizi şeklinde karşımıza çıktı .
7
Mathematical functions ( Matematiksel işlevler) ⇒
A- Plus ⇒
Bir sayıyı belirtilen sayı ile toplamaktadır . Toplama işlemi yapmaktadır .
val number = 10
println ( number.plus ( 7 ) )
Sonuç : 17 / 10 sayısını ve 7 sayısını toplamıştır .
B- Rem⇒
Bu değeri diğer değere bölmenin kalanını hesaplar . Çıkarma işlemi yapmaktadır .
val number = 10
println ( number.rem ( 8 ) )
Sonuç : 2 // 10 sayısından 8 çıktığında geriye 2 kalmaktadır .
C- Div ⇒
Metinsel veri türü haricinde rakamsal veri türlerini bölmektedir . Bölme işlemi yapmaktadır .
val number = 10
println ( number.div ( 2 ) )
Sonuç : 5 // 10 içinde 5 tane 2 vardır .
D- Dec ⇒
Int değişkenin değerini bir azaltmaktadır .
val number = 10
println ( number.dec ( ) )
Sonuç : 9 // 10 sayısından bir değer azalttı .
E- Sqrt ⇒
Float veya Double türünden bir değerin karekökünü hesaplayan yardımcı fonksiyondur . Örnek :
val number = 10
println ( sqrt ( number.toDouble ( ) ) ) // İsterseniz değişkeni double çevirip yazın isterseniz içerisine direk yazınız .
Sonuç : 3.1622776601683795
F- Compare To ⇒
Rakamsal veri türlerini verilen değer ile büyük ise -1 , aynı ise 0 , küçük ise 1 değerini döndürmektedir .
val number = 10
println ( number.compareTo ( 12 ) )
Sonuç : -1 // 12 sayısı 10 dan büyük olduğu için -1 değerini gösterdi .

8
Koşul Yapıları ⇒
Koşul yapıları geliştirilmekte olan program içerisinde , bir işlemin nihayete erdirilmesi bazen bir veya birkaç koşulun oluşmasına bağlı olabilir .
Kod blokları içerisindeki işlemler çalıştırılır . Karar yapıları 2 ‘ ye ayrılır.
İF - Else if - Else ve When ( Switch-Case-Break )
A- İF - Else iF - Else ⇒
İF kod bloğu içinde bulunan kod doğruysa eğer ancak o zaman çalışır . Örnek :
5 > 1 büyüktür .
Büyük mü ? büyük o halde burada if kod bloğu çalışacaktır .Yani sonuç True döndürdüğü takdirde çalışan kod bloğudur . Örnek :
val skor = 10 // Puanı 10 olan varsayımsal skor değişkeni tanımladık .
if ( skor < 20 ) // Skor değişkeninin değeri koşuldaki değerden düşük olduğu için çalışacaktır .
{
println ( " Oyunu Kaybettiniz . " )
}
Else ise if bloğundaki şartları sağlanmadığı zaman devreye girer . Örnek :
val skor = 100 // İF bloğundaki koşul sağlanmasın diye skor değişkeni değerini arttırdık .
if ( skor < 20 ) // 100 sayısı 20 ‘den büyük olduğu için if bloğu çalışmayacaktır .
{
println ( " Oyunu Kaybettiniz ." )
}
else // İF bloğu çalışmadığı için devreye Else kod bloğu girecektir .
{
println ( " Oyunu Kazandınız ." )
}
Else deyimini kullanmak zorunlu değildir . Ayrıca bu yapılardan ayrı olarak belirlenmiş bir kod bloğumuz daha var .
Else if birden fazla koşulun gerçekleşmesi durumuna bağlı olarak işlemler yapmak isteyebiliriz . Örnek :
Skor > 20 // Skor değişkeni 20 ‘den küçük olabilir .

Skor < 20 // Skor değişkeni 20’den büyük olabilir .
Skor == 20 // Skor değişkeni eşit olabilir .
val skor = 20
if ( skor < 20 )

{
println ( " Oyunu Kaybettiniz ." )
}
else if ( skor > 20 )
{
println ( " Oyunu Kazandınız ." )
}
else
{
println ( " Berabere " )
}
Görüldüğü üzere 3 Durum içinde farklı bir kod bloğu hazırlayıp onlara göre sonuç belirledik . Else if ‘i koşul sayısına bağlı olarak birden fazla kullanabiliriz .
Else if normal hayatta belki demek gibi bir şeydir . İF olmazsa belki bu olur gibisinden belirliyoruz .
9
B- When ( Switch ) ⇒
When İçerisine konulan değişkeni kontrol eden yapılardır . When 2 farklı şekilde uygulanır . Javadaki Switch gibidir .
1. Şekil Örnek :
val x = 2
when ( x ) {
0 -> { print ( " X çift sayıdır " ) }
1 -> { print ( " X tek sayıdır " ) }

}
Görüldüğü üzere when içerisine x değişkenini ekleyerek x ‘in üzerinde işlem yapacağımızı belittik .
0 -> { print ( " X çift sayıdır " ) }
Bu kısımlar if gibi çalışmaktadır .

Kısımlarda görülen -> işareti bir nevi o kolu temsil etmektedir . { } kod blokları ise sadece o kısmın çalışacağını temsil etmektedir .
Yada 1 veya daha fazla koşul ortak bir amaç uğruna kullanabilirsiniz .
val y = " A "
when ( y ) {
" A " , " I " -> println ( " Kalın Sesli Harftir . " ) // İşlemleriniz tek satır ise bu şekilde yazabilirsiniz .
}
Kısımlara koşul yazmak isterseniz . 2. Şekil Örnek :
val x = 2
when { // Koşul kullanılacaksa sadece when bloğu kullanınız .

x %2 == 0 -> {
println ( " X çift sayıdır " )
}
x %2 == 1 -> {
println ( " X tek sayıdır " )
}
}
Yada 1 veya daha fazla koşul ortak bir amaç uğruna kullanabilirsiniz .
val x = “ A ”
when {
x == " A " | | x == " I " -> println( " Kalın Sesli Harftir . " )
}
When karar yapısında if karar yapısında olduğu gibi else kod bloğu vardır . Switch de ki Default gibidir .
else -> {
//…………………...
}
Loops ( Döngüler ) ⇒
Gerçekleşmesini istediğimiz eylemin tekrar etmesi durumunda döngüler kullanılır .
Döngü kullanmak bize zaman kazandırır ve fazla kod satırından kurtarır .
Kaç çeşit Döngü vardır ?
1- For Döngüsü 2- While - Do While Döngüsü 3- For Each Döngüsü

10
A- For ⇒
for ( i in 1..10 step 1 ) // Bunun anlamı her bir değeri i değişkenine aktar demektir .
{
println ( " İ ’ nin Değeri = $ i " )
}
Açıklayalım.
For döngüsünün başlangıcını yazdık . Parantez içine ise For döngüsü nasıl bir işlem yapacağını belirttik .
Parantez içerisi ⇒
i : Bir değişken belirleyip döngünün işleyecek elemanı alacağını belirledik .
1..10 : Döngünün hangi durumda sona ereceğini belirtmektedir . Burda 1 ‘den başlayıp 10 da biteceğini yazdık .
İsterseniz Until de kullanabilirsiniz . ( 10 until 20 )
step : Döngünün nasıl ilerlediğini belirtiyoruz. Yani ben step 4 dersem döngü dörtlü şekilde ilerleyerek işleme devam edecektir . Gidişatı siz belirliyorsunuz .
Şöyle bir şey yapabilirsiniz . Örnek :
for ( i in 1..100 )

{
if ( i % 2 == 0 ) {
}
}
İF komutu ile ben 2 ‘e bölünen sayıları ekrana yazdım isterseniz 2 ‘er ilerleme ile de 2 değerleri ekrana yazdırabilirsiniz .
for ( i in 1..100 step 2 )

{
}
For döngüsünde step belirlemezsen sistem varsayılan olarak 1 ‘er ilerleyecektir .
Görüldüğü üzere kodlamanın sınırı yok sürekli çalışarak kodları hafızanızda bir yer atabilirsiniz .
B- While ⇒
While döngüsünde parantez içindeki koşul bölümü True olduğu sürece sürekli dönecektir lakin While döngüsü amacına ulaşıp False olduktan sonra
döngü kırılacaktır . Örnek :
var harf = ' a '
while ( harf <= ' s ' )

{
println ( " S harfi " + harf )
}
Harf değişkeni değeri a ‘dır .

While Döngüsünün koşul kısmında a ‘ değeri s ‘ den küçük ise aşağıdaki işlemleri uygula demiş olduk .
Yalnız şöyle bir durum var eğer işlemi gerçekleştiren kod bloğunun için de bir artırma işlemi olmazsa bu döngü sürekli dönerek sonsuz bir döngü oluşturacaktır
.
Bu yüzden artırma işlemi yapılması gerekmektedir .
var harf = ' a '
while ( harf <= ' z ' ) // Parantez içerisine döngüye girecek koşulu girdik .
{
println ( " S harfi $ harf " )
harf++ // Sonsuz döngüye girmesin diye arttırma işlemi uyguladık . Arttırma işlemi uygulanan değişken mutlaka var türünden olmalıdır .
}
Harf değişkeninin değeri s olana kadar devam edecektir . Değeri s olduktan sonra döngü kırılacak ve işlem sona erecektir .
Bu ne işe yarar ?
11
Bu işlem sayesinde diyelim ki veri tabanında satır sayısını bilmediğiniz bir kullanıcı tablonuz var .
C- Do While ⇒
Bu döngünün farkı ise ilk önce işlemi bir kez çalıştırıp daha sonra şartları kontrol eder .
var harf = ' a '
do {
println ( " S harfi $harf " )
harf++
} while ( harf <= ' s ' )
Şartları kontrol ettikten sonra şarta göre tekrar değer döndürür .
D- For Each ⇒
Foreachkomutu bir dizinin , koleksiyonun ( herhangi bir nesne olabilir ) elemanları üzerinde index belirtmeden dolaşmaya yarar .
Foreach farklı tanımlama şekilleri vardır . For ile aynıdır sadece basitleştirilmiş halidir .
val res = " Şeyma "
res.forEach { it : Char

println ( " Harfler = $it " )
}
Yukarıdaki olayı açıklayacak olursak , Res değişkeni içerisindeki bütün elemanları it değişkenine atadık .
Döngü sayesinde her birini ekrana yazdırdık .
Yukarıdaki tanımlama yöntemi bir değişkenin vb. elemanlarını almaktadır .
Koşul belirterek tanımlama :
(1..10 step 2 ).

forEach { i -> // - > işareti ile i adında bir değişken tanımladık . İsterseniz otomatik tanımlanan it değişkenini de kullanabilirsiniz .
println ( " Harfler = $i " )

}
For Each döngüsü Kotlin dilinde biraz daha basitleştirilmiştir . Değişken , Dizi vb . kısımlarda .forEach diye ulaşabilirsiniz .
Şeyma kelimesini parçalara ayıralım ama E harfi ve A harfi görünmesin .
val res = " Şeyma "
( res ) .forEach { it : Char
if ( it != ' e ' && it != ' a ' ) // Ve ifadesi ile Ş , y , m harfleri e ve a benzeyip benzemediğini kontrol ettik .
{
println ( it ) // Eşit olmayan harfleri ekrana yazdırdık .
}
}
Return and Jumps ⇒

Kotlin 'in üç yapısal sıçrama ifadesi vardır :
Break : Bir döngüyü bitirmek istediğimizde bu kavram kullanılmaktadır .
Conti̇nue : Döngülerde istediğimiz satırdan atlayıp bir sonrakinden devam etmesini sağlayabiliriz .
Return : Fonksiyonlarda çok sık kullanılan bu kavram en yakın işleve geri değer döndürme işlemi yapmaktadır .
Label : Bir işlevi veya ifadeyi belirtmek için label yani etiket kullanılır . Kod durumuna bağlı olarak label Break , Conti̇nue , Return ile birlikte kullanılmaktadır .
12
A- Break ⇒
Döngü içerisin de istenen şartlar sağlandıktan sonra döngünün sonlandırılmasını isterseniz bu ifadeyi kullanmalısınız .
for ( i in 1..10 ) {
println ( i )
if ( i == 8 ) {
break
}
}
Sonuç : 1 2 3 4 5 6 7 8
Görüldüğü üzere sonuç ekranındaki değerler if içerisindeki şartı sağladığında döngü sonlandırılmıştır . Yukarıdaki örnekte kavramın saf kullanımını
gördünüz eğer label belirtilmez ise kavram en yakın döngüyü sonlandıracaktır .
Label ile kullanımına bakalım . Döngüye bir label etiketi hazırlıyoruz ilk olarak .
label@ for ( i in 1 until 1000 )
ilk olarak etiket ismi yazılır daha sonra @ işareti konulur . Kavram kullanımında ise :
break@label // Label etiketleri farklı isimlerde olabilir ayrıca kavramlar ile birlikte yazılır boşluk bırakılmaz .
kavram adı yazılır . @ işareti konulur daha sonra işlemi sonlandırılacak etiket ismi yazılır . Aşağıdaki örnek kodu inceleyiniz :
label@ for ( i in 1 until 1000 ) {
println ( i )
for ( j in 1..10 ) {
println ( j )
if ( j == 8 ) {
break@label // Break kavramına etiket tanımlayarak en üst katmandaki etiketi olan for döngüsünü sonlandırdık .
}
}
}
B- Continue ⇒
Döngülerde istediğimiz satırdan atlayıp bir sonrakinden devam etmesini sağlayabiliriz .
Örnek :
for ( j in 1..10 ) {
if ( j == 8 ) {
conti̇nue // Conti̇nue kavramı ile 8 rakamını atlayıp döngünün bir sonraki aşamasına geçtik .
}
println ( j )
}
Sonuç : 1 2 3 4 5 6 7 9 10
Yukarıdaki durumu açıklayacak olursak if ile j değeri 8 rakamına eşit olduğu zaman 8 döngüyü atlamasını istedik .
Conti̇nue ile atlama işlemi gerçekleştiriyoruz . Şöyle ki conti̇nue ile o anki işlemi atlayıp bir diğer işleme geçiş yapmış oluyorsunuz .
Not : Label break kavramında kullanıldığı gibi conti̇nue içinde aynı şekilde kullanılır .
C- Return ⇒
Fonksiyonlarda çok sık kullanılan bu kavram en yakın işleve geri değer döndürme işlemi yapmaktadır . Break komutu ile benzerdir tek farkı değer
döndürmektedir .

Kotlin

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kotlin

Uploaded by

Copyright:

Available Formats

1

Oluşturulan yorum satırı program içerisinde ​Gri​ renkte görülür .

println ( “ Seni çok Seviyorum Şeyma ” ) gibi…

val​ sayi1 : ​Int​ ​// Int tipinde değişken tanımladık .

var ​sayi1 : ​Int ​; ​var ​seyma : ​Int

val​ sayi = 10 ​// Değer belirterek değişken tanımladık .

val ​sayi1 : ​Int

Peki ya veri ataması yaparken nasıl yapmalıyız ?

val ​. Değişebilen değerler için kullanılmaktadır .

A- Sabitler ( var | val ) ⇒

val ​sayi1 ​=​ ​10

Bunun için : println ( sayi1 )

println ( “ Merhaba Ben Ramazan ” )

val ​sayi1 = " Ramazan KOLDAŞ "

Eğer ben metin içerisinde kod çalıştırmak istersem :

val ​şeyma ​= “ Şeyma ”

Sayısal Veri Tipleri ⇒

Örnek : ​val​ sayi : ​Int ​= 83648

Örnek : ​val​ bytedeger : ​Byte​ = 1

Örnek : ​val ​bytedeger : ​Short​ = 1

Örnek : ​val​ sayi : ​Long​ = 92233720368

Örnek : ​val​ sicaklik : ​Float​ = 32.5 f

Metinsel Veri Tipleri ⇒

String​ ⇒ Metinsel ifadeleri içerir . Uygulanış :

Karşılaştırma gibi işlemlerde kullanılmaktadır. True ve False döndürmektedir.Uygulanış ;

val​ sayi1 : ​Boolean​ ​= true ​veya​ ​val ​sayi1 : ​Boolean​ ​= false

Daha iyi anlaşılsın diye bir Örnek yazalım .

val​ sayi1 : ​Boolean

+⇒ Değerler arasında toplama işlemi yapar .

Aritmetik Operatörler nasıl kullanılır ?

var ​sayi0 : ​Int ​; ​var ​sayi1 = 26

işlemleri böyle yapmak durumundayız . Gerçek hayatta matematikte ise ;

Olarak karşımıza çıkacaktır .

Ekrana yazdıracağımız zaman da işlem yapabiliriz .

Ama bu işlem atama yapmayacaktır . Sadece ekrana yazdırırken işlem yapmaktadır.

String Toplama İşlemi ​⇒

println ( "Adınız = " + ad + " \n Soyadınız = " + soyad )

Diye karşımıza çıkacaktır .

Artırma ve Eksiltme Operatörü ​⇒

Sonuç olarak ​sicaklik​ değeri 34 diye işlem gördü ve atandı .

Bu Operatörler yardımıyla verileri karşılaştırabiliriz . Örneğin :

val​ sayi1 = 7 > 2

val ​büyük : ​String​ ; ​val ​kücük : ​String

büyük = " Ramazan "

println ( büyük.equals ( kücük ) ) ​// Cevap ​True ​olacaktır .

val ​esitmi : ​Boolean​ ; ​val ​büyük : ​Boolean ​; ​val ​küçük : ​Boolean

büyük = 4 ​>= ​6 ​// Sonuç false .

||​ ​⇒​ ​Veya ​kullanılırsa geriye​ true​ dönecekti .

Textual functions ( ​Metinsel işlevler​) ⇒

val​ ad = " RAMAZAN "

Görüldüğü üzere değişken içerisinde ki bütün harfler küçük harf oldu .

val​ isimler : String = " akıl "

println ( isimler.​endsWith​ ( " l " ) )

val​ ad = " Ramazan "

println ( ad.​startsWith​ ( " Ram " ) )

Bu kavram değer içeriğini değiştirmeye yaramaktadır .

println ( ad.​replace​ ( ' R ' , ' S ' ) )

val​ ad = " Ramazan "

println ( ad.​split​ ( " a " ) )

Mathematical functions ( ​Matematiksel işlevler​) ⇒

Bir sayıyı belirtilen sayı ile toplamaktadır . Toplama işlemi yapmaktadır .

Sonuç : 17​ / 10 sayısını ve 7 sayısını toplamıştır .

Bu değeri diğer değere bölmenin kalanını hesaplar . Çıkarma işlemi yapmaktadır .

Oluşturulan yorum satırı program içerisinde Gri renkte görülür .

val sayi1 : Int // Int tipinde değişken tanımladık .

var sayi1 : Int ; var seyma : Int

val sayi = 10 // Değer belirterek değişken tanımladık .

val sayi1 : Int

val . Değişebilen değerler için kullanılmaktadır .

val sayi1 = 10

val sayi1 = " Ramazan KOLDAŞ "

val şeyma = “ Şeyma ”

Örnek : val sayi : Int = 83648

Örnek : val bytedeger : Byte = 1

Örnek : val bytedeger : Short = 1

Örnek : val sayi : Long = 92233720368

Örnek : val sicaklik : Float = 32.5 f

String ⇒ Metinsel ifadeleri içerir . Uygulanış :

val sayi1 : Boolean = true veya val sayi1 : Boolean = false

val sayi1 : Boolean

var sayi0 : Int ; var sayi1 = 26

String Toplama İşlemi ⇒

Artırma ve Eksiltme Operatörü ⇒

Sonuç olarak sicaklik değeri 34 diye işlem gördü ve atandı .

val sayi1 = 7 > 2

val büyük : String ; val kücük : String

println ( büyük.equals ( kücük ) ) // Cevap True olacaktır .

val esitmi : Boolean ; val büyük : Boolean ; val küçük : Boolean

büyük = 4 >= 6 // Sonuç false .

|| ⇒ Veya kullanılırsa geriye true dönecekti .

Textual functions ( Metinsel işlevler) ⇒

val ad = " RAMAZAN "

val isimler : String = " akıl "

println ( isimler.endsWith ( " l " ) )

val ad = " Ramazan "

println ( ad.startsWith ( " Ram " ) )

println ( ad.replace ( ' R ' , ' S ' ) )

val ad = " Ramazan "

println ( ad.split ( " a " ) )

Mathematical functions ( Matematiksel işlevler) ⇒

Sonuç : 17 / 10 sayısını ve 7 sayısını toplamıştır .

Sonuç : 2 // 10 sayısından 8 çıktığında geriye 2 kalmaktadır .

Sonuç : 5 // 10 içinde 5 tane 2 vardır .

Sonuç : 9 // 10 sayısından bir değer azalttı .

Sonuç : -1 // 12 sayısı 10 dan büyük olduğu için -1 değerini gösterdi .

İF - Else if - Else ve When ( Switch-Case-Break )

val skor = 10 // Puanı 10 olan varsayımsal skor değişkeni tanımladık .

Else ise if bloğundaki şartları sağlanmadığı zaman devreye girer . Örnek :

Skor > 20 // Skor değişkeni 20 ‘den küçük olabilir .

if ( skor < 20 )

1 -> { print ( " X tek sayıdır " ) }

0 -> { print ( " X çift sayıdır " ) }

val y = " A "

when { // Koşul kullanılacaksa sadece when bloğu kullanınız .

i : Bir değişken belirleyip döngünün işleyecek elemanı alacağını belirledik .

for ( i in 1..100 )

for ( i in 1..100 step 2 )

var harf = ' a '

while ( harf <= ' s ' )

Harf değişkeni değeri a ‘dır .

var harf = ' a '

var harf = ' a '

val res = " Şeyma "

res.forEach { it : Char

(1..10 step 2 ).

println ( " Harfler = $i " )

val res = " Şeyma "

( res ) .forEach { it : Char

for ( i in 1..10 ) {

label@ for ( i in 1 until 1000 )

label@ for ( i in 1 until 1000 ) {

for ( j in 1..10 ) {