Tüm yazılar

Java 8 Yenilikleri – Bölüm 1

java8-bolum1
İçindekiler

Uzun bir aranın ardından sonra herkese çok çok selamlar… Java 8 uzun zamandır (5 sene olmuş 😮 ) aramızda olan bir sürüm. Ancak getirdiği yenilikler oldukça kullanışlı. Bu özellikleri elimden geldiğince anlatmaya çalışacağım.
Java 12 çıktı yeni mi yazıyorsun diyenler için güncel olarak Java 8 kullanımı devam etmekte, geç olsun ama güç olmasın bilgi bilgidir mantığı ile yazıma başlıyorum.

Bu bölümde bahsedeceklerimi başlık altında toplamak gerekirse;


1. Default Metodlar

Java 8 öncesinde herhangi bir Interface ( Arayüz ) sınıfında gövdesiz metod yazmak mümkün değildi. Java 8 ile gelen default kelimesi ile artık Interface sınıflarda gövdeli metot yazmak mümkün. Şöyle ki;

Hesapla.java

public interface Hesapla {
    Integer topla(Integer sayi1, Integer sayi2);
    
    default Integer kareAl(Integer sayi){
        return sayi * sayi ;
    }
}

Hesapla.java · GitHub Gist

Hesapla isimli Interface’imizi eğer implement/uygulamak istersek java bize 2 yol sunuyor. İlki Anonymous Inner Class olarak tanımlamak, ikincisi ise bu arayüzün implementasyonunu yapan bir sınıf oluşturmak.

  1. Anonymous Inner Class
public class HesaplaDeneme {
    public static void main(String[] args) {
    
            Hesapla hesapla = new Hesapla() {
                @Override
                public Integer topla(Integer sayi1, Integer sayi2) {
                    return sayi1 + sayi2;
                }
            };
            
            Integer toplam = hesapla.topla(5, 5);
            System.out.println("Toplama sonucu : " + sonuc1);
            
    }
}

AnonymousInterface.java · GitHub Gist

2. Interface Implementation Class

public class HesaplaImplementation implements Hesapla {

    @Override
    public Integer topla(Integer sayi1, Integer sayi2) {
        return sayi1 + sayi2;
    }

    public static void main(String[] args) {
        HesaplaImplementation hesapla = new HesaplaImplementation();
        Integer toplam = hesapla.topla(10, 10);
        System.out.println(toplam);
    }
}

HesaplaImplementation.java · GitHub Gist

Görüldüğü gibi 2 durumda da default anahtar kelimesi ile oluşturduğumuz metodun gövdesini yazmak zorunda kalmadık. Dilersek bu metodunda gövdesini oluşturabilirdik.


2. Fonksiyonel Arayüz ( Functional Interface )

Lambda ifadelerini uygulayabilmek için tasarlanmış ve sadece bir tane abstract ( soyut) metoda sahip fonksiyonel bir arayüzdür. Özellikleri ;

  • Maximum bir tane abstract metod bulundurabilir.
  • İçerisinde birden fazla static ve default metodlar barındırabilir.
@FunctionalInterface // Opsiyonel
public interface FunctionalInterfaceExample {

    Integer topla(Integer sayi1, Integer sayi2);

    static void selamVer(){
        System.out.println("Selam !");
    }
    
    default Integer kareAl(Integer sayi){
        return sayi * sayi ;
    }

}

FunctionalInterfaceExample.java · GitHub Gist


3. Lambda İfadeleri

Lambda ifadeleri, kısaca kendi başlarına tanımlanabilen herhangi bir classa ait olmadan iş yapabilen fonksiyonlardır. Buradaki fonksiyon kelimesi Java’cılara biraz garip gelebilir bildiğimiz metod diyebiliriz. İki adet parametre alan ve bu bu parametreleri çarpan bir fonksiyonu matematik ile şu şekilde ifade edebiliriz.

fonksiyon(x,y) -> x * y

Lambda bizlere daha okunabilir kod yazma imkanı ve yukarıda bahsetmiş olduğum Functional Interface’lerin implementasyonunu yapmamızda kolaylık sağlamakta.

Unutulmamalıdır ki, lambda ifadeleri yalnızca Functional Interface’lerle kullanılabilmekte.

Syntax olarak; (argument-list) -> {body} şeklindedir.

(argument-list) kısmında Interface sınıfında ki metodumuz tipine göre eğer parametre almayan bir metod ise boş bırakılır, parametre alan bir metod ise bu parametreler buraya yazılıp argüman olarak metoda gönderilir.

{body} kısmında ise metodumuzun ne iş yapacağı bilgisini tanımlayabiliriz. Yani kısaca metod gövdesi.

İlk olarak parametre almayan geri değer döndürmeyen soyut metod bulunduran yani Functional Interface’in lambda expression kullanarak implementasyonunu nasıl yapabiliriz ona bakalım.

public class OtelOtomasyonu {

    public static void main(String[] args) {
        Resopsiyonist resopsiyonist = () -> { System.out.println("Selamlar"); };
        resopsiyonist.selamVer();
    }

}

Otel.java · GitHub Gist

public interface Resopsiyonist {

    void selamVer();

}

Resepsiyonist.java · GitHub Gist

Parametre alıp geri değer döndürmeyen bir metod için şu şekilde yapabiliriz;

public class KonusanRobot {
    public static void main(String[] args) {

        Robot robot = (String isim) -> {System.out.println("Merhaba, " + isim );};
        robot.ismimiSoyle("Faruk");

    }
}

KonusanRobot.java · GitHub Gist

public interface Robot {

    void ismimiSoyle(String isim);

}

