Java Serialization nedir

Merhaba arkadaşlar. Bu yazımda Java Serialization (Serileştirme) konusuna değineceğim.

Bir klişe olacak ama Java bilindiği üzerine nesneye yönelik bir dil. Primitive tipler (int, char, boolean … gibi) hariç neredeyse herşey nesne ve bu nesneleri sürekli ve sürekli kullanırız. Ancak nesneleri bazen JVM dışında kullanmak gerekebiliyor. Fakat dışarıda kullandığımız bir nesnemizi tekrar içeride kullanmak istediğimizde nesne içinde kullanılan değerlerin hangi tipte olduğunu öğrenemiyoruz. Yani herhangi bir sınıftan bir nesne üretip, bunu bir dosyaya yazdırıp onu tekrar dosyadan okuğumuzda değerlerin tip bilgisini bilememe problemimiz var. İşte tam bu durumda Java Serialization API yardımımıza koşuyor.

Bu durumu basit bir örnekle anlatarak durumun daha iyi pekişeceğine inanıyorum.

Araba bilgilerini tutan Car diye bir sınıfımız olsun ve bu bilgileri bir dosyaya kaydedip, tekrar okuma işlemi yapalım.

Serileştirme işlemi için Serializable arayüzünü implement etmek gerekiyor.

Araba sınıfımız :

import java.io.Serializable;

public class Car implements Serializable {
    private String brand;
    private String model;

    Car(final String brand, final String model) {
        this.brand = brand;
        this.model = model;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(final String brand) {
        this.brand = brand;
    }

    public String getModel() {
        return model;
    }

    public void setModel(final String model) {
        this.model = model;
    }
}

 

Nesnemizi dosyaya yazdırdığımız test sınıfımız :

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Main {
    public static void main(final String[] args) {
        write();
    }
    private static void write(){
        try{
            final Car car = new Car("Seat", "Leon");
            final FileOutputStream file = new FileOutputStream("/Users/okan/Documents/car.txt");
            final ObjectOutputStream write = new ObjectOutputStream(file);
            write.writeObject(car);
            write.close();
        }
        catch(final Exception e){
            System.out.println(e.getMessage());
        }
    }
}

 

Nesnemizi dosyaya yazdığımız zaman dosyamızın çıktısı şu şekilde.

¨ÌsrCarÇ«5xÕçLbrandtLjava/lang/String;Lmodelq~xptSeattLeon

 

Şimdi gelin bu nesneyi dosyadan tekrar okuyalım.

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Main {
    public static void main(final String[] args) {
        read();
    }

    private static void read() {
        try {
            final FileInputStream file = new FileInputStream("/Users/okan/Documents/car.txt");
            final ObjectInputStream read = new ObjectInputStream(file);
            final Car car = (Car) read.readObject();
            System.out.println(car.toString());
            read.close();
        }
        catch (final Exception e) {
            System.out.println(e.getMessage());
        }
    }

}

 

Çıktımız :

Marka : Seat
Model : Leon

 

Görüldüğü gibi dosyaya yazdırdığımız nesneyi tekrar okuyup, başarılı bir şekilde konsolumuza yazdırabildik.

Bir dahaki yazımda görüşmek üzere, hoşçakalın.

REST mimarisi ve RESTful servisleri nedir

Merhaba arkadaşlar, bu yazımda özellikle web uygulamalarımızda oldukça sık kullandığımız REST (Representational State Transfer) mimarisinden bahsetmek istiyorum.

REST mimamisi HTTP üzerinde çalışan bir yapıya sahiptir. Diğer mimarilere göre daha basit ve hızlı olduğunu söyleyebiliriz. Sunucu ve istemci arasında verileri JSON yada XML formatında taşıyarak uygulamaların birbirleriyle haberleşebilmelerini sağlar. REST mimarisi ile uyumlu olan servislere RESTful servisler denmektedir.

REST mimarisi stateless olup, herhangi bir durum bilgisi saklamaz. Dolayısıyla istemci-sunucu arasında taşınan verilerde istemciye ait herhangi bir veri bulunmaz.

REST mimarisini diğer bir popüler olan SOAP mimarisiyle karşılaştırırsak şunları rahatlıkla söyleyebiliriz.

