Uygulama componentleri şu şekildedir.

1. Activities (Aktiviteler)
2. Services (Servisler, GPS servisler vs. )
3. Broadcast Receivers (Bir uygulamanın başka bir uygulamaya veya bir aktiviteden başkasına yayın yapması)
4. Content Provider (İçerik sağlayıcılar , Uygulamadan başka bir uygulamaya veri aktarımı, Rehberden köklere erişim vb. )

Kısaca bahsettiğimiz bu componentlerden biz aktiviteleri ele alacağız. Android’in temelini oluşturan aktivitelerin işleyiş ağacı aşağıdaki gibidir.

Aktivite çalıştığı anda onCreate methodu harekete geçiyor. Zaten hatırlarsınız bir aktivite oluşturduğumuzda bu ister main activity ister başka bir aktivite olsun android studio önce onCreate methodunu oluşturuyor. Hatırlarsınız gerekli tüm setlemeleri burada yapıyorduk. SharedPreferences, değişkenler, initialize işlemleri… Önce bu method çalıştığı için uygulama hata vermeden burada bu işlemleri yapmak isteriz.

Daha sonra onStart() geliyor. Artık uygulama başladı.

Sonrasında onResume() var. Kullanımında onCreate() gibi kullanabiliyoruz. Bir sayfadan diğerine gittik geri döndüğümüzde eğer biz aktiviteyi sonlandırmamış isek onCreate tekrar çalışmaz. Bu gibi durumlarda onResume() içinde sayfayı yenile, tekrar yükle gibi komutlar vererek uygulamanın aksamadan yenilenmiş bir şekilde sürmesini sağlayabiliriz.

Aynı şekilde onDestroy()’da onCreate’ı tekrar çalışmasını sağlayabilir. Uygulamada başka bir aktiviteye geçildi veya uygulama alta alındı bu durumda biz finish() işlemini yapmamış isek uygulama kapanmaz ve döndüğünde onResume() ile çalışmaya devam eder. Bu da örneğin bir uygulamada onResume()’da bir tanımlama yapılmamışsa akış ekranının yenilenmemesi gibi sorunlara yol açabilir.

Bu sebeplerden ötürü bu aktivite yaşam ağacı programı kodlayan kişiler tarafından düşünülmeli  ve ona göre hareket edilmelidir.

CONTEXT

Kısaca : Android projeler içinde ne olup ne bittiğini takip etmek için bir yapıdır. Her şey birbiriyle context sayesinde haberdar olurlar. Context’leri kullanırlen uygulama hangi durumda işlem yapacak iyi anlaşılmalıdır.

ActivityContext’e ulaşmak için genellikle this veya ActivityContext

AppContext için applicationContext

Tabi this’in çalışması için( ActivityContext olarak) farklı bir obje içinde çalışmadığına da dikkat edilmelidir.

INTENT İŞLEMİ

Intent methodu en basit haliyle anlatmak istersek kamyon görevi görmektedir. Sen kamyona bir şeyler yüklersin o bu kasasındaki elementleri başka bir yere götürür. Mesela bir aktivite başlatmak için intent kullanabiliriz. Galeriden bir resim getirmek veya başka bir uygulamadan bir şey getirmek için intent kullanabiliriz. Bu çok fazla çeşitlenebilir. Şimdi kısaca intent üzerinden diğer aktivitelere veri aktarımı üzerine konuşalım.

Bir buton atayalım ve bu buton diğer aktiviteye geçiş yapsın

    fun next (view : View ) {
        var intent = Intent (applicationContext,NextActivity::class.java)
        startActivity(intent)
    }

Bu haliyle diğer aktiviteye geçebiliriz. Ama içerisine veriler eklediğimizde ise şu şekilde oluyor

    fun next (view : View ) {
        var intent = Intent (applicationContext,MainActivity::class.java)
        intent.putExtra("name" , name)
        intent.putExtra("age", age)
        startActivity(intent)
    }

NextActivity’de ise bu verileri şu şekilde alıyoruz.

        val intent = intent 
        val name = intent.getStringExtra ("name")
        val age = intent.getIntExtra ("age")

 Yani mevzu bu şekilde bu daha fazla çeşitlendirilebilir. Bundan sonrası sizin hayal gücünüze bağlı olarak çeşitlenebilecek çok önemli bilgilerdir.

NOT : Burada intent ile aktardığımız şeyleri SharedPreference ile de aktarabilirdik. Yani doğrudan başka bir aktiviteye geçildiği gibi durumlarda intent bu görevi üstlenir sadece bu iş için özelleşmiştir. Ama uygulama genelinde mesela username ve şifre her zaman kayıt olması ve her sayfada aynı olması gerekir bu gibi durumlarda sharedpreference ile de verileri çekmek daha mantıklı olur.  Şuan basit bir şekilde küçükte olsa işlevsel bir uygulama yapabilir duruma geldik. Bu bilgilerle şifreli bir günlük uygulaması bile yapılabilir. Girişinde kayıt olunan sonrasında şifre ile kayıtları görebildiğin bir günlük uygulaması bu ilk aklıma gelen şekli. Konular derinleştikçe çok daha fazlasını yapabileceksiniz.

UYGULAMADA İSTENMEYEN BİR HATA ALIYORUM

Uygulamaya bakıyorsunuz her şey düzgün fakat bir hata alıyorsunuz. Bu benim özellikle harddiskimin arızalı oluduğunu bilmediğim zamanlarda başıma çok geliyordu. Fakat başka sebeplerden ötürü de başımıza gelir. Yapmamız gereken yukarı panelden şu adımları izlemek :

Build – > Clean Project

Build – > Rebuild Project

Eğer bu ikisi ile çözülmedi ve hala bazı kütüphaneleri falan görmediğinden kaynaklı hatalar veriyorsa

File -> Invalidate Cache / Restart

Bu adımı takip etmemiz gerekir. Bu artık tamamen önbelleği silip uygulamayı tekrar başlatmak manasına gelmektedir ve çoğu zaman işe yarar. Bazen hala hatalar vermeye devam edebilir. Bazen internet bağlı olmadığından bazen ise farklı sebeplerden olabilir bu hatalar. Ama bir problem olmadığını düşünüyorsanız yukarıdaki adımlar yüzde 90 oranında hata almamanızı sağlayacaktır.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">


    <EditText
        android:id="@+id/emailText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginStart="36dp"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="36dp"
        android:ems="10"
        android:hint="Email"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/ageText" />

    <EditText
        android:id="@+id/passwordText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginStart="36dp"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="36dp"
        android:ems="10"
        android:hint="Şifre"
        android:inputType="textPersonName|textPassword"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/emailText" />

    <EditText
        android:id="@+id/ageText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginStart="36dp"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="36dp"
        android:ems="10"
        android:hint="Yaşınız"
        android:inputType="number|textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/surnameText" />

    <EditText
        android:id="@+id/surnameText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginStart="36dp"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="36dp"
        android:ems="10"
        android:hint="Soyisminiz"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/nameText" />

    <EditText
        android:id="@+id/nameText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginStart="36dp"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="36dp"
        android:ems="10"
        android:hint="İsminiz"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:id="@+id/saveButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="32dp"
        android:layout_marginEnd="48dp"
        android:text="KAYIT OL"
        android:onClick="makePerson"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/passwordText" />