Robot.java · GitHub Gist

Parametre alan ve geri değer döndüren bir fonksiyonumuz olduğunu düşünelim. Örneğin Integer tipinde iki sayı giriliyor ve bu girilen sayıları çarpıp geriye sonucu döndürüyor. ( fonksiyon(x,y) -> x * y )

public interface Fonksiyon {

    Integer carp(Integer sayi1, Integer sayi2);

}

Fonksiyon.java · GitHub Gist

public class HesapMakinesi {
    public static void main(String[] args) {

        Fonksiyon fonksiyon = (Integer sayi1, Integer sayi2) -> { return sayi1 * sayi2 ;};
        Integer sonuc = fonksiyon.carp(10, 10);
        System.out.println("Çarpım sonucu : " + sonuc);

    }
}

HesapMakinesi · GitHub Gist


Syntax konusunda kullanışlı bir kaç püf nokta… 💡

interface Robot{
  	void ismimiSoyle(String name);
}

public class KonusanRobot{
  	public static void main(String [] args){
      	
        // 1. yazım kuralı
        Robot robot = (String name) -> { return System.out.println("Merhaba, " + name); };
        
        // 2. yazım kuralı    	
        Robot robot = (String name) -> (System.out.println("Merhaba," + name);
		
        // Ayrıca -> ifadesinin sağında kalan alandaki () parantezlerini silebiliriz.
	Robot robot = (String name) -> System.out.println("Merhaba," + name);
        
        // Argümanın türünü derleyici bizim için otomatik çözer, türü silebiliriz.
        Robot robot = (name) -> System.out.println("Merhaba," + name);    
                                        
        // Tek bir argüman gönderildiğinde -> ifadesinin sol tarafındaki () silinebilir.
  	// Son hali ile ne kadar basit ifadeye dönüştüğüne dikkat ettiniz mi ? :)
  	Robot robot = name -> System.out.println("Merhaba," + name);
                                        
      	robot.ismimiSoyle("Faruk"); // Konsol Çıktısı ---> Merhaba, Faruk
                                        
	}
}

SyntaxTricksForLambdaExpression.java · GitHub Gist

  • Parametre tipini bazen derleyiciler çözümleyemez. Parametre tipini yazmanız gerekebilir.(String, Integer, Object vb.)
  • Parametre almayan metodlar için -> ifadesinin sol tarafında bulunan (argument-list) alanı () şeklinde boş bırakılabilir.

4. Metot Referansı

Java 8 öncesine kadar bir metoda parametre olarak ya primitive türde bir değişken ya da bir nesne gönderebiliyorduk. Artık bir metoda aynı formatta olan bir metodu referans alabileceğini söyleyebiliyoruz.

Tek soyut metoda sahip fonksiyonel arayüzlerle birlikte kullanılabilen “Metot referans” yöntemi bir lambda ifadesi gibi düşünülebilir.

Daha açık olmak gerekirse, bir lambda ifadesi tanımlanırken fonksiyonel arayüz sınıfımızda bulunan metodun tipini ve parametre alıp almamasını dikkate alıyorduk. Eğer bu yapıda olan herhangi bir metodumuz varsa bu metodu lambda ifadesi gibi kullanabiliyoruz.

Static olan ve olmayan metodlar için durum değişmekte. Syntax şu şekilde;
Static olan bir metod için referans verilirken ; ClassName::MetodIsmı
Static olmayan metod için ise ; ObjectReferans::MetodIsmı

public interface Ogrenci {

    Double notHesapla(Double vizeSinavi, Double finalSinavi);

}

Ogrenci.java · GitHub Gist

public class Okul {
    public static void main(String[] args) {
        
        // Lambda ifadesi ile bu şekilde yapabiliyorduk.
        // Ogrenci ogrenci = (vizeNotu,finalNotu) -> ( vizeNotu * 0.4 + finalNotu * 0.6 );
        
        // Static olan bir metodu Sınıf üzerinden erişerek metod referansı olarak verebiliriz.
        // Ogrenci ogrenci = Okul::hesaplaStatic;
        
        // Static olmayan bir metodu nesne üzerinden erişerek referans verebiliriz.
        Okul okul = new Okul();
        Ogrenci ogrenci = okul::hesapla;
        
        Double not = ogrenci.notHesapla(40,50);
        System.out.println("Notunuz : " + not);      
    }
    
    // Static method
    public static Double hesaplaStatic(Double vizeNotu,Double finalNotu){
        return vizeNotu * 0.4 + finalNotu * 0.6;
    }
    
    // Non-static method
    public Double hesapla(Double vizeNotu,Double finalNotu){
        return vizeNotu * 0.4 + finalNotu * 0.6;
    }
    
}    

Okul.java · GitHub Gist


Yazımı burada sonlandırıyorum. Bir sonraki bölümde java.util.function paketinin altında bulunan Yardımcı Fonksiyonel Arayüzler‘den bahsedeceğim. Elimden geldiğince anladığım kadarıyla bildiklerimi paylaşmaya çalıştım. Umarım işinize yarar. ⭐

Kaynaklar

  1. http://devnot.com/2017/java-8-hakkinda-bilmeniz-gerekenler/
  2. https://www.mobilhanem.com/java-8-lambda-ifadeleri/
  3. https://kodedu.com/java-8-ebook/
  4. http://www.javadunyasi.com/java-lambda-nedir-nasil-kullanilir/
  5. https://winterbe.com/posts/2014/03/16/java-8-tutorial/
  6. https://www.youtube.com/watch?v=oQCVaA11BLE
  7. https://kodedu.com/2014/03/java-8-lambda-expression-nedir-nasil-kullanirim/