  • SOAP servisleri RPC (Remote Process Call) yöntemini kullanır. Güvenlik protokollerini içinde barındırır, state bilgisini request ve response larda tutar. Fakat bu durum REST mimarisinde daha farklıdır. RESTful servislere direkt bir URL üzerinden erişilir. Arada herhangi bir güvenlik protokolü, bileşen vs… yoktur.
  • SOAP olan bir servisi kullanabilmeniz için servisin WSDL bilgisine ihtiyaç duyarsınız. Proxy sınıfları ve bileşenler gerekmektedir. Kısaca bir istemci SOAP ile ilgili neredeyse tüm detayları bilmek zorundadır. Aksi halde bu servisi istemcinin kullanması mümkün değildir. REST mimarisinde ise herhangi bir servisi çağırmak için sadece URL bilgisini bilmeniz yeterlidir. Kısaca bir istemcinin REST mimarisine ait bir servisin yapısını ve detaylarını bilmesine gerek yoktur. Son derece esnek bir yapıya sahiptir.

RESTful servisleri üzerinden CRUD (Create, Read, Update, Delete) işlemlerinin gerçekleştirilebilmesi için HTTP metotları kullanılır. Popüler olan HTTP metotları şunlardır;

  • GET (okuma işlemleri için)
  • POST (kayıt ekleme işlemleri için)
  • PUT (güncelleme işlemleri için)
  • DELETE (silme işlemleri için)

REST mimarisinin basit yapısı, kolay uygulanabilmesi, hızlı çalışması gibi olumlu özellikleri olsa da önemli bir dezavantajı vardır. Bunlardan biri güvenlikle ilgilidir. SOAP REST mimarisine göre güvenlik konusunda kendi standartları gereği daha avantajlıdır. Fakat REST mimarisinde güvenlik konusu işin geri kalan kısmıdır.

Bir dahaki yazımda görüşmek üzere, sevgiyle…

 

 

Java Optional Sınıfı

Merhaba arkadaşlar. Bu yazımda Java 8 ile birlikte hayatımıza giren en önemli özelliklerden biri olan Optional sınıfını anlatmak istiyorum.

Bu sınıf; null referanslar yerine isteğe bağlı değerleri göstermek için iyi bir çözüm sunmaktadır.

Optional sınıfı java.util paketine aittir.

import java.util.Optional;

Şimdi basitçe bir optional nesnesi nasıl oluşturulur ona bakalım.

Optional empty = Optional.empty();

Yukarıda gördüğünüz üzere basitçe Optional sınıfının empty() metodunu kullanarak boş bir Optional nesnesi oluşturmuş olduk.

Bir Optional nesnesi üzerinde herhangi bir değer olup, olmadığını nasıl kontrol ediyoruz ona bakalım.

empty.isPresent()

Yukarıdaki blokta olduğu gibi isPresent() metodunu kullanarak herhangi bir Optional nesnesi üzerinde bir değer olup, olmadığını kontrol edebiliriz. Sonuç olarak üzerinde henüz herhangi bir değer olmadığı için bize false dönecektir.

Ayrıca Optional tipinde olmayan bir nesneyi Optional tipine çevirebilmemiz mümkün.

String name = "The Coders";
Optional<String> var = Optional.of(name);

Fakat bazı durumlarda null olan nesnelere de bu işlemi uygulayabilmemiz gerekiyor. Bunun için Optional.ofNullable() metodunu kullanabiliriz. Aksi halde NullPointerException hatasıyla karşılaşabiliriz.

String name = null;
Optional<String> var = Optional.ofNullable(name);

Optional sınıfının en önemli özelliklerinden biri de ifPresent metodudur. Bu metod; Optional nesnesinin üzerinde herhangi bir değer tutulduğu zaman istenilen işlemlerin yapılmasına olanak sağlar.

String name = "The Coders";
Optional<String> var = Optional.ofNullable(name);
var.ifPresent(v -> System.out::println);

Bazen Optional nesnesi üzerinde herhangi bir değerin tutulup, tutulmadığının kontrolü yapılırken tutulmadığı durumdaki senaryoları tasarlayabilmemiz gerekiyor. Bunun için Optional sınıfının bize sunduğu çözümlere bakalım. Bunlar; orElse(), orElseGet(), orElseThrow()

orElse() kullanımı

Eğer Optional nesnesi üzerinde herhangi bir değer tanımlı değilse bu durumda istediğimiz değeri dönebiliriz.

String name = null;
Optional<String> optionalName = Optional.ofNullable(name);
String result = optionalName.orElse("The Coders");

orElseGet() kullanımı

orElseGet(); orElse() metoduna benzerdir. Eğer Optional nesnesi üzerinde herhangi bir değer tanımlı değilse bu durumda istediğimiz değeri orElse() deki gibi direk dönmek yerine functional interface kullanabiliriz.

String name = null;
Optional<String> optionalName = Optional.ofNullable(name);
String result = optionalName.orElseGet(() -> "The Coders");

orElseThrow() kullanımı

Eğer Optional nesnesi üzerinde herhangi bir değer tanımlı değilse bu durumda hata fırlatabiliriz.

String name = null; 
Optional<String> optionalName = Optional.ofNullable(name); 
String result = optionalName.orElseThrow(IllegalArgumentException::new);

Optional nesnesi içindeki değeri almak için kullanılan diğer bir yöntem ise get() metodudur.

Optional<String> optionalName = Optional.ofNullable("The Coders");
String name = optionalName.get();

Fakat bu yöntemin bir dezavantajı vardır. Eğer Optional nesnesi üzerinde herhangi bir değer yoksa ve direkt olarak get() metodunu kullanırsak NoSuchElementException() hatasını alırız.

Bir dahaki yazımda görüşmek üzere, hoşçakalın.

Dependency Injection Nedir

Merhaba arkadaşlar. Bu yazımda size DI (Dependency Injection) kavramından kısaca en basit haliyle bahsetmek istiyorum.

DI (Dependency Injection), IoC (Inversion of Control)’un en önemli implementasyonlarından biridir. Peki IoC (Inversion of Control) neydi, bunu bir hatırlayalım. IoC (Inversion of Control); uygulamamızda nesne oluşturma işinin geliştiriciden alınarak ilgili çatının sorumluluğuna devredilmisidir.

SOLID prensiplerindeki son harfi temsil etmektedir.

Uygulama katmanımızda bir A sınıfı olsun ve bu A sınıfımızın bir üyesi başka bir sınıf olan B sınıfına ait olsun. Bu ilişkiyi A sınıfımızın içinde new operatörü ile yaptığımızı düşünelim. Böylece A sınıfımız, B sınıfımızın özelliklerine ve davranışlarına daha ortada hiçbirşey yokken bağlı hale getirmiş olduk. Peki bu istenilen bir durum mu, tabiki hayır. İşte DI (Dependency Injection) kavramı burada devreye giriyor. Bu prensip sayesinde nesne atamalarını çatımızın sorumluluğuna bırakıyoruz ve bunu bizim yerimize sadece gerektiği durumlarda atamaları gerçekleştirerek dinamik hale getiriyor. Bunu başka bir cümleyle açıklamak gerekirse; uygulamamızın çalışırken o an kullanması gereken nesneler çatı tarafından enjekte edilecektir. Böylece sonraki süreçlerde herhangi bir düzenleme yada değişiklik olması durumunda sadece belirli kısımların değiştirilmesi yeterli olacaktır.

Şimdi bu prensibi artılarıyla ve eksileriyle beraber değenlendirelim.

Artıları

