Bu yazının amacı, nesne yönelimli programlama ortamlarında kullanılan bir tasarım kalıbı (design pattern) olan gözlemci tasarım kalıbını (observer design pattern) açıklamak ve kullanımına dair bir örnek vermektir. Nesne yönelimli olmayan programlama dillerinde (örneğin C) aynı yapı, geri çağırım (callback) ismi verilen yaklaşım ile yapılabilir.

Konuya, klasik bir gözlemci tasarım kalıbını açıklayarak başlayalım. Geliştirme ortamı olarak sıklıkla kullandığım Netbeans içerisinde bir observer pattern eklenmesi halinde aşağıdakine benzer bir sınıf diyagramı (class diagram) görülmektedir:

Yukarıdaki kalıpta görüldüğü üzere 4 temel unsur bu kalıbı oluşturmaktadır:

• ConcreteObserver : Somut bir gözlemci
• ConcreteSubject: Somut bir fail (özne)
• Subject : Somut failden (özneden) türemiş olan diğer failler
• Observer: Somut gözlemciden türemiş olan diğer gözlemciler./

Gözlemci tasarım kalıbı, yukarıdaki şekilde görülebileceği üzere, aslında bir Fail / Meful ilişkisi (subject / object, özne /nesne ) üzerine kuruludur. Somut fail ile kastedilen, gözlemci yapısındaki herhangi bir fiile sebep olan (eylemi yapan) faildir (özne). Buna karşılık, nesne yönelimli programlama dillerinde, üzerine bir fiil uygulanan şey genelde nesne olarak ifade edilir. Yani zaten nesne yönelimli dillerde herhangi bir fiil, sadece nesneler üzerine uygulanmaktadır. Bu durumda fail ile kastedilen, yukarıdaki kalıpta concreteSubject ve bu yapıdan türeyen bütün subject sınıfı nesneler, meful ise bu nesnelerin metotlarına parametre olarak geçirilen ve üzerinde işlem yapılan nesnelerdir.

Bu yaklaşımı bir kod örneği üzerinden açıklamaya çalışalım. Öncelikle tasarımımızın sınıf diyagramını (class diagram) vererek konuya başlayalım:

Yukarıdaki şekilde, modelimizde bulunacak olan üç unsur içinde, yani gözlemci, fail ve meful için birer sınıf tanımı yaptık. Bu sınıfların kodu aşağıda verilmiştir:

İlk olarak gözlemci sınıfı (class) ile konuya başlayalım. Sınıfın tanımında, bir main fonksiyonu bulunuyor ve bu main fonksiyonu aslında fail , meful ve gözlemci kavramlarının bir araya geldiği nokta oluyor. Zaten sınıf diyagramında da görüleceği üzere gözlemci bu iki kavramı bir araya getirir. Buna göre fail ve meful sınıflarından üretilen failNesne ve mefulNesne nesneleri (objects) (kodun 20. ve 23. satırlarında), kodun 26. satırında, addObserver fonksiyonu ile birbirine bağlanmıştır. Bu basit işlem, meful üzerinde bir failin gözlemini tanımlar. Ayrıca kodun 29. satırında klasik thread üretmek için kullanılan ve Runnable arayüzü üzerinden Thread çağırımı ile failNesne’mizi bir thread şeklinde başlatıyoruz.

Gelelim Fail sınıfının tanımına:

Yukarıdaki kodda, basit bir şekilde, kulanıcıdan, ekranda yazı okumak için BufferedReader, InputStreamReader’a ve InputStreamReader da System.in’e bağlanmış. Bu sayede, System.in üzerinden girilen bir veri, BufferedReader tarafından okunabilecektir. response ismindeki String değişkeni (variable) bir sonsuz döngü içerisinde (21. satırdaki while) kullanıcıdan veri okumakta ve sırasıyla setChanged() ve notifyObservers() fonksiyonlarını çağırmaktadır. Buradaki notifyObservers fonksiyonu aslında bütün bu yazının kalbini oluşturuyoru. Dikkat edilirse bu fonkisyona klavyeden okuduğumuz response isimli değişkeni parametre olarak veriyoruz.

Kodda dikkat edilecek diğer iki husus ise, Observable sınıfını miras almamız (inheritance) ve bir thread olarak çalışmasını istediğimiz için Runnable arayüzünü (interface) implements etmemizdir.

Son olarak meful sınıfını açıklayıp, kodun çalışmasına bakalım:

Kodda görüldüğü üzere, Meful isimli sınıfımız, basitçe Observer arayüzünü kendi üzerine uygulamıştır (implements).

Meful sınıfının yegane fonksiyonu update fonksiyonudur ve parametre olarak bir Observable nesnesi bir de arg isimli Object tipinde (yani JAVA açısından tipsiz) bir parametre almaktadır.

Burada tipsiz tipler ile ilgili aşağıdaki yazıyı okumakta yarar olabilir

Son olarak update fonksiyonu içerisinde alınan mesaj, tip inkılabı (typecasting) ile Object tipinden String tipine inkılap ettirilmiş ve ardından ekrana basılmıştır.

Şimdi yukarıdaki senaryoyu toparlayacak olursak, gözlemci sınıfımızdaki main fonksiyonu çalıştırılarak bütün senaryo başlamaktadır. Bu main fonksiyonu içerisinde bir fail bir de meful nesnesi üretilmekte ve üretilen nesneler birbirine addObserver fonksiyonu ile bağlanmaktadır. Yani artık meful sınıfından türeyen nesneler, fail sınıfının birer observer’ı olmaktadır. Ardından fail sınıfından üretilen nesne bir thread olarak çalıştırılmakta ve kendi içerisinde bulundurduğu, ve threadlerin ilk çalışan fonksiyonu olan run() fonksiyonunda tanımlı olan kullanıcıdan bir dizgi (String) okuma işlemini gerçekletirmektedir. Hemen ardından okunan mesajı, aslında hiçbir fikri olmayan ismini, ne tür bir parametre aldığını dahi bilmediği notifyObservers () fonksiyonuna parametre geçirmektedir. Bu fonksiyon, bir sevki tabii olarak meful sınıfındaki update isimli fonksiyonu tetiklemektedir. Update fonksiyonu ise kendisine parametre olarak gelen nesneyi String sınıfına çevirmekte ve ekrana bamaktadır.

Yukarıdaki kodu çalışması sonucu ekran görüntüsü aşağıdaki şekildedir:

Görüldüğü üzere kodumuz bir fiil sorusu sormakta ve klavyeden benim yazdığım “merhaba” yazısını ekrana geri basmaktadır. Buradaki mesajı okuyan fail isimli sınıftan türeyen nesne iken, ekrana cevabı yazan meful isimli sınıftan türeyen nesnedir

Yukarıdaki bu tasarım kalıbını, daha gerçekçi bir örnek üzerinden açıklamaya çalışalım.

Örneğin bir müzayede (açık arttırma) ortamını, gözlemci tasarım kalıbı ile modellemek isteyelim. Buna göre müzayedeyi yöneten bir kişi ve bu müzayedeye katılan müzayedeciler bulunacaktır. Buna göre müzayedeyi yöneten kişi bir gözlemci olmakta, müzayedecilerin her biri birer fail (fiili yapan kişi) olmakta ve müzeyede sırasında verilen her teklif (fiyat) bir meful (fiilin etkisindeki değer) olmaktadır.

Bu yaklaşımı aşağıdaki şekilde göstermeye çalışalım:

Yukarıdaki yaklaşımda, muzayede sırasında verilen değerler, gözlemcinin update fonksiyonuna birer parametre olarak geçirilmekte ve nihayetinde gözlemciden bağımsız olarak ilgili fonksiyonlar çağrılmaktadır.

