Buradaki amacımız şirket serverlarına bağlanmak olabilir, ilgili ortak dosyalara erişmek olabilir veya sadece bir PC bilgisayar Microsoft uzaktan masaüstü ile bağlanma söz konusu olabilir. Bu yazıyı okuduğunuzda ve uyguladığınızda aslında hepsi için çözüm üretebilmiş olacaksınız. Çünkü en özel uygulanışı olan Uzak Masaüstü işlemini deneyeceğiz.

Sophos Firewall Üzerinde VPN Oluşturma

Bu konu hakkında çok değinmeyeceğim. Zaten internet üzerinde çok fazla kaynak var. Ama yine de VPN kurulumu için kısaca yapmanız gerekenler Sophos VPN üzerinde Authentication -> Users ‘e giderek kişi adına bir kullanıcı oluşturun. Daha özel bir kullanıcı oluşturmanız veya birden fazla kişinin kullanacağı bir genel bir kullanıcı da oluşturabilirsiniz. Sadece bir kişi belli bir IP’ye uzak masaüstü bağlantısı yapması gerekiyorsa o halde kişiye özel açabilirsiniz. Sonrasında Remote Access VPN -> SSL VPN ile bir VPN oluşturun. Bu VPN’i de bu kullanıcı ile ilişkilendirin. Bu konu özelinde, VPN oluştururken sadece bir kişi belli bir özel IP’ye ulaşmasını istediğimiz için uzaktan bağlanacağımız bilgisayarın IP’sini buraya tanımlayalım. Kısaca bu kısım bu şekilde.

Macbook Üzerinde Sophos Configuration Dosyasını İndirme

Firewall’unuzun User Portal‘ına gidin ve ilgili kullanıcı bilgileri ile giriş yapın. VPN sekmesinin altına gelin. Burada Download for macOS dosyasını indirin. Ardından Download for Windows, macOS, Linux SSL VPN configuration dosyasını da indirin.

.pkg uzantılı olan ilk indirdiğiniz dosyayı çalıştırın ve yönelgeleri takip ederek kurun. Kurduktan sonra Sophos ile ilgili bir şey yapmanız gerekmiyor.

TunnelBlick kurulumu

Sophos macOS üzerinde bir uygulama arayüzü sunmadığı için bu açığı TunnelBlick ile kapatacağız. Tamamen açık kaynaklı ve güvenilir bir programdır. App Store’da bulunmadığı için buradan orjinal web sitesinden indirebilirsiniz.

Mevcut stable sürümü seçin ve indirin. .dmg uzantılı bir dosya inecek. Bunu tıklayıp yönelgeleri takip ederek çalıştırın.

Ardından Sophos user portaldan indirdiğimiz .ovpn uzantılı dosyaya tıklayın ve açılan pencerede sağ üstte TunnelBlick uygulaması ile aç seçeneğini seçin.

Böylece SSL VPN Configuration dosyamız artık açılmış oldu. TunnelBlick uygulaması üzerinden sağ altta bağlan seçeneğini seçelim. Önümüze gelen pencerede VPN kullanıcı bilgisi ve şifresini girelim. Hatırla seçeneğini seçerek tekrar tekrar şifre girmenin önüne de geçebilirsiniz. Böylece VPN ile bağlantı olmuş oldu. Şimdi uzak masaüstüne nasıl bağlanırız ona geçelim.

Microsoft Uzak Masaüstü Kurulumu

Uzak masaüstü Windows bilgisayarlarda hali hazırda olduğu için kurmamız gerekmiyordu. Ama macOS bilgisayarlarda bu durum tabii ki farklı. Bunun için App Store üzerinden Microsoft Remote Desktop uygulamasını indirin.

Ardından uygulamaya girin ve uzaktan bağlanacağınız bilgisayarın IP’sini girerek kaydedin. Devamlı girmek istemiyorsanız oturum adı ve şifresini tek seferlik girip kaydederek uzak masaüstüne bağlanabilirsiniz.

Sonrasında aşağıdaki gibi bir ekran karşınıza çıkacak. İlgili uzak masaüstüne çift tıklayarak bağlanabilirsiniz. User account’u kaydettiyseniz sizden username ve password isteyecektir. Bağlanacağınız bilgisayarda uzak masaüstüne izin verdiyseniz sorunsuz bağlanacaktır.

Eğer uzak masaüstüne bağlanılacak bilgisayarda izin vermediyseniz Bilgisayarım -> Bilgisayarıma sağ tık ve Özellikler -> Gelişmiş sistem ayarları -> Uzak -> Bu bilgisayara uzaktan bağlanılmasına izin ver -> Kullanıcıları Seç -> Ekle -> Seçilecek nesnenin adlarını girin kısmına hangi oturuma bağlanacaksa oturum ismini yazıp adları denetle deyin tekrardan. Böylece bu bilgisayarda bu oturuma izin vermiş olursunuz.

Ve macOS bilgisayarınızla tekrar bağlanmayı denediğinizde sorunsuz bir şekilde bağlanabileceksiniz.

Umarım anlaşılır bir çalışma olmuştur ve sorunsuz kurulum gerçekleştirebilmişsinizdir. Herkese iyi çalışmalar dilerim.

Bunun için klavyende yön tuşlarının üstünde scroll lock tuşuna basıp açıp kapatmayı deneyebilirsin. Ve istediğin sonuca ulaşabildin mi bu şekilde kontrol et.

Ama bazı HP gibi laptop klavyelerinde bu tuş olmayabiliyor. Alanı optimum kullanmak adına laptoplar bu yola gidebiliyor. Bu klavyelerde Fn – C kombinasyonu ile yine scroll lock yani kaydırma kilidini açıp kapayabilirsin.

CMD Komut Satırı Üzerinden Yüksek Performans Açma

Eğer tüm oturumlarda Yüksek Performansı açmak istiyorsan arama kısmına cmd yazın ve yönetici olarak başlatın

Powercfg -setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

CMD Komut Satırı Üzerinden Nihai Performans açma

Eğer tüm oturumlarda Nihai Performansı açmak istiyorsan arama kısmına cmd yazın ve yönetici olarak başlatın. 

Not : Burada Yüksek Performans ayarlarından farklı olarak 2 aşamalı bir işlem yapıyoruz.

powercfg /DUPLICATESCHEME e9a42b02-d5df-448d-aa00-03f14749eb61

Sonra karşımıza her bilgisayarda farklı olan bir ID değeri verecek. 

Power Scheme GUID: 3845709a-a9fd-48c2-b947-723456a4942d  (Nihai Performans)

Böyle bir ID veriyor. Bu ID değerini de kullanarak aşağıdaki gibi değiştirebilirsiniz. Aynı pencereyi kapatmadan aşağıdaki işlemi yapmalısınız kendi ID değeriniz ile.

powercfg /s 3845709a-a9fd-48c2-b947-723456a4942d

Yani aslında powercfg /s <SENINBILGISAYARID> şeklinde de kısaltabiliriz.

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/