  • Uygulamamızı oluşturan yapılan birbirleri ile bağımlılıkları azaldığı için uygulamamızda değişiklik yapmak daha kolay hale gelmesi. (Bunu loosely coupled olarak da tanımlıyabiliriz.)
  •  Çok rahat bir şekilde Unit testler yazmamızı sağlayabilmesi. İstediğimiz sınıfı rahatlıkla mock edip, kolayca test edebilmemiz.

Eksileri

  • Oluşturduğumuz sınıf sayısının fazla olması
  • Gereksiz interface lerin fazlalığı

Bir sonraki yazımda görüşmek üzere, hoşçakalın.

Builder Design Pattern

Merhaba arkadaşlar. Bu yazımda oldukça popüler ve işlevi büyük olan bir tasarım deseninden bahsetmek istiyorum.

Bu tasarım desenimizin ismi Builder ve Creational grubuna ait. Yapı olarak Abstract Factory desenine benzerlikleri vardır.

Bazen projelerimizde nesnelerimize ait birçok özellik olabilir ve bu nesnelerimizi farklı özellik/parametre ler ile oluşturmak isteriz. Dolayısıyla bazen çalıştığımız sınıflar içerisinde çok fazla parametre alan metodlar ve yapılandırıcılar kullanabiliyoruz. Bu kullanılabilirliği ve okunabilirliği oldukça zorlaştıran bir durum. Bazen aynı methodu çok fazla kez overload edip, kendimize iş yükü doğurabiliyoruz. İşte bu kısımda yardımımıza builder design pattern yetişiyor.

Şimdi gelin, bu tasarım deseniyle alakalı basit bir örnek yapalım.

Nesne sınıfımız :

public class Computer {
    private String brand;
    private String price;
    private String cpu;
    private String ram;