Gözlemci tipi tasarım kalıbının bir dezavantajı, bu noktada çıkmaktadır. Gözlemci tasarım kalıbında, meful yapısında olan ve fiilden etkilenen nesnelerin sistemde etkin rol oynaması beklenir. Diğer bir deyişle, açık arttırmaya katılan her bir katılımcı, fail olarak fiyatlarını belirtirken, gözlemci bu durumu sadece gözlemekte ve bir fiilde bulunmamakta ancak fiileri gözlemektedir. Bu anlamda, gözlemci tasarım kalıbı, çekme iletişim modeli (pull interaction model) olarak düşünülebilir. Alternatifi olan itme iletişim modelleri (push interaction model) failin doğrudan eylemde bulunması ile sonuca ulaşmakta ve dışarıdaki nesneleri çalışmaya zorlamaktadır. Yani gözlemci örüntü modelinde, dışarıda bulunan nesnelerin çalışmaları sonuçları toplanmaktayken, itme iletişim modeli olan diğer kalıplarda, bir nesne, diğer nesnelerin sonuç üretmesini zorlayabilir. Burada, tasarıma bağlı olarak bir seçim yapmak gerekir.

334 views

Çözüme geçmeden önce, sizlerle görüşme imkanımız olmadığı için bir iki noktayı buradan açıklama ihtiyacı hissettim. Öncelikle, bilinmelidir ki bu sınavda sorulan bütün sorular, derste anlatılan konular kapsamında hazırlanmıştır. Bazı sorulara çözüm olabilecek derste birden fazla yol gösterilmiştir, buradaki cevaplarda bir tanesini seçip (genelde en uzun ve karmaşık olanını vermeye çalışıyorum) anlatıyorum ancak diğer yollar da doğru kabul edilecektir. Hatta derste anlatılmayan ama JAVA dilinde doğru olan yöntemler kullandıysanız (sonuçta derste anlatmadığım ama JAVA Tutorial içinde bulunan ve sizin ders dışı çalışarak öğrendiğiniz konular olabilir) bunları da doğru kabul edeceğim.

Ayrıca sınavlarınızın bir kısmını okudum ve genel olarak çalışmadığınız görülüyor. Nasıl bir sınav bekliyordunuz bilmiyorum ama bu dönem itibariyle hayal kırıklığına uğradığımı söyleyebilirim. Özellikle final sınavında birebir derste anlattığım kodları sormuştum. Finaldeki toplam 5 sorunun tamamını derste adım adım kodlayıp çalıştırıp sizlere anlatmıştım. Özellikle finaldeki 0. soruyu çözemeyip, ekrana ismini ve numarasını bastıramayan kişi sayısı sınıfın çoğunluğunu oluşturuyor. Bu durum da gösteriyor ki bu derse hiç çalışılmamış. Bütünleme sınavlarının henüz tamamını okumadım ama görülen durum, derste anlatılan konuları, bildiğiniz veya bilmenizi beklediğimiz konuları, farklı problemlere uygulayamadığınız. Örneğin Thread sorusunda, derste anlattıklarımın dışında yeni hiçbir bilgiye ihtiyacınız olmadığı halde genelde bu soruda durum çok kötü. Bu dönem itibariyle ilk defa üniversitenizde ders verdiğim için sanırım benim hatam sizlere fazla güvenmem ve çalışacağınıza olan inancımdı. Bu dönemden sonra, her hafta ödev, dönem projesi, quiz ve sıkı bir laboratuvar programı uygulamamız gerektiğini, ve sizleri çalışmaya zorlamamız gerektiğini anlamış bulunuyorum.
Aşağıdaki çözümleri web sayfası olarak yayınlarken bazan hatalar olabiliyor. Kod hassas bir yazı olduğu için bu tip hatalara mahal vermemek adına, çalışan bir örnek kodu aşağıdaki linkten indirebilirsiniz:
Sınavın çözüm kodu (netbeans projesi olarak) indirmek için tıklayın.

Soru 0) Bir kesir (fraction) sınıfı kodlayınız. Kodunuza iki kesiri toplayan fonksiyonu ekleyiniz. (15 puan)

Öncelikle bilinmelidir ki rasyonel sayılar kümesi reel sayılar kümesinden farklıdır. Ayrıca kesirli sayıların paydası 0 olamaz. Sınavda bu problemi çözmek için istisna yakalama (exception handling) kullanabileceğiniz gibi, basit bir if ile kontrolünüz de doğru kabul edilecektir. Buna göre kodlanmış hali aşağıdaki şekildedir:

package butunleme;
class kesir{
    public int getPay() {
        return pay;
    }
    public void setPay(int pay) {
        this.pay = pay;
    }
    public int getPayda() {

        return payda;
    }
    public void setPayda(int payda) {
        if(payda==0) // kesirli sayıların paydası 0 olamaz.
            payda = 1;
        this.payda = payda;
    }
    public kesir(int pay, int payda) {
	setPayda(payda);
	setPay(pay);
    }
    int obeb(int a,int b){
      if(b==0)
        return a;
   else
        return obeb(b,a%b);
    }
    public void topla(kesir k){
        int obeb = obeb(k.payda, payda);
        k.pay *= payda/obeb;
        pay *= k.payda/obeb;
        pay += k.pay;
        payda = (k.payda/obeb ) * (payda/obeb);
    }
    int pay;
    int payda;
}
public class Butunleme {
    public static void main(String[] args) {
        // TODO code application logic here
        kesir k = new kesir(3,4);
        kesir m = new kesir(4,5);
        k.topla(m);
        System.out.println("toplam : "+k.pay + " / "+ k.payda);
    }
}

Ekran çıktısı :

toplam : 31 / 20

Soru 1) 0. Soruda verdiğiniz cevabı kullanarak, bir çok terimli (polynom) sınıfı kodlayanız. Toplama (summation) , çarpma (multiplication), türev (derivation) ve çözme (evaluation) metotlarını kodlayınız. Kodunuzda, kapsülleme (encapsulation), çok şekillilik (polymorphism), yapıcı metotlar (constructor methods) bulunmalı ve kodunuzu çalıştıran main fonksiyonunu yazmalısınız. Ayrıca kodunuzu yazdıktan sonra konsol üzerinde nasıl derlenip çalıştırığını da yazınız.

Örnek:

(¾ x² + ½ x + 5) çok terimlisi ile (5x³ + 1/3 x + 2) çok terimlisinin toplamı :

(5x³ + ¾ x² + 5/6 x + 7) olarak bulunmalıdır. Yukarıdaki iki soru için tek bir kod yazabilirsiniz. (35 puan)

Sorunun çözümünü dosya olarak ekliyorum. Soru için genel olarak birden fazla çözüm yolu bulunuyor. Örneğin iki çok terimlinin toplamını 3. bir çok terimliye döndürmek veya mevcut çok terimliye bir parametre eklemek arasındaki tercih notlamayı etkilemez. Örnek kodda çarpma için üçüncü bir çok terimli döndürdüm ve toplama için mevcut çok terimliye ilave ettim, dolayısıyla iki yolda görülebiliyor. Ayrıca çok terimlileri sadeleştirmek veya sadeleştirmemek de notlama için önemli değil. Yine örnek çözümde terim isminde bır sınıf kullanıp, çok terimlinin her terimini bu sınıftan bir nesne halinde vektöre yerleştirdim. Derste birden fazla nesneyi tutmak için iki yol görmüştük, vektör yerine diğer yol olan dizi kullanılabilir veya terim sınıfı yerine 3 farklı dizi paralel şekilde tutulabilirdi (ders veri yapıları olmadığı için bu tip, aslında veri yapısı hatası olan kodlamaları kabul edebiliriz). Yine örnek kodda, obeb (gcd) hesabı için özyineli (recursive) fonksiyon kullandım, iteratif kullanım da yapılabilirdi. Anlatmaya çalıştığım üzere sonucu doğru olan birden fazla yol bulunmakta ve hangisi ile yapılması istendiği, soruda beliritilmediği için önemli olmamaktadır.

Soru 2)Grafik arayüzü kullanarak (swing kütüphanesi), bir çok terimliyi okuyan ve yukarıdaki kodunuzu kullanarak bir nesne oluşturan kodu yazınız. (20 puan)