</androidx.constraintlayout.widget.ConstraintLayout>

EditText’ler ve buton ile yapımızı oluşturduk. Button için bir onClick methodu oluşturduk ve makePerson() ismini verdik.

    fun makePerson(view : View) {
        val name = nameText.text.toString()
        val surname = surnameText.text.toString()
        val age : Int? = ageText.text.toString().toIntOrNull()  //kişi burada yazı girebilir. Aslında ageText’i xml dosyasında tanımlarken number tipinde de tanımlayabilirdik. Veya bu yöntemi kullanarak kotlin dosyasında da güvenliğini sağlayabiliriz.
        val email = emailText.text.toString()
        val password = passwordText.text.toString()
        if (name.equals("") || surname.equals("") || age == null || email.equals("") || password.equals("")){
            Toast.makeText (applicationContext, "Tüm alanları doldurmalısın" , Toast.LENGTH_SHORT).show()
        }else
        {
            Toast.makeText (applicationContext, "İsim : $name Soyad : $surname Yaş : $age Email : $email Şifre : $password" , Toast.LENGTH_LONG).show()
        }

    }

Bu şekilde button’a tıklandığında ekrana toast mesajı gösteren bir uygulama yapmış olduk. Eğer buraya kadar hatasız yaptıysak devam edebiliriz.

Şimdi hem bu uygulamaya devam ederken hem de örneksiz çok anlatılamayacak scope ve sharedpreferences konularını bu uygulama ile işleyelim.

Scope

Scope java’da kotlin’de veya başka bir dilde hep benzer şekilde çalışır. İki scope arasındaki kodlara, değişkenlere başka scope içinden doğrudan erişilemez.

Alt scope’ta ise erişilibilir

{
/*
Kod, Değişkenler… 
*/
{
/*
ALT SCOPE
Erişim var 
*/
}
}
{
/*
FARKLI SCOPE
Erişim yok
*/
}

Kotlin Lateinit

Önceki derste de kullanmıştım. Lateinit bir değişkeni şimdi tanımlıyorum değer atamasını sonra yapacağım demek oluyor. Yani mesela

Var myString : String = “”

yapmak yerine

lateinit var myString : String

İkisinin farkı ortada aslında. Yukarıdaki boşlukta olsa bir string değer atıyorsun. Hafızada o boşluk değerini string halde tutuyor. Alttaki laneinit ile kullanılan örnekte bunu daha sonradan tanımlayacağını söylüyorsun. Bu dışarıdan bir bilgi olabilir , veritabınından alınacak bir bilgi olabilir veya herhangi bir değişken veya sabit olabilir ama bunu sonradan tanımlayacağını şimdi initialize etmeyeceğini belirtiyorsun. Lateinit kotlini javadan ayıran ve güvenli kod yazılmasını sağlayan en önemli yapılardan biridir.

Kotlin Veri Kaydetmek, Silmek ve Getirmek (SharedPreferences)

Yukarıdaki çevrimdışı kayıt örneğinde tamam verileri aldık ve ekrana Toast mesajı olarak bastırdık. Ama uygulamadan çıkıp tekrar girdiğimizde bu veriler bir yerde gösterilmiyor veya bir yere kaydedilmedi aslında. Bu tarz uygulamalarda kullanıcı bilgilerini tuttuğumuz bir yapı olan sharedPreferences’e gelin yakından bakalım

Verileri Saklamak (SharedPreferences)

SharedPreferences aslında bir sınıf. Sınıf olduğu içinde öncelikle sharedPref objesi oluşturmamız lazım.

private lateinit var sharedPref : SharedPreferences // MainActivity altında
sharedPref = this.getSharedPreferences("com.axisting.offlineregisterapp", Context.MODE_PRIVATE) // onCreate altında

NOT : Burada MODE_PRIVATE ile bu uygulamada sharedPref ile kaydedilecek verilere sadece bu uygulamadan erişileceğini söylüyoruz. Erişimini kısıtlıyoruz. Kısıtlamadığımız durumda ise aynı cihazdan diğer uygulamalardan dahi erişilebilir veriler ekleyebiliriz. Şuan için bunu istemiyoruz.

Nesneyi oluşturduk. Artık cihazda “com.axisting.offlineregisterapp” altında bu bilgiler saklanabilir hale geldi.(Uygulama ismiyle kayıt etmek kodun okunurluğunu çoğu zaman için artırır.)

Şimdi örneğimiz doğrultusunda buttona tıklanıldığında gelişecek aksiyonlar içerisine bunları sharedpref içinde kayıt edelim.

            sharedPref.edit().putString ("name", name).apply()
            sharedPref.edit().putString("surname", surname).apply()
            sharedPref.edit().putInt("age", age).apply()
            sharedPref.edit().putString("email", email).apply()
            sharedPref.edit().putString("password", password).apply()

Şekildeki gibi önce anahtar değer sonrasında ise kayıt edilecek girdi değeri ekliyoruz. Yani cihaz hafızasında örnek verecek olursak şu şekilde kayıt oluyor

Name : volkan

Surname : demir

Age : 26

Email : info@axisting.com

Password : 123456

Verileri Okumak, Verileri Getirmek (SharedPreferences)

Verileri istediğimiz zaman okuyabiliriz artık. Bunun için uygulamanın her yerinden erişmek adına sharedPreferencesi önce global tanımlayalım

private lateinit var sharedPref : SharedPreferences // mainactivity altı
sharedPref = this.getSharedPreferences("com.axisting.offlineregisterapp", Context.MODE_PRIVATE) // oncreate altı

Verileri getirirken uygulamanın hangi konumunda olursak olalım önce SharedPreferences nesnesi oluşturmamız lazım.

Bu kısımları eksiksiz yaptığımız durumda istediğimiz aktiviteden veya classtan artık verileri okuyabiliriz.

            val sharedName = sharedPref.getString("name","-1000")
            System.out.println(sharedName)

