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 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.
- 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();
}
}
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);
}
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);
}
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);
}
}
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);
}
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;
}
}
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
- http://devnot.com/2017/java-8-hakkinda-bilmeniz-gerekenler/
- https://www.mobilhanem.com/java-8-lambda-ifadeleri/
- https://kodedu.com/java-8-ebook/
- http://www.javadunyasi.com/java-lambda-nedir-nasil-kullanilir/
- https://winterbe.com/posts/2014/03/16/java-8-tutorial/
- https://www.youtube.com/watch?v=oQCVaA11BLE
- https://kodedu.com/2014/03/java-8-lambda-expression-nedir-nasil-kullanirim/