Bu soruda da farklı seçimler yapılabilir. Örneğin swing kütüphanesi kullanılarak basit bir arayüz tasarlayıp tek bir metin kutusundan çok terimli okunabilir. Okuduğunuz çok terimliyi daha sonra tokenize etmeniz gerekeceği için swing kısmı basit ama arkadaki string işleme kısmı kuvvetli bir kod yazabileceğiniz gibi, çok terimlinin her terimini okuyan ayrı birer kutu da yerleştirilebilir. Sonuçta amacımız bir çok terimliyi ekrandan okumak.

package butunleme;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ekran implements ActionListener{
    //www.bilgisayarkavramlari.com
    JButton dugme;
    JButton tamam;
    JFrame x;
    int derece;
    JTextField tf;
    JLabel jl;
    JTextField ctparam [];
    public ekran(){
        x = new JFrame();
         x.setLayout(new FlowLayout());
         jl = new JLabel("Çok Terimlinin derecesini giriniz:");
        x.add(jl);
        tf = new JTextField(5);
        x.add(tf);
        dugme=new JButton("Devam");
        x.add(dugme);
       dugme.addActionListener(this);
        x.setSize(400,200);
        x.setVisible(true);
    }
    public static void main(String args[]){
       new ekran();
    }
    public void actionPerformed (ActionEvent e){
        if(e.getSource()==dugme){
            derece = Integer.parseInt(tf.getText());
            x=new JFrame();
            x.setLayout(new GridLayout(derece+2,2));
            x.setSize(150,300);
            x.add(new JLabel("pay"));
            x.add(new JLabel("payda"));
            x.add(new JLabel("üst"));
            ctparam = new JTextField [derece*3];
            for(int i = 0;i<derece;i++){
                ctparam[3*i]=new JTextField();
                ctparam[3*i+1]=new JTextField();
                ctparam[3*i+2]=new JTextField();
                x.add(ctparam[3*i]);
                x.add(ctparam[3*i+1]);
                x.add(ctparam[3*i+2]);
            }
            tamam = new JButton("Tamam");
            x.add(tamam);
            tamam.addActionListener(this);
            x.setVisible(true);
        }
        if(e.getSource() == tamam){
            cokTerimli ct = new cokTerimli();
            for(int i = 0;i<derece;i++){
                ct.ct.add(new terim(Integer.parseInt(ctparam[3*i+2].getText()),
                        new kesir(Integer.parseInt(ctparam[3*i].getText()),
                        Integer.parseInt(ctparam[3*i+1].getText()))));
            }
            ct.goster();
        }

    }
}

Kodun ekran çıktısı aşağıdaki şekildedir:

Ve kod konsoldan aşağıdaki çok terimliyi basar:

2/3x^4 + 5/6x^5 + 3/1x^2 + 3/4x^3 + 1/1x^1

Soru 3) Bir çok terimlinin x ekseni ile arasında kalan alanın hesaplanması için, kullanılan yöntemlerden birisi de, belirli aralıklarla x değerleri verilerek dikdörtgenler elde etmek ve bu dikdörtgen alanlarının toplamlarını hesaplamaktır.

Örneğin yukarıda, şekli verilen çok terimlinin alanı hesaplanırken, belirli aralıklara sahip x değerleri verilmiş ardından bu değerlerin çok terimlideki sonuçları ile aralık miktarları çarpılarak elde edilen dikdörtgenlerin alanları bulunmuştur. Çok terimlinin alanı, bu dikdörtgenlerin alanlarının toplamı olarak bulunabilir.

Bu hesaplama işlemi, karmaşık çok terimliler için, çok küçük aralıklarla hesaplama istendiğinde, bilgisayara yüksek miktarda yük getirebilmektedir. Sizden istenen hesaplama işlemini çok life bölmenizdir.

Çok lifli (multi threaded) kod yazarak hesaplanacak alanı en az 3 life (thread) bölünüz ve sonucu ekranda gösteren main fonksiyonunu kodlayınız.

Not: kolaylık olması için bu soruda, hesaplanacak alanın başlangıç ve bitiş değerlerini (x’in alt ve üst limitlerini), aralık değerini (delta) ve lif sayısını, kullanıcıdan alabilirsiniz.

(30 puan)

Yukarıdaki soru için yazılabilecek çözümlerden birisi aşağıdaki şekildedir:

package butunleme;
class alanLif extends Thread {
    cokTerimli ct ;
    int basla,bit;
    int delta;
    anaLif al ;
    public alanLif(cokTerimli ct,int basla, int bit, int delta,anaLif al){
        this.ct = ct;
        this.basla = basla;this.bit=bit;this.delta=delta;
        this.al = al;
    }
    public void run(){
        int hareket = basla;
        int toplam = 0;
        while(hareket < bit){
            toplam += ct.coz(hareket)*delta;
            hareket += delta;
        }
        al.getSonuc(toplam);
        System.out.println(" alan : "+ toplam + " aralik " + basla + " - "+ bit);
    }
}
public class anaLif {
    int toplam=0;
    int sonucGelen = 0;
    public anaLif(){
        cokTerimli ct = new cokTerimli();
        ct.ct.add(new terim(2,new kesir(2,1)));
        ct.ct.add(new terim(1,new kesir(3,1)));
        ct.ct.add(new terim(0,new kesir(5,1)));
        ct.goster();

        int basla = 0;
        int bit = 100;
        int ara= (bit-basla)/5,arabasla=0,arabit=ara;
        for(int i = 0;i<5;i++){

            new alanLif(ct,arabasla,arabit,1,this).start();
            arabasla+=ara;
            arabit += ara;
        }
    }
    public static void main(String args[]){
       anaLif al = new anaLif();
       while(al.sonucGelen < 5)
           try{  Thread.sleep(50); } catch(Exception e){}
       System.out.println("alanın toplam değeri:"+al.toplam);
    }
    public void getSonuc(int sonuc){
       toplam += sonuc;
       sonucGelen ++;
    }
}

Yukarıdaki kodda, alanLif isimli thread sınıfı, verilen aralık ve delta değeri için alan hesaplamaktadır. Bu sırada, çok terimli sınıfında bulunan çöz fonksiyonunu kullanmaktadır. Ayrıca analif sınıf, 5 adet (bu örnek için lif sayısını ben 5 kabul ettim, sayı farklı olabilir, soruda 3′ten fazla olması istenmiştir) lif (thread) oluşturmaktadır.

Son aşamada, main fonksiyonu altında, bütün threadler bitene kadar (ki bittiklerini hepsinin sonuç döndürmesinden anlıyoruz) bekliyoruz. Bütün thraedler sonuçlarını analif’e döndürünce, her threadden gelen değeri alıp sonuç toplamını hesaplıyor ve ekrana basıyoruz.

Yukarıdaki kod için örnek ekran çıktısı aşağıdaki şekildedir:

2/1x^2 + 3/1x^1 + 5/1x^0 alan : 5610 aralik 0 – 20

alan : 102410 aralik 40 – 60

alan : 38010 aralik 20 – 40

alan : 198810 aralik 60 – 80

alan : 327210 aralik 80 – 100

alanın toplam değeri:672050

658 views

Bu yazının amacı, Java dilindeki vektör sınıfının kullanılmasını ve yapısını anlatmaktır.

Java dilindeki vektörlerin yapısından bahsederek başlayalım. Klasik veri yapısı olarak dizilerin (array) ve bağlı listelerin (linked list) özelliklerini birleştirmiştir.

Bir vektör boyutu belli olmadan tanımlanıp içerisine veri konuldukça hafızada kapladığı yeri arttırmaktadır. Bu anlamda bağlı listelere benzer özellik göstermektedir. Yani bir vektörün boyutunun önceden tanımlanması gerekmez. Aslında vektörün boyu yoktur ve herhangi bir anda vektör için bir limit belirtilmez.