Bu şekilde kolaylıkla verileri okuyabiliriz. Bunu kontrollerle zenginleştirmek artık size kalmış.

Verileri Silmek (SharedPreferences)

Örneğin uygulamada kaydettiğimiz bu verileri bir delete butonu aracılığıyla silelim. Delete isminde bir button oluşturup delete isminde bir onClick methodu tanımlayalım. Bu delete() methodu şu şekilde olurdu.

 fun deletePerson(view : View) {
        val sharedName = sharedPref.getString("name","-100")
        val sharedSurname = sharedPref.getString("surname","-100")
        val sharedAge = sharedPref.getInt("age",-100)
        val sharedEmail = sharedPref.getString("email","-100")
        val sharedPassword = sharedPref.getString("password","-100")
        if (!sharedName.equals("-100")){
            sharedPref.edit().remove("name").apply()
        }
        if (!sharedSurname.equals("-100")){
            sharedPref.edit().remove("surname").apply()
        }
        if (sharedAge != -100){
            sharedPref.edit().remove("age").apply()
        }
        if (!sharedEmail.equals("-100")){
            sharedPref.edit().remove("email").apply()
        }
        if (!sharedPassword.equals("-100")){
            sharedPref.edit().remove("password").apply()
        }

        Toast.makeText(applicationContext, "Paylaşılan Veriler Silindi..", Toast.LENGTH_SHORT).show()



    }

Not : Bu şekilde offline kayıt olma uygulamasının tamamını doldurabiliriz. Ben tam halini github hesabımda da paylaşacağım.

Bir sonraki derste aktiviteler ve yaşam döngülerinden bahsedelim.

Github : https://github.com/axisting/OfflineRegisterProject

Parametre İstemek

Parametre isteme durumu Java programlama dilinden biraz daha farklı. Java’da class ile aynı isimde bir constructor sınıfı oluşturmak zorunlu idi. Yani siz oluşturmasanız bile java kendiliğinden arka planda bu fonksiyonu oluşturuyordu. Kotlin de bu durum hem biraz farklı hem de aynı aslında. Kotlinde constructor isminde bir constructor sınıfı oluşturuyoruz. Ve içerisinde aynı javadaki gibi atamalarını yapıyoruz. Örneğin yeni bir person classı oluşturalım

class Person {

    var age  : Int
    var name : String
    var job : String

    constructor (ageInput : Int , nameInput : String , jobInput : String  ) {
        this.age = ageInput
        this.name = nameInput
        this.job = jobInput
    }
}

Şimdi oncreate içinde parametreleriyle birlikte çağıralım

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val volkan : Person = Person (20 , "Volkan", "Bilgisayar Mühendisi")
        System.out.println(volkan.name)
    }

Logcat’te göründüğü üzere “Volkan” yazacaktır. Person sınıfının bir nesnesi olan volkan nesnesinin name parametresini çağırmış olduk. (volkan.name ile)

Class tarafında ayrıca şöyle bir kolaylıkta mevcut. Class constructor methodunu direk classın yanında parantezde de oluşturabiliriz.

Class Person ( var age : Int , var name : String , var job : String) {}

Görüldüğü gibi bir class’ı böyle tek satırda yazabildik. Yani constructor’ını class parantezleri içerisinde tanımladık.

Kotlin Erişilebilirlik Seviyeleri (Visibility Modifiers)

Private : Sadece tanımlandığı sınıfta kullanılabilir

Protected : private + kalıtım aldığı sınıfta kullanılabilir.

İnternal : Bütün projeden ulaşılır. Ekstra kütüphanelerden vs. ulaşılamaz.

Public : Her yerden ulaşılabilir. Ayrıca default değerdir.  Herhangi bir tanımlama yapıldığında derleyici otomatik public atar.

Bu şekilde javada 3 olan erişilebilirlik seviyesi kotlinde 4 olarak karşımıza çıkmaktadır. Private’ın kendi class’ına özel olduğunu göstermek için küçük bir örnek yapalım. Person class içerisine

private  var hairColor : String = ""

onCreate içerisinde bunu setlemeye çalıştığımızda

volkan.hairColor = "Black"

HATA alacağız yani direkt olarak haircolor’u görmeyecek ve kırmızı olarak hatalı görünecektir. Ama başında eklediğimiz erişilebilirlik seviyesi olan private kaldırırsak public olacağından erişime açık olacaktır ve hata vermeyecektir.

NOT : Şimdi o zaman ben neden private kullanayım ki diyenler olabilir. Bir değişkeni private yaparak diğer classlardan doğrudan erişimini kaldırmış oluruz. Ama dolaylı olarak setter getter fonksiyonları ile erişim sağlayabiliriz ve kodumuz hem daha okunabilir hem de daha güvenli kod haline getirmiş oluruz.

Kotlin Nullability

Güvenli kod yazmak programlama dillerinde son derece önemlidir. Bir uygulama yazdığınızda bunun kullanıcaya herhangi bir crash , kesinti gibi problemler vermesini istemeyiz. Örnek verecek olursak bir değişken veya sabit initialize edilmez ise uygulama hata verip kendini kapatabilir.

Nullable veya non-null tipler vardır. Herhangi bir şeyi nullable yapmak için (?) kullanılır.

        var myString : String? = null
        System.out.println (myString)

Ekranda manalı bir şey yazdırmaz. Boş manasına gelen null değerini döndürür. Ama hata da vermez. Kullanıcı uygulamayı kullanmaya rahatlıkla devam edebilir. ? kullanmasaydık hata verebilir. ? sayesinde myString hem null değer alabilir hem de String değer alabileceğini belirtmiş olduk.

 var myAge : Int? = null

 System.out.println(myAge!! * 20)

Burada uygulama bize myAge’in değerinin null olabileceğini söylüyor. Bunu tekrar düzenlemem konusunda beni uyarıyor. Eğer ben kesin olarak değer geleceğinden eminsem (!!) ekleyerek kesinliği belirtiyorum. Tabi bunun kötü bir yanı var eğer değer gelmez ise yani null bir değer gelirse uygulama hata verir. Uygulama crash olur. Şimdi daha güvenli kod yazmak üzerinde biraz daha derine inelim.

Kotlin Güvenli Kod Yazma

Kotlin’de güvenli kod yazmanın anahtarı nasıl olacaktır. Eğer null değer kullanırsak null harici zorunlu bir değer isteyen işlemde uygulamamız patlıyordu. Null vermezsekte bir değer tanımlamadığımız için uygulama patlayabiliyordu. Güvenli kod yazmanın anahtarı kontrol etmektir. Bunu değer var mı yok mu şeklinde düşünebiliriz.

        var myNumber : Int? = null
        if (myNumber != null) {
            System.out.println (myNumber*10)
        }else {
            System.out.println("myNumber is null")
        }

