|
Yoksa sonuna mı geldim? Olurmu hiç öyle şey canım, daha dünya kadar yolum var. Kaynaklarımdan Java dilini öğrenmeye çalışırken, final anahtar sözcüğünden bahseden yerlere rastladığımda, java dilini daha başlarda bitirmek isteyeceklerini düşünmemiştim zaten. çoğu kaynakta araya sıkıştırılmıştı bu kavram ancak sağladıkları ile bence öğrenilmesi gereken niteliklerden birisiydi.
Herşeyden önce mükemmelliğin ayrıntılarda gizli olduğunu biliyordum. Gerçektende çoğu kaynak final kavramına sadece yorum satırları ile değinmiş olsada, içerik açısından ayrıca incelenmeyi gerektiriyordu. Aslında buna değerdide. Söz gelimi, geçen hafta üzerinde çalıştığım kalıtım konusuna kattığı bir özellik vardı. Eğer kaynaklarımda bu kavrama rastlamamış olsaydım, bu kabiliyeti bilemiyecek ve karşılaştığımda bu nedir diyerek sağa sola bakacaktım.
O nedenle bu hafta boyunca, final anahtar sözcüğünün Java diline sağladıkların incelemeye çalıştım. Herşeyden önce işe, kalıtım ile başlamam gerektiğini düşünüyordum. final anahtar kelimesinin kullanılabildiği alanlardan bir tanesi metodlardı. Ancak sadece metodlara değil, değişkenlere, sınıf örneklerine ve sınıflarada uygulanabiliyordu. Bunlarla birlikte kalıtım söz konusu olduğunda final metodlardan bahsetmeden geçilemiyeceğini bu haftaki çalışmalarımdan anlamıştım. İşe öncelike final kelimesinin, metodlara kattığı anlamı tanımlamakla başlamak gerekir diye düşünüyorum.
Bir final metod, Temel sınıfta uygulandığında, türetilen sınıflarda iptal edilemeyen metodları belirtir. Yani override işleminden bahsetmek mümkün değildir. Bu etkiyi ispat etmek için her zaman olduğu gibi kahvemden bir yudum aldım ve bir çırpıda aşağıdaki kodları yazıverdim. Tek amacım, final metodların türeyen sınıflarda yeniden yazılıp geçersiz kılınıp kılınamıyacağıydı.
class Temel
{
final void Yaz()
{
System.out.println("Temel sınıf Yaz Metodu");
}
}
class Tureyen extends Temel
{
public void Yaz()
{
System.out.println("Tureyen sınıf Yaz Metodu");
}
}
public class FinalDeneme
{
public static void main()
{
Tureyen t=new Tureyen();
t.Yaz();
}
} |
Uygulamayı derlediğimde, aşağıdaki derleme zamanı hata mesajı ile karşılaştım.
Her şey sonderece açıktı. Gerçektende temel sınıflarda final olarak tanımlanan metodlar, türeyen sınıflarda override edilemiyorlardı. Final anahtar kelimesinin kabiliyetleri sadece metodlara yaptırdıkları ile sınırlı değildi. örneğin final alanlar vardı. Değişkenleri final olarak bildirdiğimizde, onlara ilk değerlerin atanmasından sonra, değerlerini değiştiremiyorduk. Bu aslında C# dilinde constant değişkenlerden farklı değildi. Yani uygulamada değeri bir kere atandıktan sonra değişmesini istemediğimiz değişkenler için kullanıyorduk.
Final olarak belirlenen değişkenler ile ilgili ilginç olan nokta, değer atamalarının çalışma zamanında (runtime) veya derleme zamanında (debug time) yapılabilmesiydi. Yani istersem, final bir değişkene ilk değer atamasını çalışma zamanında gerçekleştirebilirdim. Ancak çalışma zamanına kadar değeri belli olmayan bir değişken nasıl olabilirdi diyede düşünmeye başlamıştım. Tam o sırada imdadıma Math sınıfının rastgele sayılar üretmekte kullanılan, random metodu yetişti. Bu metod çalışma zamanında, rastgele sayılar üretebilirdi. Dolayısıyla rastgele üretilen bir değeri, programın çalışması boyunca sabit bir değer olarak saklamak için final anahtar kelimesi kullanılabilirdim. Bu bilgiler ışığında, konuyu daha iyi kavrayabilmek için, hemen basit bir örnek geliştirmeye karar verdim.
public class FinalAlanlar
{
final static double deger2;
public static void main(String[] args)
{
final int deger1=7;
deger2=0.125;
final int deger3=(int)(Math.random()*10);
Yaz(deger1,deger2,deger3);
deger2=100;
deger1=8;
deger3=(int)(Math.random()*5);
Yaz(deger1,deger2,deger3);
}
static void Yaz(int a,double b,int c)
{
System.out.println("Deger1="+a);
System.out.println("Deger2="+b);
System.out.println("Deger3="+c);
}
} |
Uygulamada yapmak istediğim, final olarak belirlenmiş alanların değerlerini değiştirip değiştiremiyeceğimdi. Bu haliyle çalışan uygulama bana 4 adet derleme zamanı hatası verdi.
İlk göze çarpan, deger2, deger1 ve deger3 değişkenlerine yeni değerlerin final değişkenler oldukları için atanamıyacağıydı. Diğer taraftan dikkatimi çeken bir başka nokta, ilk değer ataması yapmadığım deger2 değişkeni içinde, sonradan yaptığım ilk değer atamasında hata almamdı. Buradan, final olarak tanımlanan değişkenlere tanımlandıkları anda değer atanması gerektiği sonucuna varıyordum. Ama gerçekten durum böylemiydi? öncelikle koddaki hataların sayısın indirgemem gerektiğini düşünerek harekete geçtim. Bir yudum sıcak kahve ve ardından aşağıdaki kodları uygulamadan çıkardım.
deger2=100;
deger1=8;
deger3=(int)(Math.random()*5);
Yaz(deger1,deger2,deger3); |
Şimdi uygulamayı yeniden derlediğimde, hata sayısının bire düştüğünü ama deger2 için yapılan atamada halen hata aldığımı gördüm.
O halde yapılacak tek bir şey vardı, deger2 nin değerini tanımlandığı satırda belirlemek. Kodları son olarak aşağıdaki hale getirdiğimde herhangibir hata mesajı almadan çalıştığını gördüm. Gerçektende final olarak belirlenmiş alanlar programın çalışması esnasında değiştirilemiyorlardı.
public class FinalAlanlar
{
final static double deger2=0.125;
public static void Main(String[] args)
{
final int deger1=7;
// deger2=0.125;
final int deger3=(int)(Math.random()*10);
Yaz(deger1,deger2,deger3);
}
static void Yaz(int a,int b,int c)
{
System.out.println("Deger1="+a);
System.out.println("Deger2="+b);
System.out.println("Deger3="+c);
}
} |
Diğer taraftan aklıma takılan bir nokta vardı. Final olarak belirtilmemiş bir alana ilk değer atamadığımızda java derleyicisi bu değişkenin türüne göre bir ilk değer ataması yapıyordu. örneğin uygulamada double tipinden bir değişken tanımlayıp buna ilk değer ataması yapmassak derleyici bizim için bu değişkene başlangıç değeri olarak 0.0 değerini atıyordu. Oysa değişkeni final olarak belirttiğimizde, derleyici bizim için varsayılan bir değer atamsı yapmamakta, üstüne üstelik birde hata mesajı vermekteydi. Bunu görmek için uygulamaya deger4 isminde double veri türünde bir değişken ekledim. Ancak herhanbiri değer atamadım.
Daha sonra, bu degeri ekrana yazdırdığımda derleyicinin 0.0 değerini atadığını gördüm. Ancak, bu değişkeni final olarak belirttiğimde,
| final static double deger4; |
ve programı derlediğimde aşağıdaki hata mesajını aldım.
Elde edilen bu hata mesajı bana, final olarak tanımladığım değişkenlere mutlaka ilk değer ataması yapmam gerektiğini ve hatta bu atamayı değişkenleri tanımladığım yerde yapmam gerektiğini gösterdi.
Final anahtar kelimesinin değişkenlerce kullanılması bu şekildeyken, pandora’nın kutusu açılmaya devam ediyor ve içinden sınıf nesne örnekleri çıkıyordu. Final anahtar kelimesini , nesne örneklerinede uygulayabilir ve böylece bu nesnelerin programın çalışması boyunca sadece bir kez yaratılmasını sağlayabilirdik. Bu durumu araştırmak amacıyla aşağıdaki kodları yazdım. Burada tanımladığım bir sınıfa ait nesneyi final anahtar kelimesi kullanarak oluşturdum ve daha sonra aynı nesneyi tekrardan oluşturmaya çalıştım.
class Kimlik
{
String ad="Burak";
String soyad="SENYURT";
int id=1000;
public void Yaz()
{
System.out.println(ad+" "+soyad);
}
}
public class FinalAlanlar
{
public static void main(String[] args)
{
final Kimlik personel1=new Kimlik();
personel1.Yaz();
personel1=new Kimlik();
}
} |
Uygulamayı derlediğimde aşağıdaki hata mesajını aldım.
Sonuç olarak, final olarak oluşturulan bir sınıf örneği bir kere oluşturulabiliyordu. Diğer yandan final olarak tanımlanan bu sınıfın üyelerine normal olarak erişilebiliyordu. Final anahtar kelimesinin, bir sınıf örneğinin sadece bir kere üretilmesini sağlaması benim aklıma başka bir şey getirmişti. Acaba bir sınıfın yapıcı metodlarına final anahtarını ekleyebilirmiydim? Nede olsa final anatar kelimesini sınıf metodları ile birlikte kullanabiliyorduk. Bunun anlamanın yolu denemekten geçiyordu. önce aşağıdaki varsayılan yapıcıyı ekleyerek işe başladım.
final public Kimlik()
{
} |
Programı derlediğimde aşağıdaki hata mesajını aldım.
Belkide, final anahtar sözcüğünün yerinden kaynaklanıyordur diye düşündüm. Bu sefer final anahtar kelimesini public tanımından sonraya aldım. Ancak yine aynı hata mesajını elde ettim. Aklıma bu kez parametre alan bir yapıcıda final anahtarını kullanmak geldi. Nitekim yukarıdaki durum belkide varsayılan yapıcılara hastı.
final public Kimlik(int YeniID)
{
id=YeniID;
} |
Ancak sonuç yine değişmedi. Demekki final metodlar tanımlayabiliyor ancak final yapıcılar oluşturamıyordum. Tabi kendi kendime neden final yapıcılar oluşturmaya çalışayım ki dedim. Biraz anlamsız geldi ama neleri yapamıyacağımı görmem açısındanda bir yerde iyi oldu. Final anahtar sözcüğünü metodlara uygulayarak kalıtımda override’ları engellemeyi, değişkenlere uygulayarak program boyunca değiştirilemeyen değişkenler elde etmeyi, sınıf nesne örneklerine uygulayarak aynı nesnenin tekrar türetilememisini sağlamayı, öğrendikten sonra dahada fazlasının olabileceğini hiç düşünmemiştim.
Meğerse sırada parametreler varmış. Bir metodun parametrelerini final olarak tanımlayabilir ve bu sayede metodlara gelen parametre değerlerinin değiştirilmesini engelliyebilirdim. Nasıl mı?
class Hesaplar
{
double UsAl(final double sayi,final double us)
{
return Math.pow(sayi,us);
}
}
public class FinalAlanlar
{
public static void main(String[] args)
{
Hesaplar islem1=new Hesaplar();
System.out.println(islem1.UsAl(2.4,1.25));
}
} |
Bu uygulamada, Math sınıfının pow metodunu kullanarak, double tipinden bir sayının double değerden üssünü aldım. önemli olan kısım UsAl metodunda, parametre değerlerinin final olarak belirlenmesiydi. Şimdi bu metod içerisinde, gelen parametre değerlerini değiştirmeye çalışmalıydım.
double UsAl(final double sayi,final double us)
{
sayi=1.1;
us=3.1;
return Math.pow(sayi,us);
} |
Uygulamayı bu hali ile derleyip çalıştırdığımda,
görülen hata mesajını elde ettim. Demekki, metod parametreleri, final olarak bildirilirse, metod içinde değerleri değiştirilemiyordu. Ancak parametreye gönderilen değerlerin verildiği yerlerde bu durum söz konusu değildi. Bu tip parametreye sahip metodları, değerlerin kesinlikle içeride değiştirilmemesini istediğimiz durumlarda kullanabilirdim.
Herhalde final ile ilgili pek çok şey hallolmuştu demelimiydim acaba diye düşünürken, kitaplarımın birisinde final sınıflar isimli bir başlık görüverdim. Evet sanırım daha herşey bitmemişti. Kahvem bitmişti ancak final anahtar kelimesinin işlevsellikleri halen daha bitmemişti. Yinede final sınıf kavramı faydalı ve incelenmeye değer bir kavramdı. Final olarak belirtilen sınıfların en önemli özelliği, C# dilindeki sealed anahtar sözcüğünün işlevselliğine sahip olmalarıdır. Yani final olarak tanımlanmış bir sınıftan başka bir sınıfı kalıtımsal olarak türetemeyiz.
final class Hesaplar
{
double UsAl(final double sayi,final double us)
{
sayi=1.1;
us=3.1;
return Math.pow(sayi,us);
}
}
class AltSeviye extends Hesaplar
{
} |
Buradaki basit kodlarda, Hesaplar isimli sınıfı final olarak tanımladım. Sonrada, bu sınıftan kalıtım yolu ile başka bir sınıf türetmeye çalıştım. Elbette sonuç olarak java derleyicisi beni uyardı ve final olarak tanımlanmış bir sınıftan başka bir sınıfı türetemiyeceğimi söyledi.
Sınıfların final olarak tanımlanması, içerdiği metodların veya değişkenlerin final olarak algılanması anlamına gelmiyordu tabiki. Sadece ve sadece sınfın türetme amacı ile kullanılamıyacağını belirtiyordu. Final anahtar kelimesi ile ilgili elde ettiğim bilgiler şu an için bunlarla sınırlıydı. İlerleyen zamanlarda farklı şekillerde kullanımını görebilirmiyim bilemiyorum. Nitekim bende final olmuş durumdayım. Hem kahvem bitti hemde pilim. Sanıyorumki bir ara vermenin zamanı geldi. Artık önümüzdeki hafta boyunca, polimorfizm konusunu incelemek için bana gerekli olan enerjiyi depolamam gerekiyor.
|