Boyutunu belirsiz tutabilmemizin yanında, bir vektörün herhangi bir elemanına doğrudan erişmek (random acces) de mümkündür. Bu sayede vektör yapısı diziler ve bağlı listelerden daha avantajlı bir hal almış olur.

Vektörler hakkında bilmemiz gereken son özellik ise, vektörlerin tipsiz olduğudur. Yani vektörler içlerinde istenilen tipte veri tutabilir. Bunu, JAVA dilinde bulunan nesne mirası sayesinde yapmaktadırlar. JAVA dilinde, bütün nesneler, Object sınıfından türemiştir. Yani aslında bütün nesneler ile Object sınıfı arasında bir miras (inheritance) ilişkisi bulunmaktadır.

Dolayısıyla JAVA dilindeki bütün nesneler, Object sınıfına yukarı akış yapılarak (upcasting) bu tipte tutulabilir. Aşağıdaki örneklerde bu durumu gösteren kodlar sunulacaktır.

Gelelim vektörlerin, JAVA dilindeki kullanılışlarına

Basit bir uygulama ile bu sınıfı tanımaya başlayalım.

Öncelikle java dilindeki vektör sınıfı, java.util paketi altında bulunabilir. Dolayısıyla vektörler ile çalışırken kodun başına

import java.util.Vector;

yazmak gerekir. Yukarıdaki kodun 14. satırında da bu import işlemi ile koda başlanmıştır.

Kodun ana çalışan sınıfı (class) vektorDeneme isimli sınıftır ve bu sınıfın içerisinde bir adet main fonksiyonu bulunur. Bu fonksiyonun içinde victor isimli bir Vector tanımlanmıştır.

Ayrıca vektörün içerisinde tutulacak veri tipini belirlemek için bir oluşum sınıfı (composition class) tanımı yapılmış ve insan tipinin, boy ve yaş bilgilerinden oluştuğu kodlanmıştır. (kodun 14-23. satırları arası). Bu sınıf içerisinde bir inşa fonksiyonu (yapıcı fonksiyon, constructor) tanımlanmış ve iki tam sayı (int) alarak bir insanı tanımlamaya imkan sağlamıştır.

Kodun 28. satırında, insan tipinde bir ali nesnesi (object) üretilmiş ve bu nesne, 29. satırda, daha önceden tanımladığımız victor ismindeki vektöre yerleştirilmiştir.

Kodun 30. satırında, victor isimli vektörün boyutunun nasıl alındığı gösterilmiştir. Buna göre bir vektör nesnesinin .size() şeklinde metodu çağrılarak, boyutu alınabilir.

Ayrıca vektörün herhangi bir sıradaki elemanına erişmek için .elementAt() fonksiyonunu çağırmak ve bu fonksiyona parametre olarak kaçıncı elemana erişilmek istendiğini vermek yeterlidir.

Ne yazık ki 31. satırdaki çağırma işlemi sonucunda JAVA anlamlı bir şey basamaz. Bunun sebebi, vektörün 0. elemanı olarak konulan nesnenin tipinin belirsiz olması ve şu anda nesne sınıfına (object) çevrilmiş olmasıdır. Vektörün 0. sırasında bulunan bu elemanın üyelerine (members) erişmek için öncelikle insan tipine geri çevrilmesi gerekir. Bunun için tip inkılabı yapıp nesnenin başına parantezler içerisinde (insan) yazılmıştır. Ancak bu çevirim yapıldıktan sonra boy ve yas üyelerine erişilebilmiş ve ekrana basılmıştır.

Yukarıdaki kodun çıktısı aşağıda verilmiştir:

• vektör boyutu: 1
• vektörün 0. elemanı : javaapplication21.insan@190d11
• elemanın insan olarak boyu : 100 yasi : 10

Görüldüğü üzere, çıktının ikinci satırında, JAVA nesneyi ekrana basmıştır. (aslında ekrana basılan nesnenin dizgiye (string) çevrilmiş ve serilenmiş halidir, daha fazla bilgi için nesne serileme (serialization) başlıklı yazıya bakabilirsiniz).

Vektörlerin, JAVA dilinde bir tip kısıtlaması ile kullanılması da mümkündür.

Örneğin yukarıdaki kodda bulunan victor isimli vektöre, yeni elemanlar eklenirken herhangi bir kısıt bulunmaz. İkinci elemanı olarak öğrenci, üçüncü elemanı olarak ders tipinde nesneler eklenebilir. Bu nesnelerin hepsi Object tipine çevrilerek yerleştirilir. Ancak biz kısıtlamak istersek bir şablon tanımı (template) yapmamız mümkündür.

Vector<insan>kisitli = new Vector<insan>();

Şeklindeki tanım, sadece insan tipinden nesneler alabilir. Farklı tiplerdeki nesnelerin bu vektöre konulması mümkün değildir. Aynı zamanda tip dönüşümü yapmak da gerekmez. Yani bir önceki kodda bulunan ve vektörün herhangi bir elemanının boyu veya yaşını bastırmak için başına eklediğimiz (insan) ibaresinin bu kodda bulunması artık gerekmez. Çünkü JAVA bu sınıfların tiplerini bilmektedir ve bu tiplere göre erişime izin verir.

459 views

Bu yazının amacı, java dilinde bulunan final kelimesini açıklamaktır. Temel olarak final kelimesi, java dilinde 3 farklı yerde bulunabilir:

• Sınıf tanımında
• Metot (fonksiyon) tanımında
• Değişken tanımında

Sırasıyla bu durumları uygulamalar üzerinden görelim.

public final class sonsınıf{ }

yukarıdaki tanımın yapılması halinde, sınıf (class) nihai bir sınıf olur (final class) ve artık bu sınıftan kalıtım yapılamaz (miras, inheritance).

Örneğin yukarıdaki tanımdan sonra, aşağıdaki şekilde bir kod yazılması hatadır:

public class yenisınıf extends sonsınıf{ }

sebebi ise sonsınıf’ın nihai sınıf olarak tanımlanmış olmasıdır (final class).

Benzer şekilde bir metot tanımının başına final kelimesi yazılarak, metodun nihai olması durumunda, bu metodun üzerine bindirme yapılamaz (overriding).

Örneğin aşağıdaki kodu ele alalım:

public class deneme{

  public final int toplama(int a,int b){

     return a + b;

 }

}

Yukarıdaki kodda, toplama fonksiyonunun nihai hali kodlanmıştır. Bu sınıftan miras alan hiçbir sınıf toplama fonksiyonunu değiştiremez.

Örneğin aşağıdaki kod hatalıdır:

public class yenisınıf extends deneme{

  public int toplama(int a, int b){ }

}

Yukarıdaki bu kodun hatası, final olarak tanımlanan bir metodun üzerine bindirme yapıyor olmasıdır (overriding).

Son olarak bir değişkenin nihai olmasını inceleyelim. (final variables)

Bir değişken nihai tanımlandıysa, bu durumda içerisine atama sadece bir kere yapılabilir (assignment).

Örneğin aşağıdaki tanımı ele alalım:

final int x = 10;

yukarıdaki koddan sonra, kodun herhangi bir yerinde x değişkenine yeni değer atanamaz. Örneğin

x= 7;

yazılması durumunda hata alınır.

Nihayi değişkenler, sabit değişkenlerden farklıdır (constant variables, const)

En önemli farkı ise, derleme zamanında (compile time) değişkenin değerinin bilinmesi gerekmemesidir.

Örneğin aşağıdaki kodu ele alalım:

public class deneme{

  final int x;

  public deneme(int x){

   this.x = x;

  }

}

Yukarıdaki kod doğru ve çalışan bir koddur çünkü değişkene sadece bir kere, yapıcı fonksiyon marifetiyle (constructor, inşa fonksiyonu) atama yapılmıştır. Buna karşılık aşağıdaki kod hatalıdır:

public class deneme{

  const int x;

  public deneme(int x){

   this.x = x;

  }

}

Çünkü yukarıdaki kodda, değişkenin tanımı sırasında değer atanması yapılması gerekir. Örneğin