Bir diğer yöntem ise safe call yöntemidir. Yukarıdaki ile benzer mantıkta

System.out.println(myNumber?.compareTo(2))

Burada ise eğer denerseniz myNumber null’a eşitlendiği durumda işlem sonucunun null döndürdüğünü ama uygulamanın hata vermediğini görürsünüz.

3. yöntem ise Elvis yöntemidir. Bu yöntem ise tek satırda bu işlemi yap ya da belirlenen anlamsız bir değere ata mantığıdır.

        val myResult =myNumber?.compareTo(2)?: -100
        System.out.println(myResult)

Elvis işleminde de ben null dönsün istemiyorum yerine başka bir şey dönsün istiyorsam (bu örnek için -100) elvis kullanmış oluyorum.

Bu kodda da görüldüğü gibi kodun derleme hatası alma olasılığını ortadan kaldırıyoruz. Böylelikle güvenli bir kod yazmış oluyoruz.

Tüm sonuçların ekran görüntüsü bu şekilde

Github : https://github.com/axisting/KotlinSiniflar

Android Studio’da bir proje oluşturduğumuzda ilk olarak MainActivity’nin oluştuğunu görmüştük. MainActivity burada bir sınıf görevindedir. Yanında : (iki nokta ile birlikte) AppCompatActivity ise başka bir class’tır. Fakat arada 2 nokta olduğu için bu class’tan miras alındığını göstermektedir. Yani AppCompatActivity’nin kullanılmaya uygun fonksiyon ve değişkenlerini bu yeni class’ta kullanabilir demektir.

class MainActivity : AppCompatActivity() { /*.....*/}

NOT : AppCompactActivity’i miras almasından dolayı MainActivity class olduğu gibi android dilinde artık bir Activity özelliği de taşımış olmaktadır.

Class Oluşturma

Class oluştururken android studio’da File – New- Kotlin File/Class yolunu izleyerek oluşturabiliriz. Oluştururken ismini yazmamız gerekiyor. Burası örnek yapmak adına Singer() olsun. Şarkıcıların bilgilerini içeren basit bir class yapalım.

class Singer {

    var name  = ""
    var age = 0
    var type = ""
}

Böyle bir class oluşturduk. Şarkıcının adını yaşını ve hangi türde söylediğini yazacağız. Fakat buraları boş bırakmadık. Şuan için buralara bir değer yazmamız gerekiyor. Ama daha sonradan tamamen sonradan tanımlı şekilde nasıl olacak onu da gösteririz. Şimdi bunu MainActivity class’ı bir nesne olarak çağırıp nesnenin değerlerini tanımlayalım.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        var tarkan = Singer()
        tarkan.name = "Tarkan"
        tarkan.age = 48
        tarkan.type = "Pop"

        System.out.println(tarkan.name + "/" + tarkan.age + "/" + tarkan.type)
        val sagopa = Singer()
        sagopa.name = "Sagopa Kajmer"
        sagopa.age = 40
        sagopa.type = "Rap"

        System.out.println( sagopa.name + "/" + sagopa.age + "/" + sagopa.type)



    }
}

Göründüğü gibi bir class’ın bir den çok nesnesinin kullanımı da bu şekilde oluyor.

Şimdilik burada bırakalım bir sonraki derste constructor (yapıcı fonksiyon) ve class’tan parametre isteme konularına değinelim

1 – Yeniden kullanılabilirlik

2- Düzenli kod yazmak (Okunabilirlik)

3- İstenilen her yerden çağırılabilmek

Bu her programlama dilinde aynıdır. Kullanım şekilleri (syntax) farklı olabilir ama her zaman bu 3 sebep temelinde tüm programlarda fonksiyonlar ile bir çok kez karşılaşırız. Fonksiyonun kotlinde kullanımı ise aşağıdaki şekildedir.

fun test(){
   println("Merhaba")
}

Uygulamanın herhangi bir yerinden artık test fonksiyonu çağırıldığında içinde yazılan kodu çalıştırır. Yani bu örnek için terminale ‘Merhaba’ yazdırır.

Fonksiyonlarda Girdi Almak (input)

Fonksiyonların kullanımında genellikle fonksiyon değer veya değerler ister. Örneğin uygulamada birden fazla kez toplama yapmak istiyorsunuz her seferinde bu tanımlamayı yapmadan tek bir fonksiyon tanımlaması ve bu fonksiyonun çağırımıyla bu yapılabilir. Şöyle ki :

fun main() {
    mySum(5,4)
}

fun mySum ( a: Int , b: Int){
   println (a + b)
}

Main fonksiyonu uygulama derlenirken ilk bakılan kısmıydı. Uygulama derlenirken main içine geliyor ve mySum() fonksiyonunu görüyor. Hemen oraya dallanıyor uygulama ve mySum()’un içi çalıştırılıyor bu sefer.Orada ise girdi olarak alınan a ve b değerlerinin toplanıldığı belirtilmiş. Bu örnek için 5 ve 4 ü topluyor ve sonuç olarak terminale 9 yazdırıyor.

NOT : Fonksiyonların tipleri vardır. Buradaki fonksiyonların tipleri aksi belirtilmediği için Unit tipindedir. (java’daki kullanımı ise void şeklindeydi) Yani boş bir şey döndürmeyen tiptir.

Fonksiyonlarda Değer Döndürmek (return)

Şimdi ise fonksiyonların değer döndürdüğü kısımları düşünelim. Değer döndürmek bir işlem yaptın ve bir sonuç almak istiyorsun. Ama uygulamada bu sonucu aldıktan sonra bunun üzerinde işlem yapmak istiyorsun. O zaman return kullanmamız gerekir. Bir çarpma örneği yapacak olursak :

fun main() {
    var result = myMultiply(5,4)
    println ("result:  $result")
}

fun myMultiply ( x: Int , y: Int) : Int{
   return x*y
}

Burada myMultiply fonksiyonu parantezden sonra int tanımlaması ile aslında bu fonksiyonun int döndürdüğünü belirtiyoruz. Sonucu 20 olarak döndürmüşüz bunu da bir değere yazdırdık. Artık bu değeri main fonksiyonda her yerde kullanabiliriz. Burada ekrana yazdırmışız ve 5*4 ün çarpımını 20 olarak bulduk.

Bu diğerine göre biraz daha uzun duruyor olabilir ama bunu birden fazla kullanma ihtimaliniz olduğu için her zaman en kısa ve sade yoldur.

Fonksiyonlar ve Android’de Görünümler