    public Computer(final String brand, final String price, final String cpu, final String ram) {
        this.brand = brand;
        this.price = price;
        this.cpu = cpu;
        this.ram = ram;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(final String brand) {
        this.brand = brand;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(final String price) {
        this.price = price;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(final String cpu) {
        this.cpu = cpu;
    }

    public String getRam() {
        return ram;
    }

    public void setRam(final String ram) {
        this.ram = ram;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "brand=" + brand +
                ", cpu=" + cpu +
                ", ram=" + ram +
                ", price=" + price +
                '}';
    }
}

Builder sınıfımız :

public class ComputerBuilder {
    private String brand;
    private String price;
    private String cpu;
    private String ram;

    public ComputerBuilder setBrand(final String brand) {
        this.brand = brand;
        return this;
    }

    public ComputerBuilder setPrice(final String price) {
        this.price = price;
        return this;
    }

    public ComputerBuilder setCpu(final String cpu) {
        this.cpu = cpu;
        return this;
    }

    public ComputerBuilder setRam(final String ram) {
        this.ram = ram;
        return this;
    }

    public Computer buildComputer() {
        return new Computer(brand, price, cpu, ram);
    }
}

Test sınıfımız :

public class MainClass {
    public static void main(String[] args) {
        final ComputerBuilder computerBuilder = new ComputerBuilder();

        final Computer computer1 = computerBuilder
                .setBrand("ASUS")
                .setCpu("2,40 GHZ")
                .setPrice("1500 $")
                .setRam("8 GB")
                .buildComputer();

        System.out.println(computer1);

        final Computer computer2 = computerBuilder
                .setBrand("APPLE")
                .setCpu("2,60 GHZ")
                .setPrice("3500 $")
                .setRam("16 GB")
                .buildComputer();

        System.out.println(computer2);
    }
}

Bir sonraki yazımda görüşmek üzere, hoşçakalın 🙂

Java instanceof kullanımı

Merhaba arkadaşlar. Bu yazımda Java projelerimizde sık bir şekilde kullandığımız instanceof operatöründen bahsedeceğim.

Java instanceof operatörü herhangi bir nesnenin belirtilen türe ait olup, olmadığını öğrenmek için kullanılır. Bu operatör aynı zamanda tip karşılaştırmak için de kullanıdır ve Boolean tipinde true yada false değerini döner. Bu operatör null bir değişkene uygulandığında false değerini dönmekle yükümlüdür.

Şimdi basit bir örnek yapalım.

public class MainClass {
    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car instanceof Car);
    }
}
Output : true

Yukarıda kod bloğunda gördüğünüz üzere Car sınıfından bir nesne yarattık ve bu nesnenin Car sınıfına ait olup, olmadığını ekrana yazdırdık ve sonuç olarak bize true değerini döndürdü.

Alt sınıf nesnesinin türü de aynı zamanda bağlı olduğu üst sınıfının türüyle aynıdır. Yani Car sınıfımızın bir alt sınıfı olarak Opel sınıfı olsun. Opel sınıfından bir nesne yaratıp, bu nesnenin Car sınıfına ait olup olmadığını sorgularsak sonuç olarak bize true dönecektir.

Şimdi bunla ilgili bir örnek yapalım.

public class Opel extends Car {
}
public class MainClass {
    public static void main(String[] args) {
        Opel opel = new Opel();
        System.out.println(opel instanceof Car);
    }
}
Output : true

Yazının başında da bahsettiğim gibi instanceof operatörünü null bir değişkene uygularsak sonuç olarak bize false döner.

public class MainClass {
    public static void main(String[] args) {
        Opel opel = null;
        System.out.println(opel instanceof Opel);
    }
}
Output : false

Bir dahaki yazıda görüşmek üzere, hoşçakalın 🙂 ..

Isolation Level nedir

Merhaba arkadaşlar. Bu yazıda size kısaca çoğu kişinin merak ettiği veri tabanı sistemlerinde kullanılan izolasyon seviyelerinden bahsedeceğim.

Bildiğiniz üzere bir veri tabanında tutarlığı korumak için dört farklı özellik bulunmaktadır. Bunlar; atomicity, consistency, isolation ve durability (Kısaca ACID diye söylenebilir). Biz burada isolation (izolasyon) kısmıyla ilgileneceğiz. İzolasyon bir işlem bütünlüğünün diğer kullanıcı ve sistemlere nasıl göründüğünü ifade eder. İzolasyon seviyesi veri tabanındaki bir işlemin başka işlemlerden nasıl izole edilmesi gerektiğini tanımlar. Kullanılacak olan izolasyon seviyesi aşağıdaki olaylar düşünülerek ve kullanılacak sistemin ihtiyaçlarına göre belirlenebilir.

Dirty Read : Adından da anlaşılacağı gibi kirli bir okumadır. Bir işlemin henüz işlenmemiş bir veriyi okuduğu durumdur. Örnek olarak elimizde T1 ve T2 diye iki işlemimiz olsun. T1 herhangi bir satırı güncelliyor fakat değişikliği onaylamadan işini bırakıyor. Bu arada T2 bu güncellenmiş veriyi okuyabiliyor. Eğer T1 bu işlemi geri alırsa T2 var olmamış veriyi okumaya devam edecektir.

Non-Repeatable Read : Yine elimizde T1 ve T2 diye iki işlemimiz olduğunu varsayalım. Örneğin T1 in bir veriyi okuduğunu varsayalım. Eş zamanlı olarak T2 de bu veriyi güncellemiş olsun. Şimdi T1 aynı verileri tekrar alırsa farklı bir değer okumuş olur.

Şimdi izolasyon seviyelerinden bahsedelim. Bilindiği üzere temelde dört adet izolasyon seviyesi bulunmaktadır.

Read Uncommitted : Read Uncommitted en düşük izolasyon seviyesidir. Adından da anlaşılacağı gibi bu seviyede bir işlem başka bir işlemin henüz onaylamadığı değişiklikleri okuyabilir. Bu sayede yukarıda bahsettiğimiz Dirty Read olayına izin verilmiş olur.

Read Committed : Bu izolasyon seviyesi okunan herhangi bir verinin okunduğunda verinin önceden işlendiğini garanti eder. Böylece Dirty Read e izin vermez.

Repeatable Read : En kısıtlayıcı izolasyon seviyesidir. Bu seviyede herhangi bir işlem referans aldığı tüm satırlarda okuma kilitlerini tutar. Diğer işlemler bu satırları okuyamayacağından, güncelleyemediğinden veya silemediğinden, böylece Non-Repeatable Read ı önlemiş olur.

Serializable : Bu en yüksek izolasyon seviyesidir. Seri hale getirilebilir bir yürütmenin serileştirilmesi garanti edilir.

 

Bu izolasyonların seviyeleri için şu en iyisidir veya şu en kötüsüdür diye bir yorumda bulunamayız. Hangisinin bizim için iyi veya kötü olduğu var olan uygulamamızın ihtiyaçlarına göre değişebilir.

Bir dahaki yazıda görüşmek üzere, hoşçakalın 🙂

Singleton Design Pattern

Merhaba arkadaşlar.

Uzun bir süre yazmıyordum, aranıza tekrar döndüğüm için ve uzun bir zaman sonra tekrar yazdığım için mutluyum açıkcası. Bugün size singleton design pattern hakkında biraz bahsetmek istiyorum.

Singleton design pattern creational design pattern ailesine ait olan bir tasarım desenidir. Bu tasarım deseninin kullanım amacı bazı durumlarda bir sınıftan birden fazla nesne oluşturulmasına gerek yoktur. Örneğin; uygulama katmanımızın veri tabanına bağlantısını yöneten sınıftan birden fazla nesne oluşturmaya gerek yoktur. Her çağıran için bu sınıftan ayrı ayrı nesne oluşturmak uygulama verimliliğini düşürecektir. İşte singleton deseni bize bu konuda yardımcı oluyor. Bu desen ile ilgili sınıftan birden fazla nesne oluşturulmasının önüne geçmiş oluruz.

Bir sınıfı singleton prensibine uyarlamak için yapılandırıcısının erişim belirtecini private yapmamız yeterlidir.

Örnek Java kodu :

public class SingletonObject {