const int x = 10;

gibi ve bu atamadan sonra değer değiştirilemez. Örneğin yukarıdaki kodda bulunan final kelimesinin const kelimesi ile değişmesi halinde, yapıcı fonksiyonda (constructor) hala hata bulunmaktadır çünkü sabit bir değişkenin değeri değiştirilmeye çalışılmaktadır.

212 views

Bu yazının amacı, JAVA programlama dilinde bir sınıfın, birden fazla sınıftan nasıl miras aldığını anlatmaktır. Temel olarak JAVA dilinde doğrudan çoklu kalıtım (multiple inheritance) bulunmaz. Yani aşağıdaki gibi bir kod hatalıdır:

public class bilgisayar_mühendisliğ_öğrencisi extends sayısal_öğrenci, üniversite_öğrencisi{

}

Yukarıdaki tanıma göre bir bilgisayar mühendisliği öğrencisi hem üniversite öğrencisidir hem de sayısal bölüm öğrencisidir. Ancak JAVA, yukarıdaki bu tanıma izin vermez ve extends kelimesinden sonra sadece tek bir sınıf ismi yazılmasına izin verir.

Buna rağmen, JAVA programlama dilinde arayüz kullanarak (interface) bir sınıfın birden fazla sınıftan miras almasını sağlayabiliriz.

Çoklu mirasa geçmeden önce tek bir sınıfı, arayüz kullanarak nasıl miras aldığımızı görelim ardından birden fazla sınıf için bu yöntemi geliştirelim.

interface sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek();

}

Yukarıda bir sayısal öğrencisi olma şartı arayüzü tanımlanmıştır. Bu arayüz, herhangi bir sınıf tarafından uygulanırsa (implements) bu sınıfın analitik_düşünmek şeklinde bir fonksiyonu bulunması gerekir.

Şimdi bir bilgisayar mühendisliği öğrencisinin bu şartı sağladığını JAVA dilinde modelleyelim:

Public class bilgisayar_mühendisliği_öğrencisi implements sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek(){

// fonksiyon içeriği…

}

}

Yukarıda kodda görüldüğü üzere, uygulama şartı olarak (implements) arayüzde bulunan fonksiyonun içeriği yazılmıştır. Bu kodlamadan sonra artık bilgisayar mühendisliği öğrencisinin, sayısal öğrencisi olma şartını sağladığını söyleyebiliriz.

Şimdi bilgisayar mühendisliğindeki öğrencileri sayısal öğrencisi olarak tanıtabiliriz:

public class sayısal_öğrencisi {

double ortalaması;

public sayisal_öğrencisi( sayısal_öğrencisi_olma_şartı s){

s.analitik_düşünmek();

}

}

public class bilgisayar_mühendisliği_öğrencisi implements sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek(){

System.out.println(“düşünüyorum….”);

}

}

public class test{

public static void main(String args[]){

sayısal_öğrencisi ali = new sayısal_öğrencisi( new bilgisayar_mühendisliği_öğrencisi());

}

}

Yukarıdaki kod sonucunda ekranda, “düşünüyorum….” yazısı belirir. Bunun anlamı, ali isimli sayısal öğrencisinin, düşünmek isminde bir fonksiyonu olmasıdır.

Yazının başında da belirtildiği gibi JAVA doğrudan bir kalıtım ilişkisini desteklemez. Ancak yukarıdaki şekilde sınıflar arasında bir arayüz tanımlayarak bu iki sınıf arasında kalıtım ilişkisi kurulabilir.

Yukarıdaki kodda, yapılan eylem iki farklı yanlış anlaşılmaya açıktır. Genelde sık yapılan bu hataları aşağıda anlatmaya çalışalım.

1. Kalıtım değildir.

Yukarıdaki kod modeli, tam olarak kalıtım değildir. Sadece fonksiyonlar üzerinde tanımlıdır. Örneğin arayüzler (interface) üzerinde değişken tanımlanamaz.

2. HASA ve ISA arasındaki fark.

HASA ilişki modeli ile bir nesnenin diğer bir nesneyi içermesi, ISA ilişki modelinden farklıdır.

Bu durumu aşağıdaki şekil üzerinden açıklamaya çalışalım. Örneğin aralarında ISA ilişkisi bulunan iki sınıfı ele alalım:

Bu çizimi bir küme modeli ile modellemek istersek aşağıdaki şekilde bir sonuç çıkar:

Yukarıdaki model, nesne varlığı açısından kurulmuştur. Bu modele göre, insan, öğrenci’nin bir alt sınıfıdır. Yani öğrenci, insanda olan bütün özellikleri ve eylemleri kapsar ilave olarak kendisine özgü bazı özellikleri de bulunabilir. ( bu modelleme aslında çok sağlıklı değildir çünkü genelde kavram-varlığı açısından karmaşaya sebep olur. Modele kavram-varlığı açısından bakılırsa aslında öğrenci, insanın bir alt kümesidir ve insan kümesinde farklı varlıklar da vardır (örneğin öğrenci olmayan diğer insanlar) ancak yukarıdaki model tekrar ediyorum nesne-varlığı açısından çizilmiştir).

Yukarıdaki modeli elde etmenin birinci yolu miras ilişkisi kurmaktır (kalıtım inheritance) diğer yolu ise HASA ilişkisi tanımlamaktır.

public class öğrenci extends insan{

}

Şeklindeki bir tanım, insan sınıfındaki bütün tanımları otomatik olarak öğrenci sınıfına taşıyacak ve ardından yukarıda çizilen küme modelini gerçekleyecektir.

public class öğrenci{

insan a;

}

Ancak bu gerçekleme bir kalıtım ilişkisi olarak kabul edilemez. Bu gerçeklemede aslında iki farklı varlık vardır ve bu varlıklar arasında var oluştan kaynaklanan bir fark yoktur.

public class test{

public static void main(String args[]){

insan ali = new insan();

öğrenci veli = new öğrenci();

veli.a= ali;

}

Yukarıdaki bu model sonucunda, ali, velinin bir alt kümesi halini alır ancak buradaki ali’nin varlığı ile veli’nin varlığı arasında bağlayıcılık yoktur. Örneğin veli nesnesi (object) yok edilmesi sonucunda ali yaşamına devam edebilir. Bu tip ilişkilere münasebet (aggregation) ismi verilmektedir ve yukarıdaki yazıda anlatılan arayüz marifetiyle kalıtımdan tamamen farklı bir yapıdadır.

581 views

Nesne yönelimli programlama dillerinde, sınıflar (class) arasında miras ilişkisi bulunması halinde (inheritance), bu sınıflardan türetilen nesnelerin birbirine akıtılması durumudur.

Bu durumu aşağıdaki örnekler üzerinden anlamaya çalışalım:

public class insan{
   int boy;
   int kilo;
}
public class öğrenci extends insan{
   int sınıf;
   String bölüm;
}

Örnek olarak verilen yukarıdaki iki sınıf arasında miras ilişkisi bulunmaktadır ve insan sınıfı, öğrenci sınıfının atası olarak kabul edilebilir.

Şimdi bu sınıflardan birer nesne tanımlayarak akış işlemini göstermeye çalışalım:

public class test{
   public static void main(String args[]){
      öğrenci ali = new öğrenci();
      insan veli = new insan();
      ali= veli;
      veli = new öğrenci();
   }
}

Yukarıdaki kodun son iki satırında bulunan atama işlemleri birer akış işlemidir (casting) ve ali=veli atamasında, öğrenci tipinden bir nesne atfına, insan sınıfından bir nesne konulduğu için bu akışa, aşağı akış (down casting) ismi verilir.

Bu akışın tam ters yönlüsü olan ve son satırda yer alan atamada ise veli isimli insan tipinden bir nesne atıfının içerisine öğrenci sınıfından bir nesne yerleştirilmektedir. Bu durum ise yukarı akış (up casting) olarak isimlendirilmektedir.

Klasik olarak nesne yönelimli programlama dillerinde aşağı akış (downcasting) yapılması halinde, nesnenin bütün bilgilerine erişilebilirken, yukarı akış (upcasting) yapılması durumunda nesnenin sadece nesne atfının üyeleri kadar bilgisine erişilebilir. Örneğin yukarıdaki kod için veli isimli değişken, insan tipinde olduğu için, öğrencinin boy ve kilosuna erişebilirken, öğrencinin sınıfı veya bölümüne erişemez. Bu bilgiler daha önceden atanmışsa hafızada durur ama erişilemez. Tekrar öğrenci tipinde bir nesne atıfı tarafından karşılanması durumunda bu bilgilere erişilebilir. Örneği yukarıdaki kodun sonuna aşağıdaki satır eklenseydi:

ali = veli;

Bu durumda veli tarafından atıfta bulunulan öğrenci, kendi tipinden bir nesne atıfı tarafından gösterilecek ve veli tarafından erişilemeyen değerlere erişilebilecekti.

Atama işlemleri sırasında unutulmaması gereken bir husus da, tip inkılabında olduğu gibi (type casting) aşağı akış sırasında (downcasting) mutlaka tip dönüşümü yapılması gerektiğidir. Örneğin yukarıdaki kodda bulunan bu satır JAVA dili açısından hatalıdır:

ali= veli;

Ancak bunun tam tersi atama hatalı değildir:

veli = ali;

Yukarıdaki hatalı olan atamayı düzeltmek için tip dönüşümü yapılabilir:

ali = (öğrenci) veli;

şeklinde.

179 views

Bu yazının amacı, nesne yönelimli programlama ortamlarında (object oriented programming) kullanılan iki temel kopyalama işlemini anlatmaktır.

Literatürde bir nesnenin kopyalanması için geçen iki terim bulunur:

• Sığ kopyalama (shallow copying)
• Derin kopyalama (deep copying)

Sığ kopyalama basitçe bir nesnenin referansını gösteren nesne atfının, farklı bir nesne atfına atanmasıdır. Örneğin aşağıdaki kodu inceleyelim :

public class kedi{