Android’de proje oluşturduğumuzda java klasörü altında bir MainActivity oluşur. Bununla birlikte layout altında activity_main xml dosyası da oluşur. Layout tarafı görünümleri tasarladığımız xml kodlarının yer aldığı yer iken, java klasörü altında oluşan kısım ise kotlin kodlarımızın yer aldığı kısımdır ve arka planda çalışma biçimlerinin yazıldığı kısımdır.

Şimdi activity main altında bir button oluşturuyoruz ve içine bir onclick methodu tanımlayacağımızı belirtiyoruz.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="buttonClicked"
        android:text="TIKLA"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Burada sadece eklediğimiz kısım button kısmı aslında. Daha sonrasında MainActivity’de onClick fonksiyonunu tanımlıyoruz. Böylece button tıklanıldığında bu fonksiyon çalıştırılacak.

package com.axisting.functions

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.Toast

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    fun buttonClicked (view : View){
        Toast.makeText(applicationContext, "BUTON TIKLANDI " , Toast.LENGTH_LONG).show()
    }
}

Bu şekilde tanımlamasını yapıyoruz.

NOT : Burada yazılan kodun tamamını attım ama bir dahaki kısımlarda böyle yapmayacağım. İlk kez gösterdiğim için öyle yaptım. Kodun tamamını merak edenler içinde Github’a bunları yükleyeceğim yine oradan erişebilirsiniz.

Velhasılıkelam sonucunda butona tıkladığımızda şöyle bir görüntü ortaya çıkıyor.

Bir sonraki ders class’lar. Görüşmek üzere

Github : https://github.com/axisting/Functions

Döngüler, genel itibariyle tekrar eden işlemleri gerçekleştirmek üzere vardırlar. Örneğin; 1’den 10’a kadar programa yazdırmak için döngüleri kullanırız. Döngüleri iyi kavramak programlama dillerinin temelini iyi anlama konusunda son derece önemlidir.

for Döngüsü

for‘un kullanımı

val myArrayOfNumbers = arrayOf (12, 15 , 18, 21)
for (k in myArrayOfNumbers)  {
    val z = k /3*5
    println(z)
}

Burada for döngüsünün bir dizi içinde sırayla geziniyor. Tek tek kendisi arama yapıyor. Çok daha az kod yazıyoruz. Java, C++ gibi dillere kıyasla for içinde tanımlamalarımız vs. çok daha az.

for burada ilk elemandan son elemana kadar her bir elemanı k içerisine koyuyor. Sonrasında her bir iterasyonda k ‘ üzerinde işlemler yapılarak z’ye atanıyor ve z ekrana yazdırılıyor.

Eğer indisler üzerinden işlem yapmak isteseydik (eski usül ama lazım olabilir);

val myArrayOfNumbers = arrayOf (12, 15 , 18, 21)

for (i in myArrayOfNumbers.indices) {
    val qz = myArrayOfNumbers[i] /3*5
    println(qz)
}

Sonuç yukarıdaki ile aynı olacaktır.

Kotlin‘in bir diğer güzelliği ise bazı işlemleri çok daha kısaltabiliyor olmamız.

Örneğin b değişkenine 0-9 arası sayıları yazdırdığımız bir uygulamayı yapmak için

for (b in 0..9) {
    println(b)
}

• Eğer 0’dan 9’a 9 dahil olmadan yazdırmak isteseydik
• 0,1,2,3,4,5,6,7,8

for (b in 0 until 9) {
println(b)
}

• Eğer 0’dan 9 a kadar ikişer ikişer saymasını isteseydik
• 0,2,4,6,8

for (b in 0 until 9 step 2 ) {
println(b)
}

• 9’dan geriye 3’er 3’er saysaydık
• 9,6,3,0

for (b in 9 downTo 0 step 3 ) {
println(b)
}

Bu örnekler bu şekilde çoğaltılabilir ben son olarak foreach’i göstermek istiyorum

val myArrayOfNumbers = arrayOf (12, 15 , 18, 21)

myArrayOfNumbers. forEach  {
	println(it/3*5)
}

Bu da yine ilk işlemimizle aynı sonucu verecektir. Burada sonucu herhangi bir değişkene atamıyoruz. Otomatik olarak “it” nesnesinin içinde tutuluyor. Bizde böylece kullanabiliyoruz.

while Döngüsü

While‘da for‘dan çok farklı bir şey yapmıyor esasında. Fakat for’un aksine tek bir syntax düzeni var.

var j = 0

while (j <3 ) {
    println(j)
    j++
}

Burada da 0’dan 3’e kadar 3 dahil olmayacak şekilde yazdırdık.

continue ve break

continue ve break döngü değiller fakat döngüler ile doğrudan alakalı anahtar kelimelerdir. continue döngünün iterasyonunu bir sonrakine geçirirken, break döngüyü tamamen sonlandırır. Yani 1’den 10 a kadar saydığımızı düşünürsek 5’te bir karşılaştırma yapıp continue kullanırsak 5 hariç tüm sayıları yazdırır.(1,2,3,4,6,7,8,9,10) break kullanırsak 5 ve sonrasını yazdırmaz. (1,2,3,4)

for (x in 0..10) {
    if (x == 5 ) {
        continue
    }
    println(x)
}

for (x in 0..10) {
    if (x == 5 ) {
        break
    }
    println(x)
}

break ve continue kullanımını da öğrendik. Son bir detay var continue ile ilgili. @ kullanımı. @ continue ile kullanıldığında döngüyü istediğimiz bir yerden devam ettirmemizi sağlıyor.

Asal sayıları yazdırmakla ilgili şuana kadar öğrendiklerimizle güzel bir örnek yapalım. Bu örnekte 2’den 100’e kadar asal sayıları yazdıran kotlin programını kodlayalım

outer@ for (n in 2..100) {
    for (d in 2 until n) {
        if (n % d == 0) continue@outer
    }
    println("$n asaldır")
}

Kod’da outer yerine istediğiniz bir zıplama noktası yazabilirsiniz. Evrensel olarak outer kullanmak ve ingilizce kullanmak kodun okunabilirliği açısından olumlu olacaktır.

Evet şimdilik bu kadar. Bir sonraki derste görüşmek üzere.

Operatörler

Toplama, çıkarma, çarpma, bölme işlemlerini yapmak için matematikte herkesin bildiği operatörler vardır (+,-,*,/). Bunların haricinde kıyaslama yapmak ve eşitlikleri göstermek için de operatörler vardır. Kontrolleri yaparken özellikle bunları kullanıyoruz. “Hava güneşli mi?” veya “Hız sabit mi?” gibi kıyaslamalar günlük hayatta yapabiliyoruz. Bunları programlamaya dökmek için de aşağıdaki operatörleri kullanıyoruz.