    private static SingletonObject singletonObject = null;

    private SingletonObject(){
        //
    }

    public static SingletonObject getInstance(){
        if (singletonObject == null){
            singletonObject = new SingletonObject();
        }
        return singletonObject;
    }
}

public class MainClass {
    public static void main(String[] args) {
        
        SingletonObject instance = SingletonObject.getInstance();

        //SingletonObject instance1 = new SingletonObject(); Hatalı Kullanım
    }
}

Bir dahaki yazıda görüşmek üzere, sevgiyle kalın.

Java – Throw ve Throws Kavramları

Merhaba arkadaşlar. Bu yazımda Java’da kullanılan throw ve throws kavramlarını ele alacağım.

Throw Kavramı

Yazdığımız Java programında açıkca throw ifadesini kullanarak bir istisna fırlatmak mümkündür. throw ifadesinin genel formu aşağıdaki gibidir.

throw FırlatılabilirNesne;

Burada FirlatilabilirNesne, Throwable veya onun herhangi bir alt sınıfı tipinde bir nesne olmak zorundadır. Throwable olmayan String, Object, Int, Char.. gibi tipler istisna olarak kullanılamaz. Throwable bir nesne elde etmenin iki yolu vardır. Birinci yolu catch cümleciği içinde parametre olarak kullanılabilir ya da new operatörü ile yeni bir nesne oluşturabilirsiniz.

Programın işleyişi throw ifadesinden hemen sonra durur ve sonra hiçbir ifade çalıştırılamaz. Kapsayan en yakın try bloğunda istisna tipiyle eşleşen bir catch cümleciği aranır. Bulunmaz ise sıradaki kapsayan try bloğu denetlenir. Denetleme try bloklarının sonuna kadar devam eder. Eğer istisna tipiyle eşleşen bir catch bulunamazsa program durur.

Şimdi bir istisna oluşturan ve bunu fırlatan basit bir örneği inceleyelim.

Ekran Alıntısı

Bu program aynı hatayı yakalamak için iki şansa sahiptir. Birincisi main() metodunun içinde çağırılan olustur_firlat metodunun try bloğunda hata oluşturulur ve catch bloğunda yakalanır. İkincisi main() metodunun içindeki catch bloğudur. Örnek kodumuzda kullanılan new kelimesini hata nesnesi oluşturmak için kullanırız.

Throws Kavramı

Eğer bir metot yakalayamadığı bir istisnaya neden olursa, metodu çağıranların kendilerini istisnaya karşı koruyabilmeleri için çağıran metodun bu davranışı belirtmesi gerekir. Bunu metodun bildirimine bir throws ifadesi ekleyerek yapabilirsiniz. throws ifadesi bir metodun fırlatabileceği istisna tiplerini belirtir. Eğer belirtilmez ise derleme zamanı hatası alınır.

throws ifadesinin genel formu aşağıdaki gibidir.

tip metot_adi (parametreler) throws istisna_listesi {

//metot gövdesi

}

Burada istisna_listesi metodun fırlatabileceği istisna tiplerinin virgülle ayrılmış halidir.

Aşağıdaki örnek kodumuza bakalım.

Ekran Alıntısı

Kodda gördüğünüz IllegalAccessException ifadesi metodumuzun fırlatabileceği hatanın tipidir. Bunu yazmazsak derleme hatası alırız. throwOne() metodunun içinde yeni bir hata nesnesi yaratılıp, fırlatılmıştır. Fırlatılan bu hata main() metodumuzun catch bloğunda yakalanmaktadır. Bu şekilde hata potansiyeline sahip metotlarımızın hata bildirimini yaparak bu metotları çağıran programların herhangi bir çalışma hatasıyla karşılaşmadan işleyişine devam etmesini sağlayabiliriz.

Bir daha ki yazımda görüşmek üzere..

 

Java This Anahtar Kelimesi

Merhaba arkadaşlar. Bu yazımda nesneye yönelik programlama dillerinde özellikle Java’da sıkça kullandığımız this ifadesinden bahsedeceğim.

Basitçe söylemek gerekirse this ifadesi o anda hangi nesne üzerinde işlemler yapılıyorsa o nesnenin ifadesini döndürür.

This ifadesinin bir kaç kullanımından bahsedelim.

Bu ifade genellikle değişken ismi çakışmalarını önlemek için kullanılabilir. Bu durum aslında this ifadesinin en çok kullanıldığı durumlardan birisidir. Çakışma olayını biraz açarsak; bir yapıcı metoda(constructor) gönderdiğimiz parametrelerin ismi sınıf değişkenleriyle aynı ise this kullanarak bu karışıklılığı önleyebiliriz.

Aşağıdaki örneğe bakalım.

Ekran AlıntısıEkran Alıntısı1

Yukarıdaki örnek kodda gördüğünüz üzere, ana sınıfımızda Ayşe Yılmaz diye bir öğrenci nesnesi oluşturduk ve bu nesneyi oluşturduğumuz ilk anda Ogrenci sınıfının yapıcı metodu çalışacaktır. Yapıcı metot isim ve soyisim adında iki parametre kullanmaktadır. Bir de yapıcı metodumuz dışındaki isim ve soyisim değişkenlerini görmektesiniz. Yapıcı metodun kullandığı parametrelerle bu değişkenlerin isminin aynı olduğuna aldanmayın aslında farklıdır. Yapıcı metottaki parametreler aslında bir iletim görevi görür bu parametreler ana sınıfımızdan gelen Ayşe ve Yılmaz kelimelerini yapıcı metoda iletmektedir. Ogrenci sınıfı değişkenleri olan isim ve soyisim ise bu parametrelerle gönderilen verileri tutmakla görevlidir. İşte tam burada this ifadesini kullanarak bu çakışmayı giderebiliriz. this.isim sınıf değişkeni olan isim değişkenini işaret ederken isim ifadesi yapıcı metoda gönderilen parametreyi temsil etmektedir.

this anahtar kelimesini kullanarak aynı sınıf içindeki diğer yapıcı metodları da çağırabilmemiz mümkün.

Aşağıdaki örneğe bakalım.

Ekran Alıntısı3Ekran Alıntısı5

Yukarıdaki örnek kodlarda gördüğünüz üzere bu seferde Mustafa Işık diye bir öğrenci nesnesi yarattık. Nesneyi yarattığımız anda ilk olarak iki parametre alan yapıcı metodumuz çalışacaktır. Bu yapıcı metodun içinden de this (isim, soyisim, 181) ifadesi ile diğer yapıcı metodumuz çalışacaktır. Böylece öğrencimizin isim ve soy ismine ek olarak numarasını da yapılandırabiliriz. Kısacası this ifadesinin bu kullanımı bir yapıcı metodun içinden başka bir yapıcı metoda göndermede bulunmaktır.

this anahtar kelimesinin diğer bir kullanımı da tek başına nesnelerin referansını temsil edebilmesidir.

Aşağıdaki örneğe bakalım

Ekran Alıntısı Ekran Alıntısı1

Yukarıda örnek kodlarda gördüğünüz üzere iki tane öğrenci nesnesi ve ogr_liste adında öğrencilerin tutulacağı bir ArrayList oluşturulmuştur. Ogrenci sınıfımızda da bu nesnelerimizi listemize eklemeye yarayan ekle metodu bulunmaktadır. Bu metodumuza gönderdiğimiz parametre öğrencilerin tutulduğu listedir ve metodun gövdesinde bulunan this ifadesi de metodun hangi öğrenci nesnesi üzerinden çağrıldığını belirtir. Yani ana sınıfımızda o1.ekle() ifadesi ile Mustafa Işık’ı temsil eden öğrenci nesnesi ekle metodu ile öğrenci listesine eklenir. Ekle metodunun içindeki this ifadesi aslında bu nesneyi temsil etmektedir.

Şunu da hatırlatmakta fayda var this ifadelerini statik metotlarımız içinde kullanamayız çünkü statik metotlar sınıf metotlarıdır. Bu metotlar nesnelerle ilgilenmez.

Bir sonraki yazımda görüşmek dileğiyle. İyi çalışmalar..