   int boy;

   int kilo;

}

public class test{

   public static void main(String args[]){

      kedi tekir = new kedi();

      tekir.boy = 40;

      tekir.kilo=6;

      kedi mırnav = new kedi();

      mırnav = tekir;

}

Yukarıdaki kodun son satırında bulunan mırnav = tekir; ataması (Assignment) yapılmadan önce hafızdaki (RAM) durum aşağıdaki şekildedir:

İlgili atama satırı çalıştıktan sonra mırnav ile tekir aynı adresi göstermeye başlar:

Yukarıdaki bu atamaya sığ atama (shallow copying) ismi verilir çünkü hafızada iki nesne atıfı tarafından da aynı nesne gösterilmektedir ve birisinde yapılan değişiklik diğerini etkiler. Örneğin aşağıdaki satırı ele alalım:

mırnav.boy = 35

Bu satırdan sonra tekir isimli nesne atfının da boy üyesi 35 değerine sahip olmaktadır.

Peki, atamadan önceki mirnav tarafından gösterilen ve henüz değerleri bulunmayan nesne ne olur? Sonuçta bu nesnenin içerisindeki üyelere (members) değer konulmamış olsa da (boy ve kilo değeri verilmemiştir), new operatörü ile tanımlanmış bir hafız alanı söz konusudur ve bu alan hafızada yer kaplar. Sorunun cevabı programlama diline göre değişir. Örneğin java için garbage collector isimli bir işlem devreye girerek bu alanı temizler. C++ dilinde ise bu alan uzayda kaybolur (lost in space) ve C++ programcılarının bu tip hatalara karşı dikkatli olması ve free() fonksiyonunu kullanarak hafızadan kaldırması gerekir.

Gelelim derin kopyalamaya (deep copying)

Bu durumu da aynı sınıf tanımı üzerinden (kedi sınıfı) aşağıdaki kod ile anlamaya çalışalım:

public class kedi{

   int boy;

   int kilo;

   public void kopyala(kedi x){

      this.boy = x.boy;

      this.kilo= x.kilo;

   }

}

public class test{

   public static void main(String args[]){

      kedi tekir = new kedi();

      tekir.boy = 40;

      tekir.kilo=6;

      kedi mırnav = new kedi();

      mirnav.kopyala(tekir);

   }
}

Yukarıdaki bu işlemin hafızdaki (RAM) görüntüsü ise aşağıdaki temsili resimde verilmiştir:

Yukarıda gösterilen derin kopyalama işleminin bir benzerini yapmak için yapıcı fonksiyonlardan (constructor function, inşa fonksiyonu) faydalanılabilir. Bunun için aşağıdaki kodda olduğu gibi bir yapıcı fonksiyon tanımlamak yeterlidir.

public class kedi{

   int boy;

   int kilo;

   public kedi(kedi x){

      this.boy =x. boy;

      this.kilo= x.kilo;

   }

}

public class test{