Kotlinde toplama (+), çıkarma (-), çarpma (*) ve bölme (/) normal matematik operatörleri ile aynı işlevde kullanılıyor. Eşittir işareti eşitlik göstergesi. Büyüktür (>) ve küçüktür (<) işlemleri ise sayılar için büyüktür küçüktür işlemine denk gelmektedir.

(!) işareti ise değil anlamına gelmektedir. a != b işlemi : a eşit değildir b anlamına gelmektedir.

En önemli operatörler başlangıç için bunlar. İstisna birkaç kullanımda ise

a++ -> a’yı 1 artır

++a -> a’yı 1 artır

a– -> a’yı 1 azalt

–a -> a’yı 1 azalt

(+)’nın önce gelmesi ve sonra gelmesi farketmeksizin aynı sonuçları verdiğini yazdık. ( (-)’de kendi özelinde aynı şekilde). Şimdi durum şu. Eğer o satırda o an bir işlem yapılacaksa, örneğin, ekrana bir şey yazdırılacak ve bunun artırılmış şekilde yazılmasını istiyorsak ++a kullanıyoruz. Eğer o satırda değil sonraki satırda artırılmasını ekranda ise o anki sayıyı görmek istiyorsak a++ kullanıyoruz. (-) içinde benzer işlemler geçerli. Biraz kafa karıştırıcı hemen bir örnekle üzerinden geçelim

    var a = 5
    System.out.println(a++)
    System.out.println (a)
    System.out.println ("------------------")
    var b = 5
    System.out.println(++b)
    System.out.println (b)
    System.out.println ("------------------")
    var c = 5
    c++
    System.out.println(c)
    var d = 5
    System.out.println ("------------------")
    ++c
    System.out.println(d)
    System.out.println ("------------------")
    

Bu kodun çıktısını sizde dikkatlice incelerseniz ne anlatmak istediğimi anlayacaksınız.

Sizde aynı mantıkla çıkarma işlemini (-) değerlendirebilirsiniz.

Kontroller

if Kontrolleri

if İngilizce’den Türkçe’ye eğer olarak çevirilebilir. Eğer doğruysa bunu yap. Değilse şunu yap mantığı var. Önemli bir işin varsa dışarı çık. Değilse #evdekal gibi 🙂

var work : Boolean = false

fun main() {
	// work = true ise işim var false ise işim yok
    work = true 

    workControl()
    System.out.println("-------------------")
    workControl()

    
}
fun workControl() {
   	if(work ==true) {
        System.out.println ("İşimi halletmek için dışarı çıktım")
        work = false // işimi hallettim artık work = false
    }else {
        System.out.println("Dışarıda işim yok #evdekal ")
    }
}

Bu kotlin kod satırlarında anlatılan şudur. İlk olarak main’e bakıyoruz. Mainde work değişkeni true olarak setleniyor. Kişinin dışarıda işi var. İşi var mı? kontrolü için workControl() fonksiyonuna yönlendiriyor. Burada work kontrol ediliyor işi olduğu için dışarı çıkıyor. Ve işini hallettiğini belirtmek için work değişkeni false’a setleniyor. Tekrar control çalıştırıldığında ise bu sefer #evdekal mesajı görünüyor.

if – else if – else olarak if kontrolleri çoğaltılabilir. Daha fazla dallanma, ayrıştırma işlemi yapılabilir. Fakat bu tip durumlar için gayet basit bir kontrole geçelim.

Switch – When Kontrolleri

Çok fazla if else durumları olduğunda when kullanılabilir. Daha düzenli ve daha anlaşılır bir görünüm sağlayabilir.

When kontrolünü anlatmak içinde ayların kaçıncı aya karşılık geldiğini anlamamızı sağlayan bir kotlin programı yazalım.

fun main() {
    val monthNumber = 10
    var mountString : String? = null
    //var mountString = ""
    when (monthNumber){
        1 -> mountString = "Ocak"
        2 -> mountString = "Şubat"
        3 -> mountString = "Mart"
        4 -> mountString = "Nisan"
        5 -> mountString = "Mayıs"
        6 -> mountString = "Haziran"
        7 -> mountString = "Temmuz"
        8 -> mountString = "Ağustos"
        9 -> mountString = "Eylül"
        10 -> mountString = "Ekim"
        11 -> mountString = "Kasım"
        12 -> mountString = "Aralık"
        else ->  mountString = "Miladi takvim 12 tane ay ile sınırlıdır."       
    }
    System.out.println(mountString)
}

When ile görüldüğü üzere birçok kontrolü içeren düzenli bir yapı elde ettik. Mount number kullanıcıdan istenilerek hangi aya denk geldiği kolaylıkla bulunabilir. mountNumber’in kontrolünü when ile yaparak istenilen ay mountString’e setleniyor. Sonunda da ekrana yazdırılıyor

Bu kotlin kodlarında;

    var mountString : String? = null
    //var mountString = ""

görüldüğü üzere alttaki satırı kullanmadık üstteki olanı kullandık. Bunun sebebi güvenli kod yazmaktan ötürü gelmektedir. Ben burada anlatırken kolay olması açısından alttakini kullabilirdim. Ama bu sisteme alışmak açısından güvenli kod yazmaya, sonradan tanımlamaya, initialize etmeye alışmak için bunları yavaş yavaş yazmaya başlayalım.

Kaynaklar : https://kotlinlang.org/

Diziler (Arrays)

Kotlinde diziler, statik yani büyüklüğü baştan belirlenmiş veri topluluklarına denir.

val myBrothers = arrayOf ("Volkan", "Oguzhan", "Hasan" )
println(myBrothers.size())

Boyutunun 3 olduğunu görürsünüz ekranda. Şimdi burada 0. (sıfırıncı) indis “Volkan”, 1. “Oguzhan” , 2. “Hasan” ‘dır. Burada indislerin sıfırdan başlanıldığı unutulmamalıdır.

myBrothers.set(0, Furkan) //0. indisi furkan yapar
myBrothers.sort()  //sıralama yapar
println(myBrothers[1]) 

Bunu yaptığımda ekranda “Hasan”‘ı gösterir. Çünkü alfabetik olarak sıralandığında dizinin 1. indisindeki eleman (yani 2. elemanı) “Hasan” olur.

Peki diziye olmayan bir sıralamayı eklemeye çalışsaydım ne olacaktı ?

myBrothers[3] = "Ümit"
println(myBrothers[3])

hata mesajı alırdım. Çünkü bu statik başlangıçta boyutu belirlenen bir dizi. Ben buna sondan ekleme yapamam. Yapacağım eklemelerde bir önceki değeri silip üzerine yazılacaktır. Eğer deneyenler olursa : ArrayIndexOutOfBoundsException hatası alındığını görecektir. Uygulama çökecektir. Bu tamamen istenmeyen bir durumdur. Bu sebepten boyutu bilinen dizilerde boyutunca işlem yapılmalıdır.

Listeler (Lists)

Dinamik bir dizi yapısıdır diyebiliriz. Sonradan eklemeler, baştan ekleme vs. yapılabilir. Hadi bir anime listesi yapalım ve bu animeler stringlerden oluşacağı için tanımlamasını yaparak atama işlemi yapalım bu sefer.

    val myAnime = arrayListOf <String>()
    myAnime.add("One Piece")
    myAnime.add("Shokugeki no Souma")
    myAnime.add("Bleach")
    myAnime.add("Fairy Tail")
    
    println("first anime : ${myAnime[0]}")

Şimdi burada görüldüğü gibi en baştan bir atama yapmamıza gerek yok dizilerdeki gibi. Bu bize fazla fazla esneklik kazandırıyor zaten. İstersek başta da tanımlamalar yapabilirdik. Fakat yine ekleme, çıkarma her türlü yapardık. Bu bize bir esneklik, dinamiklik kazandırıyor. Örneğin, bir veritabanından verileri çekiyorsun ve ne kadar veri geldiğini bilmiyorsun. Bu durumda arrayList kullanmamız gerektiği çok açıktır.

NOT : Ayrıca burada listelerden bağımsız bir detay daha var. Son satıra bakarsanız tırnak işareti içerisinde 0. elemanı çağırma işlemi yapmışız. Java’dan farklı olarak Kotlin’de String kısmın içine ${} ile istediğimiz kodları yazabiliriz. $ kendinden sonraki {} içindeki kısımı tırnak içerisinin dışındaymış gibi çalıştıracaktır.

SET

Set ise kısaca tekrarlı olmayan liste diyebiliriz. Küme mantığı vardır. Hani siz nasıl bir kümeye aynı değerden eklemezsiniz. Set de aynı şekildedir. Kısa bir tanımlama yapalım.

val citiesList = setOf ("Ankara","Ankara","İstanbul" ,"Antalya","Çorum" )
println(citiesList.size())

4 sonucunu verecektir. Tamamen büyük-küçük ayrımı yaparak aynı olan değerleri 1 değer olarak tutar. Bu durumda 1. indis doğal olarak “İstanbul ” olacaktır.

HashSet

HashSet Set ile aynı aslında. HashSet Setin özelliklerini taşır. Bunu çağırırken bir nesne olarak değil de doğrudan bir sınıf olarak çağırıp oluşturuyoruz.

val myNumbers = HashSet <Int> (1,2,3,1,4,5,3)
println(myNumbers.size())

5 değerini ekranda yazdıracaktır.

MAP

Bir anahtar ve bir değerin olduğu topluluklardır diyebiliriz. Mesela bir öğrenci listesi yapıyorsun. Bu listede ise öğrenci no ve öğrenci adını tutmak istiyorsun. Bu tam sana göre. Öğrenci numarası yani anahtar tamamen benzersiz olmalıdır. Map içinde aynısı geçerlidir. Anahtar kısmı tamamen diğerlerinden her zaman farklı olmalıdır.

val studentMap = mapOf<Int, String>(19 to "Volkan")
println(studentMap[19])

Ekranda “Volkan” yazdırır. Aynı dizideki gibi sonradan veri eklenmez. Eklemek için hashmap oluşturmalıyız.

HashMap

var studentHashMap = hashMapOf <Int, String>() 
studentHashMap.put (1, "Ceyda")
studentHashMap.put (2, "Selim")
println (studentHashMap[1])

ekranda “Ceyda” yazdıracaktır. Aynı tanımlama şu şekildede yapılabilirdi.

var studentHashMap = hashMapOf  <Int, String>(1 to "Ceyda", 2 to "Selim") 
println(studentHashMap[1])

Koleksiyonlarda bu kadardı. İyi Çalışmalar

Kaynaklar : https://kotlinlang.org/docs/tutorials/

Medium : https://medium.com/@dvolkan2001/kotlin-koleksiyonlar-collections-ders-2-3ab74e3f3444

Değişkenler (Variables)

Değişkenler adı üzerinde sonradan değişebilen veri tipleridir. Örnek:

var x = 5
x = 6 
println(x)

yazıldığında 6 sonucunu verir. Görüldüğü gibi x başlangıçta 5 değeriydi sonrasında ise bu değer 6 olarak değiştirilebildi.

Sabitler (Constants)

Sabitler ise adı üzerinde sonradan değiştirilemeyen veri tipleridir. Uygulamamızda hiç değişmesini istemediğimiz veriler var ise sabitler kullanılır.

val name = "Volkan Demir"
name = "Hasan"

şeklinde name’i değiştirmeye çalışırsam hata gösterir ve bunu yapamayacağımız konusunda bizi uyarır. Eğer hala kullanmak istersek “val” tanımlamısını “var” olarak değiştirmemiz gerekir.

Kotlin Veri Tipleri 2:

Bu kısım ise değişken ve sabitler ile birlikte kullanılan veri tiplerini içerecektir.

Tam Sayılar (Integer)

Sadece tam sayı tipi olan değişken veya sabitleri temsil eder. Sasece tam sayılar !

val myNumber : Int      //Defining : tanımlama kısmı
myNumber = 3   //Initialize : atama kısmı 

myNumber sabitini 3 olarak atadık. bunu tek satırda 2 farklı gösterimle de tanımlayabilirdik.

val myNumber : Int = 3    

şeklinde tanımlama ve atama kısmını tek bir satırda yazabilirdim veya

val myNumber = 3

şeklinde tanımlama yapmadan atama yaparsam da Kotlin bunun Int olduğunu anlayacaktır. Örnek:

var number : Int = 19
println(number / 2)

9 yazdırır. Tam sayılar da işlem yaptığı için gerçekte 9.5 olan sonuç kesirli kısmı almayarak 9 yazdırır.

Kesirli Sayılar (Float, Double)

Burada ise işin içine kesirli sayılar da girer. Bir önceki örnekteki gibi durumlar ile karşılaşıldığında double veya float kullanmak mantıklıdır. Gelin pi sayısını tanımlayalım

val pi  = 3.14 

veya

val pi : Double = 3.14

“pi” sayısı her zaman sabittir mesela bu sebepten val kullanırız. Bunun haricinde bu tanımlamayı yaptığımızda pi artık double bir sabittir. Float için :