   public static void main(String args[]){

      kedi tekir = new kedi();

      tekir.boy = 40;

      tekir.kilo=6;

      kedi mırnav = new kedi(tekir);
   }
}

245 views

Quiz soruları ve çözümleri aşağıdaki şekildedir:

1. Bir oylama için program yazmanız isteniyor. Oylamaya katılan 5 aday bulunuyor ve bu adayların numarası (1′den 5′e kadar bir sayı) oy pusulasına yazılarak oy kullanılıyor. Programınızda 10 adet oyu okuyup ekrana adayların aldıkları oy miktarını basan bir program yazınız. Kullanılan oyun 1-5 arasında olmaması halinde problemi istisna yakalama ile çözünüz.

Çözüm

Oylama programında basitçe her oyun tutulduğu bir oy pusulası ve bir de oy verilen adaylar olacağını düşünebiliriz. Bu durumda oy pusulası ve aday isimli iki adet sınıf tanımlayıp bu sınıfların kodlamasını aşağıdaki şekilde yapabiliriz.

Yukarıdaki kodda, aday bilgisi tutuluyor. Programımızda olması gereken bilgi, adayın numarası ve oy sayısıdır. Biz de bu bilgileri tutan iki adet değişken tanımlıyor ve bu değişkenlerin getter/Setter fonksiyonlarını kodluyoruz. Ayrıca sınıfın inşa fonksiyonunda (constructor), başlangıç olarak oy sayısını 0 yapıyoruz. Son olarak adayların oy sayısını arttıran bir metot yukarıdaki kodun sonunda yer almaktadır. Basit bir arttırma işlemidir.

Oy pusulasını tutan kod ise aşağıdaki şekilde kodlanmıştır:

Yukarıdaki kodda, görüldüğü üzere, oy pusulasında sadece kime oy verildiği bilgisi tutulmuştur. Bu bilgiyi kapsülleme gereği getter ve setter fonksiyonları ile erişilebilir halde sınıfta kodluyoruz.

Son olarak kodumuzu test etmek için bir main fonksiyonu yazalım:

Oy okuma işlemi için “oyoku” isimli fonksiyon yazılmıştır. Bu fonksiyonun özelliği, oyları okurken yanlış bir oy girilmesi durumunda, (oyların 1 ile 5 arasında olacağını hatırlayınız) bir istisna fırlatmasıdır. Bu istisna, try bloğu içerisinden çağrıldığı yerde yakalanır ve kodun 27nci satırında bulunan catch bloğu ile ekrana bir hata mesajı basılır. Şayet oy başarılı bir şekilde okunabilirse, bu durumda ilgili oy pusulasına (ki toplam 10 adet pusula bulunuyor) oy değeri kaydedilir. Şayet bir istisna burada oluşmamışsa kodun 25. Satırına geçebiliriz. İstisna oluşması durumunda kodun 25. Satırı hiç çalışmadan catch bloğuna gidilir.

Kodumuzun 25. satırında, adayların tutulduğu nesne dizisinin (object array) ilgili elemanının (hangi elemana oy verildiyse) oy miktarını 1 arttıran oysayisiniArttir() fonksiyonu çağrılır.

Son olarak kodun 31-33 satırları arasında, adayların oy durumları ekrana basılır.

Yukarıdaki kodda bulunan ve kendi istisnamız olan hatalioy sınıfını aşağıdaki şekilde kodlayabiliriz:

1. Bir banka yazılımı için aşağıdaki özelliklerle program yazmanız isteniyor. Sistemde tutulacak veriler:
   1. Hesap sahibinin ismi
   2. Hesap numarası
   3. Bakiye
   4. Hesap tipi (vadeli / vadesiz)

Yukarıdaki hesap bilgileri için aşağıdaki işlemleri yapmanız isteniyor:

1. Hesapların ilk değer olarak bakiyesinin 0 atanması gerekir.
2. Hesaba para yatırılabilir
3. Hesaptan para çekilebilir
4. Hesap bilgisi görüntülenebilir (sahibinin ismi, numarası, tipi ve bakiyesi)

1. 2. Sorudaki programınızı, 10 müşteriye hizmet verebilecek şekilde genişletin.
2. 2. Sorudaki programınızı, hesap hareketleri görüntülenecek şekilde genişletin. Buna göre bir hesap hareketinin, tarihi, saati, miktarı ve hesap numarası bulunur.

Çözüm:

Yukarıdaki sorunun çözümü için basitçe bir hesap nesnesi oluşturmamız yeterli olacaktır. Yukarıdaki 4. soru için hesap hareketlerini tutan ilave bir sınıfa daha ihtiyacımız olacak. Öncelikle, hesapların tutulduğu bir hesap sınıfını programlayarak başlayalım.

Soruda tanımlandığı üzere, her hesap için hesapno, bakiye , hesap tipi ve hesap sahibi bilgilerini tutuyoruz. Ayrıca hesap hareketlerinden oluşan ilave bir dizi, her hareketi ayrıca kayıt altına alıyor.

Hesap sınıfımızın constructor fonksiyonunda, hesap bakiyesini 0 olarak atıyoruz.

Ayrıca sınıfımızdaki hesap hareketlerini tutan dizinin kaçıncı elemanında olduğumuz bilgisi, hhsayisi isimli değişkende durmaktadır. Bu değişken de henüz hesap hareketi olmadığı için 0 olarak atanıyor.

Sırasıyla hesap sınıfındaki metotların kodlamasını inceleyelim:

Yukarıda, hesap detaylarını ekrana basan fonksiyon verilmiştir. Fonksiyondaki 21nci satırda bulunan cout komutu ile ekrana hesabın temel 3 bilgisi bastırılmıştır. Ardında hesabın tipi yazıya çevrilerek bastırılmıştır. Hesap tipini tutmak için kullanılan int tipi, kullanıcı açısından anlamsız olabilir o yüzden yazıya çevirme işlemi yapılır.

Son olarak 27-30 satırları arasında, hesap hareketlerini bastırmak için, mevcut hesap hareketi sayısını tutan değişken kadar dönen döngü içerisinde her hesap hareketinin miktarı basılmaktadır.

Bu çıktının örneği aşağıda verilmiştir.

Yukarıdaki ekran görüntüsünde, örnek olarak bir hesabın detayları basılmış ve bu hesapta yapılan hesap hareketleri altında gösterilmiştir.

Hesap hareketi olarak kabul edilebilecek iki temel işlem para çekmek ve para yatırmak işlemleridir. Bunların kodlamasını aşağıda anlatalım:

Para çekme işlemi, belirtilen miktar kadar bakiyeyi azaltmamaktadır. Bu işlem sırasında öncelikle miktarın yeterli olup olmadığı kontrol edilir. Şayet miktar yeterli bulunursa bakiye azaltılır, şayet yeterli bulunmazsa bu durumda bir istisna (exception) fırlatılır. Burada fırlatılan istisna, proje kapsamında bizim tanımladığımız yetersizBakiye istisnasıdır.

Yetersi bakiye istisnası, basit bir şekilde bakiye bilgisini de içinde saklayan bir sınıf (class) olarak tasarlanabilir:

Hesap hareketlerinin içerisine, ayrıca miktar konulurken -1 değeri ile çarpılmaktadır. Bunun anlamı, hesap hareketinin eksi değer olarak tutulmasıdır.

Benzer kodlama, para yatırma fonksiyonunda da kullanılmaktadır. Yatırılan miktar, hesap hareketlerine işlendikten sonra, bakiye değeri parametre olarak verilen miktar kadar arttırılmaktadır.

Hesap hareketlerinin detayı için sınıf kodlamasını aşağıdaki şekilde yazabiliriz:

Bu sınıf, basit bir şekilde hesapta yapılan işlemleri tutmak için tasarlanmıştır. İlgili üyelerin getter / setter fonksiyonlarının yazılması yeterlidir.

Quiz sorularının kodlarını indirmek için tıklayınız.

438 views

Bu yazının amacı, C++ dili için fonksiyon üzerine bindirme (function overriding veya method overriding) konusunu açıklamaktır.

Üzerine bindirme işlemi, basitçe aralarında miras (inheritance) ilişkisi bulunan iki sınıf için kullanılabilir. C++ dilindeki, nesneler arasında kurulan bu ilişki modeli hakkında daha detaylı bilgi için, bu bağlantıya tıklayabilirsiniz.

Öncelikle iki sınıf tanımlayıp bu iki sınıf arasında miras ilişkisi kurulmalıdır. Bu miras ilişkisinden sonra, sınıflardan birisi, diğerine bazı fonksiyonlarını miras bırakacaktır. İşte fonksiyon üzerine bindirme de tam olarak burada devreye girer. Şayet miras alınan fonksiyonlar alt sınıfta yeniden tanımlanmak isteniyorsa, bu duruma üzerine bindirme (overriding) ismi verilir.

Örneğin, dikdörtgen olarak tanımlı bir sınıfımız bulunsun.

class dikdortgen{

public:

   int x,y;

   int boy,en;

public:

   int alan();

};

int dikdortgen::alan(){

   return en *boy;

}

Yukarıdaki bu tanıma uyan diğer bir iki boyutlu şekil ise, kare’dir. Bilindiği üzere kare kenarları birbirine eşit bir dikdörtgendir. O halde kare sınıfını aşağıdaki şekilde tanımlayabiliriz.

class kare:public dikdörtgen{ // kare sınıfı, dikdörtgen sınıfından miras alır.

public:

   int alan();

};

kare::alan(){

   return en * en ;

}
};

Yukarıdaki kare sınıfında görüldüğü üzere, her kare’nin zaten sahip olduğu x,y koordinatları ve en, boy bilgisi yeniden kodlanmamış bu bilgiler miras ile alınmıştır. Alan hesaplamak için yazılan alan() fonksiyonu ise, yeniden yazılmıştır. Bunun sebebi kare sınıfında sadece tek kenar bilgisinin yeterli olması ve bu durumda alan hesabının değişmesidir.

Şayet kare sınıfı için, yeniden alan fonksiyonu yazılmasaydı, dikdörtgen sınıfının alan fonksiyonunu kullanabilirdi. Ancak buradaki yeniden yazılan aynı isme ve parametrelere sahip olan alan fonksiyonu, üzerine yükleme işlemi yapmıştır (overriding).

Yukarı Atamak (Upcasting)

Miras ilişkisi içerisinde bulunan iki sınıftan tanımlanan iki nesne arasında atama yapılabilir. Örneğin yukarıdaki kodu ele alalım ve bu kodla oluşan sınıf diyagramını çizmeye çalışalım:

Yukarıdaki bu çizimden anlaşılacağı üzere, her kare bir dikdörtgendir ifadesi kullanılabilir. Bu ifade aynı zamanda dikdörtgen sınıfının, kare sınıfının atası olduğu, veya kare sınıfının, dikdörtgen sınıfının bir çocuğu olduğu şeklinde de yorumlanabilir.

Yukarıdaki bu ilişki şeklinde, bizim için dikdörtgen sınıfı üst, kare sınıfı ise alt sınıf olarak kabul edilebilir. Bu durumda kare sınıfından bir nesnenin, dikdörtgen sınıfından bir nesneye atanmasına upcasting ismi verilir. Burada nesne olduğu gibi kalmakta ancak nesne göstericisi (object referrer) farklı bir sınıftan olmaktadır. Bu işlemin kod olarak karşılığı aşağıdaki şekildedir:

dikdörtgen *d = new kare();

Görüldüğü üzere kare sınıfından tanımlanan bir nesne, dikdörtgen sınıfından bir nesne göstericisi tarafından gösterilmiştir. Bu kullanım, tip belirsizliği yaşanan durumlarda sıklıkla konu olur. Örneğin kodlamak istediğimiz fonksiyon, bir parametre olarak dikdörtgen alıyor ve bu dikdörtgenin orjine (merkez 0,0 noktasına) uzaklığını ölçüyor olsun. Bu durumda fonksiyonumuz aşağıdaki şekilde olabilir:

int mesafe(dikdörtgen *d){

   return sqrt(x*x+y*y);

}

Yukarıdaki bu fonksiyon, her türlü dikdörtgeni kabul etmektedir. O halde bu fonksiyona bir dikdörtgen nesnesi veya bir kare nesnesi, parametre olarak verilebilir.

Upcasting işlemi, sanal fonksiyonların kullanımı açısından önem taşır.

Sanal Fonksiyonlar (Virtual Functions)

Yukarı atama işlemi sırasında yaşanan bir problem, yukarı yükleme işlemi sonrasında, nesnenin bir fonksiyonu çağırıldığında, ata sınıfından mı çocuk sınıfından mı fonksiyonun çalışacağıdır.

Örneğin, yukarıdaki miras konusunu ele alalım. Dikdörtgen sınıfından bir nesne göstericisinin içerisine, kare sınıfından bir nesne atanmıştır. Şimdi bu atamadan sonra

d->alan();

şeklinde bir fonksiyon çağırımı yapılırsa, acaba kare sınıfının mı, dikdörtgen sınıfının mı alan fonksiyonu çalışacaktır?

Herhangi özel bir durum olmaksızın, yukarıda yazdığımız kodlar için, d->alan() çağrımı, ata sınıfında (base class, ancestor, parent) olan alan fonksiyonunu çalıştıracaktır.

Peki acaba çocuk sınıftaki alan fonksiyonun çalışmasını isteseydik kodu nasıl değiştirmemiz gerekirdi?

Sınıf tanımı sırasında, ata sınıfta bulunan fonksiyonu tanımlarken başına virutal eklenmesi, bu sınıfın ileride bir şekilde üzerine yükleme yapıldığında (override), ve ayrıca yukarı atama yapıldığında (upcasting), üzerine yükleme yapılan fonksiyon tarafından çalıştırılacağıdır.

Örnek olarak yukarıdaki sınıf tanımını aşağıdaki şekilde değiştirirsek,

class dikdortgen{

public:

   int x,y;

   int boy,en;

public:

virtual int alan(){

   return en*boy;

}

};

Bu yeni tanımdan sonra yukarı atama yapılırsa,

dikdörtgen *d = new kare();

artık d göstericisinin alan fonksiyonu çağırıldığında,

d->alan();

çalışacak olan alan fonksiyonu, kare sınıfındaki alan fonksiyonudur. Çünkü dikdörtgen sınıfında bulunan alan fonksiyonu sanal bir fonksiyondur (virtual function).

287 views

C++ programlama dili, nesne yönelimli olmasından dolayı çok şekillilik (polymorphism) özelliğini destekler. Çok şekillilik (polymorphism) bir işin farklı şekillerle yapılabilmesidir. Örneğin bir metodun farklı şekillerde çağrılabilmesi, çok şekillik özelliği ile mümkündür. Bu yazıda, metotların ve işlemlerin (operators) üzerine yüklenmesi (overloading) anlatılacaktır.

Amacımız bir fonksiyonu farklı şekillerde çalıştırabilmektir. Nesne yönelimli özelliği olmayan dillerde, bir fonksiyon tek bir isimle bir kere tanımlanabilir. Örneğin aşağıdaki dikdörtgenin alanını hesaplayan fonksiyonu ele alalım:

int alan(int a, int b){

   return a*b;

}

Yukarıdaki fonksiyon gayet başarılı bir şekilde a ve b kenarları verilen dikdörtgenin alanını hesaplar. Ancak aynı alan hesabını örneğin float sayılar için düzenlemek istesek ve verilen değere göre çalışmasını istesek:

float alan (float a, float b){

   return a*b;

}

Şeklinde yazılan fonksiyon, aldığı parametreler itibariyle, farklı bir fonksiyon iken, nesne yönelimli özelliği bulunmayan dillerde, bu iki fonksiyonu aynı anda kodlamamız mümkün olmaz.

Benzer şekilde, her kare bir dikdörtgendir mantığıyla, tek kenar uzunluğu verildiğinde alan hesaplamak istersek

int alan(int a){

   return a*a;

}

Fonksiyonu, bir karenin alanını başarılı bir şekilde hesaplayabilrken, daha önceden tanımlı olan fonksiyonlarla çakışmaktadır.

C++, JAVA veya CSharp gibi diller için yukarıdaki bütün bu fonksiyon tanımları farklı anlama gelmektedir ve tek bir sınıf (class) içerisinde tanımlanabilir. Örneğin aşağıdaki C++ sınıfını ele alalım

class dikdörtgen{

 public:

   int a,b;

 public:

   int alan(int a,int b);

   float alan(float a,float b);

   int alan(int a);

};

Yukarıdaki bu tanımlama, C++ dili açısından problemsiz bir tanımdır ve hangi alan fonksiyonunun çalıştırılacağı, verilen parametrelere göre algılanır.

Örneğin yukarıdaki tanımlardan sonra aşağıdaki main fonksiyonunu yazarsak:

int main(){

   dikdörtgen *d = new dikdörtgen();

   cout << d->alan(3,4) << endl << d->alan(2.2,7.8) << endl << alan(5) << endl;

}

Yukarıdaki kod, sorunsuz bir şekilde üç ayrı fonksiyonu çağırarak çalıştırır.

Yukarıdaki örnekte yapılan işlem, alan isimli fonksiyonun üzerine yüklenmesidir (overloading). Yani aynı isme sahip birden fazla fonksiyon tanımlanmış ve bu fonksiyonların parametre tipleri veya parametre sayılarına göre farklı durumlar için yeniden kodlanmıştır. Bu anlamda üzerine yükleme işlemi bir çok şekillilik işlemidir (polymorphism) ve aynı işi yapan birden fazla şekilde çalışmaya izin verir.

Üzerine yükleme işlemi, fonksiyonların yapıcıları (constructors) için de kullanılabilir. Örneğin dikdörtgen tanımı sırasında farklı bilgiler ile bir dikdörtgenin tanımlanacağını düşünelim.

• Dikdörtgen hakkında hiçbir bilgi vermeyebiliriz
• Dikdörtgenin kenarlarını verebiliriz
• Dikdörtgenimiz özel olarak bir kare olabilir ve tek kenarını verebiliriz.

Yukarıdaki bu üç farklı durum için, dikdörtgen tanımını değiştirmemiz gerekir. Bu durumda olası, yapıcı fonksiyonlarımız (constructors) aşağıdaki şekilde olabilir :

public:

dikdörtgen(){

   a=0;b=0;

}

dikdörtgen(int a){

   this->a = a; b= 0;

}

dikdörtgen(int a,int b){

   this->a=a;

   this->b=b;

}

Benzer bir üzerine yükleme işlemi de, işlemler (operators) için yapılabilir. İşlem üzerine yükleme (operatör overloading) için bağlantıdaki yazıyı okuyabilirsiniz .

255 views