val pi : Float = 3.14f

sonuna “f” karekteri eklenerek sayının float olduğu belirtilebilir.

String

Text olarak saklanmak istenildiğinde veriler String kullanılır.

val myName : String = "Volkan Demir"
val myNick = "Axisting"

şeklindedir. Tabi Stringler üzerinde birçok farklı method kullanabilirsiniz. bunları yapmak için değişkenin ismi sonra nokta (.) kullanılarak işimize yarayan methodları kullanabiliriz.

val myNick = "axisting"
myNick.captalize()
println(myNick)

captalize methodu ilk karakteri büyük yapmaya yarar. Burada logcat ekranında “Axisting” yazısını görürüz.

Boolean

Sadece 2 farklı değer içerir. Bunlar “doğru” veya “yanlış”a karşılık gelen “true” ve “false”‘dur

var myBoolean : Boolean = false
myBoolean = true

Dönüştürmek (Conversion)

Bu verileri birbirine dönüştürmek isteyebiliriz. Mesela veritabanından bir öğrenci no’yu çekerken bu değer String olarak çekiyor olabiliriz. Bunu integer’a dönüştürmek isteyebiliriz. Bir başka örnekte yine int olarak aldığımız bir işlemde matematiksel işlemler yaptırmak isteyebiliriz ve kesirli sayılarla uğraşmamız gerekebilir. O zaman da integer değişkeni double’a çevirmemiz gerekir.

var x = 23
var y = 4
println (x/y)
println (x.toDouble()/y)

Görüldüğü üzere ilk yazdırma da 5, ikinci yazdırmada 5.75 çıktı sonuç. Bunun sebebi x’i double yapıp işleme koyduğumuzda double ve integer işleme girdiğinde sonuç daha kapsamlı olan double’ın tipinde yazdırıldı.

Şimdi de String bir değişkeni integer bir sayıya çevirelim.

val a = "19"
val aInteger = a.toInt()
println(aInteger)

sonuç “19” olacaktır. Bu özellikte ayrıca veritabanından çekilen verilerde oldukça kullanışlıdır. Yalnız eğer içerde rakamlar harici dönüştürülemeyecek karakterler bulunursa (a,b,c, >, ? vb.) o zaman uygulama hata verecektir.

Şimdi bunların haricinde long, byte, short gibi veri tipleri de vardır. Bunların int ile kıyaslamasının verildiği tabloyu aşağıda vererek dersi bitirelim. Farkları tablo üzerinden incelenebilir.

kısaca kullanımları ise :

    val a : Long = 12131312
    val b : Short = 12
    val myByte : Byte = 7
    
    println(a)
    println(b)
    println(myByte)

Kaynaklar 1: https://developer.android.com/kotlin/learn

Kaynaklar 2: https://kotlinlang.org/docs/reference/basic-types.html

Kodlarınızı test etmek için Kotlin IDE : Android Studio veya https://kotlinlang.org/

Bu kısımda Kotlin derslerimi ve çalışmalarımı kayıt alıp kamuya açık bir alanda paylaşmak istedim. Normalde deftere not alarak ve kod çalışmalarımı kendi harddisk’imde depoluyordum. Eskiden beri aslında çalışmalarımı hep blogumda paylaşmak istemiştim fakat bilirsiniz üşengeçlik vs. bunu hep erteliyordum ve geleneksel yöntemlerimden şaşmıyordum. Artık bu çalışmaların hem insanlara faydalı olması açısından, hem de internet ortamında bunları ölümsüzleştirmek ve kolayca ulaşılabilir olmasını istediğimden ötürü paylaşıyorum.

Kotlin Yazım Kuralları ve Kodlama Standartları

Burada kısaca değineceğim konu bir kodlama standardı aslında. Öncelikle Kotlin’de Java’dan farklı olarak “;” (noktalı virgül) yok. Bu beni çok mutlu etti. Eğer “Enter” ‘e basıp bir sonraki satıra geçiyorsanız o satır bitmiş oluyor. (isterseniz ; kullanabilirsiniz fakat alt satıra geçiyorsanız buna gerek yok)

Kodlama standardı temelde 2’ye ayrılır. Camel Case ve Snake Case. Yazım standartları şirketten şirkete, yazılımcıdan yazılımcıya farklılık gösterir.

Camel Case yazım şekli değişkenler üzerinden örnek verecek olursak:

var sayfaninSonuNumarasi = 11

şeklindedir.

Snake Case ise :

var sayfanin_sonu_numarasi = 11

şeklindedir. Bir kodlama standardı ortaya koymak her proje için tekrar kullanılabilirlik, anlaşılırlık, kolaylık gibi faydalar sağlamaktadır.

Ayrıca yine açıklayıcı yorum satırı kullanmak projeye anlaşılırlık katacaktır. Yorum satırının kullanımı ise “//” iki slash sonrasında yazılan yazılarla gerçekleşir

var name = "Volkan"  //isim tanımlaması

Kotlin : Merhaba Dünya

Gelin ekrana yorum satırı ile birlikte yazılmış bir “Merhaba Dünya” yazdıralım.

println("Merhaba Dünya")
//logcat'e Merhaba Dünya yazdırır

logcat yazılımcıların gördüğü fakat uygulama kullanıcılarının görmediği bir alandır. Burada uygulama derlenirken olan tüm işlemler sıralanır. Burada şuan için aradığımızı bulabilmek için logcat ekranındaki arama kısmına System.out.println yazmamız test amaçlı yeterlidir.

logcat, uygulamanın testinde, runtime hatalarında veya herhangi merak edilen işlemin incelenmesi için bakılan penceredir.

Kotlin kodlarını nasıl test ederim?

“Tamam, ben bu kodları yazdım ama nasıl test edeceğim?” bunun için Google’ın kendi geliştirmiş olduğu bir uygulama olan Android Studio var. Android Studio ile hem test edebilir hem de simülasyon telefon üzerinden bakabilirsin. Çok fazla güzel özelliği bulunan Android Studio’yu kullanamayabilir çünkü çok fazla RAM isteyen bir uygulama. Bunun için Google’ın yine kendisinin geliştirmiş olduğu Kotlin IDE’yi tavsiye edebilirim. Kotlin IDE üzerinden, Android Studio’da logcat üzerinden incelediğimiz sonuçları kolaylıkla inceleyebilirsiniz.

Kotlin IDE : https://kotlinlang.org/

Kaynaklar : https://developer.android.com/kotlin/learn

Medium : https://medium.com/@dvolkan2001/kotlin-dersleri-kotlin-ile-android-programlama-19493b25a3e5