Yazarlar Sözlük Makaleler Yardım Masası Gözlük Forum İstatistik

Yardım Masası

SORU: Php de OOP
PHP de OOP kullanmaya çalışıyorum. Deneme amaçlı olarak (makalelerde anlatıldığı gibi) bir sınıfı tanımladıktan sonra klasik olarak get ve set metodlarını da tanımlayıp sınıfa bilgi giriş çıkışını sağladım. Şimdi buraya kadar herşey klasik OOP makalelerinde anlatıldığı gibi.. Ama gerçek bir uygulama yaparken iş burada bitmiyor maalesef..

Şimdi, PHP de veritabanı olarak MySQL kullanıyorum. MySQL'e veri gönderip çekmek için de mysql isminde bir sınıf yazdım. Bu sınıf baglan, ekle, duzenle, sil ve guncelle metodlarından oluşuyor.. Normalde ekle metoduna ($_POST) parametresini göndererek formdan gelen bilgileri sınıfın içinde tanımlı olan alanlara bakarak alıyor ve Mysql e ekliyorum. Güncellemede $id'yi ve $_POST'u silmede ve düzenlemede ise sadece $id'yi gönderiyorum. Bu kısmı sadece ileride bu sınıfı kullanırken takıldığım sorunları yazmak için açıklayıcı bilgi olarak verdim..

Bu kadar açıklamadan sonra sırasıyla sorularımı sorayım..
Mesela bir kütüphane programı yazdığımızı varsayalım. OOP ile o kadar makale okuduktan sonra OOP ile yapmak farz olmuştur diyerek kodlamaya başlayalım.. OOP'nin varsayımı olarak gerçek hayat birebir modelleneceği için öncelikle bir kütüphaneci ve bir de kitap nesnesi konması gerekiyor. (Başka nesneler de olabilir ama ben bunları bile aşamadığım için şimdilik yeter..)

Kitap nesnesi veritabanına eklemek istediğimiz kitabın bilgilerini içereceği için post ile gelen bilgileri öncelikle ona depoluyoruz. (Set metodu ile..) Daha sonra kitap kendini kütüphaneye ekleyemeyeceği için kütüphaneci arkadaşa bir ekle metodu yazmalıyım. Hazır elimde mysql sınıfı olduğu için kütüphaneci arkadaşı bu nesneden türettim. (Sanırım [Gerçekten emin değilim]) buraya kadar herşey normal ve anlaşılabilir) Ama sorunlar burada başlıyor..

1-) Şimdi formdan gelen bilgileri mysql'e depolamak amacı ile aldığıma göre neden kitap nesnesini kullanmak zorundayım. Yani ondan ona diye verileri dolandırmak yerine neden direk mysql (kutuphaneci demiyorum) sınıfından bir nesne türeterek sonuca gidemiyorum. Yani formdan gelen verileri evvela bir nesneye set edip, oradan da başka bir nesnenin metoduna parametre olarak göndermek sol kulağı sağ elle tutmak gibi bir şey değil mi? Eğer değilse neden? (kitap nesnesinin set metodunda gelen veriler kontrol filan edilecek deniyorsa ben zaten mysql sınıfının ekle motodunda bu işlemleri bir kez tanımladım. Bunu her sınıfta tekrar etmeye ne gerek var).

2-) PHP ile yazacağım programların 'ı (hatta 0'ü) Mysql kullanacağı için, bana bir gün içerisinde kullanılabilir hale getirdiğim mysql nesnesi ömür boyu yetecek mi? Eğer yetmeyecek ise bu nesnenin dışında daha başka hangi nesneler hangi amaçlarla işime yarayabilir..

Açıklamayı uzun, soruları kısa tutma nedenlerim
1- Soruma cevap gelirse diğer postlarda ayrı ayrı açıklamalarla uğraşmamak
2- OOP hakkında bildiklerimi (ya da bildiğimi sandıklarımı) sizlerin görüşlerinize sunarak var olan yanlışlarımı düzeltmenize imkan sağlamak..
3- Ve en önemlisi, bir postu bu kadar uzun tutupta okuyacak olan insanların sabır sınırlarını zorlamamak.


Cevaplar

1.  Soruyu ekleyeceğim sıralar makinemde bir sorun olduğundan dolayı soruyu benim adıma BaRNeY eklemişti. Eğer soruda okunduğunda anlaşılmayan (ve muhtemelen bu nedenle cevaplanamayan) bir yer varsa daha açıklayıcı mesajlar atabilirim. Elimde bir iş var ve tamamını OOP ile yapmak istediğimden dolayı bu işte tıkandığın bu noktaları öğrenmek zorundayım. Cevap yazacak arkadaşlara şimdiden teşekkürler..
allenscoot
16 Eylül 2006 11:58
2.  Bu soru çok generic. Yani cevap vermek için makale yazmak gerekiyor. İlk sorduğunuzda cevap yazmaya teşebbüs etmiştim, baktım çok uzamaya başladı. Sonra kazara bir linke tıkladım yazdıklarım uçtu. :)

Yalnız şunu söyleyebilirim;
OOP sadece bir tekniktir. OOP ile yapılan şeyler prosedürel programlama ile de yapılabilir. Bu iki teknikten birini kullanarak yazılım geliştirebilirsiniz. Özellikle veritabanı uygulamaları için prosedürel yaklaşıma daha uygundur.

Mesela 3D Studio MAX gibi bir programı OOP ile yazmak daha mantıklıdır. Çünkü nesneler var, özellikleri ve davranışları var. Ama bir ERP programını OOP ile yazmak daha zordur. Object relational mapping gibi şeylerle uğraşmak zorunda kalırsınız.
fizikci
19 Eylül 2006 12:33
3.  Hocam cevabın için saolasın. Bundan sonra yazarken daha dikkatli ol :).

Aslında ben bu soruyu buraya atarken, birinin kafamda dönüp duran bu sorunu direk çözmesini beklemiyordum. Sadece "senin sorun yanlış" ya da "şurda yanlış bir mantık kurdun" ya da "bilmiyoz kardeş" gibisinden bir cevap bekliyom. Yoksa herkes herşeyi bilmek zorunda değil ama benim gibi bir adam da yanıt alamayınca haliyle üzülüyo.

Cevabınıza dönersek şimdi oop ile yapılabilen herşey prosedürel yakşalımla yapılabilir ve terside geçerli olan bir mantıkdır. Buraya kadar sizinle hem fikirim. Zaten prosedürel yaklaşımla şimdiye kadar çözemediğim bir sorun yok. OOP ye takma nedenim de bu (bazı şeyleri becerememiş olmam). Yani bunda da herşeyin yapılması gerek diye düşünüyorum. Yani OOP de herşeyi nesne gibi gördüğümüze göre mysql bağlantısını sağlayacak bir nesne olmadılır bence.. Zaten bu nesneyi de yazdım ama yukarıda uzunca yazdığım şimdide kısaca soracağım gibi

Kitap nesnesinin $ad, $yazar vb.. özelliklerine değer atadıktan sonra bunları mysql'e ekle demekle bir mantık hatası yapıyoruz, öyle değil mi? Yani hem bilgileri nesneye depoluyoruz hem de vt ye. Aynı işi 2 defa yapıyoruz.. Bu gibi durumlarda sizin gibi deneyimli yazılımcılar ne gibi şeyler yapıyolar. Yoksa veritabanı işlemlerinde oop kullanma fikrine tamamen karşımısınız ve kullanmıyor musunuz?..
allenscoot
19 Eylül 2006 13:57
4.  Şu an çalıştığım şirkette bir ERP çözümü geliştiriyoruz.* Sonuçta bir veritabanı uygulaması. Siparişler, faturalar, malzemeler, müşteriler, hepsi veritabanına kaydediliyor. Ama çalışma sistemimiz şöyle: Veritabanına kaydedilebilen herhangi bir bilgi parçasını bir OOP sınıfı olarak tanımlıyoruz. Örneğin;

class Malzeme {
    var $kodu;
    var $adi;
    var $deposu;
}
class Siparis {
    var $tarih;
    var $musteri;
    var $toplamTutar;
}
class SiparisSatiri {
    var $malzeme;
    var $miktar;
    var $birimFiyat;
}
vs.. vs..

Bunun gibi yüzlerce sınıfımız var. Aslında bunların herbiri veritabanında bir tabloya karşılık geliyor. Bunlara entity (varlık) diyoruz. Bu sınıflara ait instancelar (örnekler) ise tablonun satırlarına karşılık geliyor. Ayrıca Database adında bir sınıfımız var. Bu sınıfın insert(), update(), delete() gibi metodları var ve entity'lerimizi parametre olarak alıyorlar. Şunun gibi;

$malzeme = new Malzeme();
$malzeme->kodu = "HP-390";
$malzeme->adi = "HP Laser Printer";

$db = new Database();
$db->insert($malzeme);

insert metodu kendisine parametre olarak gelen nesnenin tipine bakıyor ve ona uygun bir insert SQL'i üretiyor (ya da daha önce üretilmiş* insert SQL'ini kullanıyor) Bu insert SQL'i çalıştırılarak, malzeme, veritabanına kaydediliyor.

Peki ama neden malzemeyi class olarak tanımladık ki? Direk veritabanına kaydedebilirdik.

Direk veritabanına kaydetmek demek
mysql_query("insert into malzeme values('HP-390', 'HP Laser Printer')");
gibi bir kod yazmak demektir. Bu durumda örneğin ileride tablonun fieldlarının yerini değiştirdiğinizde, ya da bir field'ı kaldırıp, diğerini eklediğinizde bu kodlarınız geçersiz olacaktır. Eğer bu işi generic bir sınıfın (Database) generic bir metoduna (insert) havale ederseniz, ve elinizle kodunuzun sağına soluna SQL'ler yazmamaya çalışırsanız daha maintainable bir uygulamauya sahip olacaksınız demektir.

Ayrıca şöyle bir kural koyabilirsiniz: Bütün entity sınıfları Entity adında bir base class'tan türetilecek ve ve bu class'ın validate() metodunu override edecek. Validate metodu entity'ye girilen değerlerin geçerli olup olmadığını inceleyecek geçersizse exception fırlatacak. Yani şöyle:

class Entity {
    var $id;            // bütün entity'lerin id'si olmalıdır.
    var $insert_date;   // bütün entity'lerin kayıt tarihini saklar
    var $insert_user;   // entity'yi kim insert etti?
    var $update_date;   // bütün entity'lerin update tarihini saklar
    var $update_user;   // entity'yi en son kim update etti?

    function validate()
    {
        if($this->id<0)
            throw new Exception("entity'ler 0'dan küçük id'ye sahip olamaz!");
    }
}

class Siparis extends Entity  // bütün entity'ler Entity'den türetilir.
{
    var $tarih;
    var $musteri;

    function validate()   // Entity'nin validate'ini override ediyoruz.
    {
        parent::validate(); // önce bir üst sınıf valid mi bakalım?

        if(!isset($musteri))
            throw new Exception("Müşterisi belli olmayan sipariş olamaz!");

        if(!isset($tarih))
            throw new Exception("Tarihsiz sipariş olmaz.");
    }
}

Bu aşamada nesne yönelimli tasarımımızı biraz daha detaylandırdık. Artık her bir sınıfın kendi datasını kontrol etmesini sağlayabiliyoruz. Bu kontrol işi Database sınıfının insert ve update metodlarında kullanılmalıdır. Şöyle;

class Database
{
    function insert($entity)
    {
        $entity->validate(); // önce gelen entity'yi kendisine kontrol ettirelim

        // insert edilecek entity'nin id'si sıfır olmalıdır. bakalım:
        if($entity->id!=0)
            throw new Exception("Id'si sıfır olmayan bir entity insert edilmek isteniyor!");

        // buraya kadar gelebildiysek problem yok demektir, entity'yi kaydedelim.
        ... insert into bik bik
        ... cik cik
    }
}


Dikkat ederseniz nesne yönelimli programaya ait inheritance (kalıtım), polymorphism (çok biçimlilik) gibi disiplinleri kullanmaya başladık. Bu şekilde veritabanı uygulamız OOP teknikleriyle daha okunabilir*(sınıfların ayrı ayrı olması okumayı, anlamayı kolaylaştırıyor), daha bakımı kolay*(her yere SQL yazmadığımız için bakım kolaylaşır), daha ölçeklenebilir*(Database sınıfı ve Entity sınıfı gibi merkezi yapılar kullanıcı sayısının artması durumunda cache gibi yapıları implement etmemize imkan sağlar) olmuş oldu.

Peki aynı şeyler prosedürel programlama ile yapılamaz mıydı? Elbette yapılabilirdi. Ama bu durumda örneğin polymorphism'i switch..case ile sağlamak durumunda kalacaktık. Daha mı kötü? Kesinlikle hayır. Daha önce de dediğim gibi, bu iki tekniğin birbirine üstünlüğü yok. Sadece tat meselesi. Hangisinden hoşlanıyorsanız (daha önemlisi hangisini daha iyi biliyorsanız) onu kullanmalısınız.

Not: ERP projemizi PHP ile geliştirmiyoruz. Sadece burada konuya uygun olsun diye PHP örnekleri yazdım. :)
fizikci
19 Eylül 2006 15:28
5.  @fizikci gerçekten uzun uzun cevaplar yazman çok hoş, sana da çok zahmet verdiriyom ama belki yine bu meseleye takılacak bazı insanlar olur ve onlarda bunlardan faydalanırlar..

class Malzeme {
    var $kodu;
    var $adi;
    var $deposu;
}


ile malzeme sınıfına ait alanlar tanımlamak bana anlamlı gelmiyor. Malzemeye gelecek olan değerler belli ki (php için konuşuyorum) ya $_POST ya da $_GET ile gelecek. Biz $_POST ile gelen veriyi önce malzeme sınıfına daha sonrada kaydedilmesi için Database sınıfının insert() metoduna parametre olarak gönderyoruz.. Benim de takıldığım nokta burası zaten, aynı işlemi iki kez yapmıyo muyuz? (Önce malzeme sınıfna $this->kodu = $_POST['kod']; gibisinden ekleyip. Daha sonra Db->insert($malzeme) diyerek aynı bilgileri 2 kez atamıyo muyuz?) Eğer kontrol var deseniz (ki aslında insert() metodunun kendinde kontrol var, yani malzeme sınıfı görünüşte bir işe yaramıyor - tabii bana göre- ) neden kontrol insert() metodunda değilde malzeme metodunda yapılmıyo vb..

Senin yolladığın kodlara ne kadar benzer bilmiyorum ama ben de nesneleri kullanıcam diye bir kaç şey yazmıştım..

Mysql sınıfım.. (Sendeki Database sınıfına denk geliyo) vt.php

<?
class mysql {
   
    function vt_bagla () {
        $ok = mysql_pconnect ("localhost", "root","deneme");
        mysql_select_db($this->vt);
        return $ok;
    }

    function mysql () {
        $this->vt = "oop";
        $this->tablo = "ktp";
        $this->alanlar = array ("ad", "yazar", "sayfa");
        $this->tekrar = array ("ad");
    }
   
    function listele ($sec = "*", $sart = NULL) {
        $this->alanlar = array();
        global $bagla, $sorgu;
        if (!empty($sart)) {
            $kosul = "where $sart";
        }

        $bagla = $this->vt_bagla($this->vt);

        $sorgu = "select ";
        for ($i=0; $i<count($sec); $i++) {
            $sorgu .= " $sec[$i], ";
        }
       
        $sorgu = rtrim($sorgu, ", ");
        $sorgu .= " from $this->tablo $kosul";
        $sonuc = mysql_query ($sorgu);
       
        while ($veri = mysql_fetch_assoc($sonuc))
            $this->liste[] = $veri;
           
        return $this->liste;
    }
   
    function goster($veri, $en=400) {
        echo "<table align='center' border=1 cellspacing=0 cellpadding=0 width=$en> \n";
        for ($i=0; $i<count($veri); $i++) {
            echo " <tr> \n ";
            while ( list ($alan, $deger) = each($veri[$i])) {
                echo "<td> ".$deger." </td> ";
                if ($alan=="id") $x=$deger;
            }
            echo "<td> <a href='?is=duzenle&id=".$x."'>Dzn</a> </td>  <td> <a href='?is=sil&id=".$x."'>Sil</a> </td> </tr> \n ";
        }
    echo "</table> \n";

    }
   
    function duzenle ($id) {
        $this->alanlar = array();
        global $bagla, $sorgu;
        $bagla = $this->vt_bagla($this->vt);

        $sorgu = "select * from ".$this->tablo;
        $sorgu = rtrim($sorgu, ", ");
        $sorgu .= " where id=".$id;
        $sonuc = mysql_query ($sorgu);
        $this->dzn = mysql_fetch_assoc($sonuc);
        return $this->dzn;
    }

    function kontrol($id = NULL)     {
        global $bagla, $sorgu;
        if (!$bagla) $bagla = $this->vt_bagla ($this->vt);
        $sorgu = "select id from ".$this->tablo." where ";
       
        for ($i=0; $i<count($this->tekrar); $i++) {
            $sorgu .= $this->tekrar[$i] ."= '".$_POST[$this->tekrar[$i]]."' and ";
        }
        $sorgu = rtrim( $sorgu, "and ");
        if (isset($id)) $sorgu .= " and id <> ".$id;
        $sonuc = @mysql_num_rows ( mysql_query ($sorgu));
        if ($sonuc==0) return true;
        else return false;
    }
   
    function ekle($post) {

        global $bagla, $sorgu;
        if (!$bagla) $bagla = $this->vt_bagla ($this->vt);
       
        if (!$this->kontrol())
            die ("Veritabanında Aynı Kayıttan Olduğu İçin Bilgi Eklenemiyor..");

        $alanlar = $this->alanlar;
       
        foreach ($post as $alan => $deger) {
            if (!in_array($alan,$alanlar))
                unset($post[$alan]);
        }

        $sorgu = "insert into ".$this->tablo." set ";

        foreach($post as $alan => $deger)
            $sorgu .= "$alan='$deger', ";

        $sorgu = rtrim ($sorgu, ', ');

        $sonuc = mysql_query ($sorgu);
        if (!$sonuc)
            echo "Kayit Eklerken Bir Sorunla Karsilasildi Lütfen tekrar deneyiniz.. <br> $sorgu";   
    }

    function guncelle($post, $id) {

        global $bagla, $sorgu;
        if (!$bagla) $bagla = $this->vt_bagla ($this->vt);
       
        if (!$this->kontrol($id))
            die ("Veritabanında Aynı Kayıttan Olduğu İçin Bilgi Güncellenemiyor..");

        $alanlar = $this->alanlar;
       
        foreach ($post as $alan => $deger) {
            if (!in_array($alan,$alanlar))
                unset($post[$alan]);
        }

        $sorgu = "update ".$this->tablo." set ";

        foreach($post as $alan => $deger)
            $sorgu .= "$alan='$deger', ";

        $sorgu = rtrim ($sorgu, ', ');
        $sorgu .= " where id=".$id;
        $sonuc = @mysql_query ($sorgu);
        if (mysql_errno <> 0)
            echo "Kayit Güncellerken Bir Sorunla Karsilasildi Lütfen tekrar deneyiniz.. <br> $sorgu";   
    }
   
    function sil($id) {
        global $bagla, $sorgu;
        if (!$bagla) $bagla = $this->vt_bagla ($this->vt);
       
        $sorgu = "delete from ".$this->tablo." where id=".$id;
        $sonuc = mysql_query($sorgu);
        if ($sonuc) return;
    }

}

?>


Database sınıfından türetilen kutuphaneci sınıfımla, sendeki malzeme sınıfına denk gelen kitap sınıfım class.php

<?
include ("vt.php");

class kutuphaneci extends mysql {
}
   
class kitap {
    var $ad, $yazar, $sayfa;
   
    function kitap ($k_ad, $k_yazar, $k_sayfa) {
        $this->ad = $k_ad;
        $this->yazar = $k_yazar;
        $this->sayfa = $k_sayfa;   
    }
}
?>


Tüm bunlarla oluşturduğum index.php dosyam..

<?
include ("class.php");
$x = new kutuphaneci();
$x->vt_bagla("ktp");

switch ($is) {
case "sil" :
    $x->sil($id);
header("location: ?is=yeni");
break;
case "ekle" :
    $ktp = new kitap($ad, $yazar, $sayfa);
    if ($id)
        $x->guncelle($ktp, $id);
    else
        $x->ekle($ktp);
header("location: ?is=yeni");
break;
}


if ($is=='duzenle' or $is='yeni') {
?>
<form id="form1" name="form1" method="post" action="?is=ekle">
<br />
<br />
<table align="center" width="400" border="0" cellspacing="0" cellpadding="0">
<?
    if ($is=='duzenle') {
        extract($x->duzenle($id));
        echo "<input type='hidden' name='id' value='".$id."'";
    }
?>
  <tr>
    <td>Kitap Adı : </td>
    <td><input type="text" name="ad" value="<?=$ad?>" /></td>
  </tr>
  <tr>
    <td>Yazarı : </td>
    <td><input type="text" name="yazar" value="<?=$yazar?>" /></td>
  </tr>
  <tr>
    <td>Sayfa Sayısı : </td>
    <td><input type="text" name="sayfa" value="<?=$sayfa?>" /></td>
  </tr>
    <tr>
    <td colspan="2" align="center">
      <input type="submit" value="Bilgileri Ekle" />
</td>
    </tr>
</table>
<br />
<br />
</form>
<?
} # end duzenle..
$x->goster($x->listele());
?>


Görülüyorki mantık aynen birbirine benziyor ama dediğim gibi kafam hala senin malzeme sınıfına neden değer atamak için uğraştığında? Yani değişkenleri önce bir kaba koyuyoruz sonra hiçbir değiiklik yapmadan diğer bir kaba konması için bir sınıfa parametre olarak gönderiyoruz. Aynı işi tekrar yapmanın mantığı nedir. Mesela sen yazmışsın her tabloya karşılık gelen bir sürü sınıf var. Bu kadar sınıf yazmayıpta, değişkenleri direk $db->insert() metoduna dizi olarak atasaydın ne olurdu??
allenscoot
19 Eylül 2006 16:21
6.  yaw yukarıdaki mesaj biraz uzun kaçmış kusura bakmayın. kısaca özetleyeyim..

$malzeme = new Malzeme();
$malzeme->kodu = "HP-390";
$malzeme->adi = "HP Laser Printer";

$db = new Database();
$db->insert($malzeme);

satırları yerine
$db = new Database();
$db->tablo_adi = "malzeme";
$db->insert("HP-390", "HP Laser Printer");

demenin ne mahsuru var demek istedim sadece..
allenscoot
19 Eylül 2006 16:28
7.  Hiç bir mahsuru yok. Hatta öyle yapman daha iyidir. Niye her tablo için bir tane class tanımlamak için uğraşasın ki?

Ama bir başka programcı da diyecektir ki; kodunun okunabilirliği, düzeni açısından her birini sınıf yapman daha iyi olur.

Biz şimdi iki yaklaşımda da insert metodunu kod yazarak inceleyelim. Hangisi size daha hoş görünüyorsa onu kullanın:

1. OOP modeli :

class Database
{
    function insert($entity)
    {
        $entity->validate();

        // foreach ile alanları dolaşarak insert işini yap
        // yukarıdaki mysql sınıfındaki ekle() fonksiyonunda olduğu gibi
    }
}

2. Prosedürel model :

function insert($tabloAdi, $postData)
{
    validate($tabloAdi, $postData);

    // foreach ile alanları dolaşarak insert işini yap
    // yukarıdaki mysql sınıfındaki ekle() fonksiyonunda olduğu gibi
}

function validate($tabloAdi, $postData)
{
     switch($tabloAdi)
     {
         case "Malzeme": // postData ile gönderilen verileri Malzeme olarak kontrol et
         case "Musteri": // postData ile gönderilen verileri Musteri olarak kontrol et
         case "Siparis": // postData ile gönderilen verileri Siparis olarak kontrol et
         case "Fatura":  // postData ile gönderilen verileri Fatura olarak kontrol et
     }
}

Bu iki yöntem arasındaki fark nedir? İkisi de generik bir şekilde insert işini yapıyor. Bu açıdan bir farklılık yok. Ama girilen verinin doğruluğunun kontrolü (validation) işlemi farklı.
- Prosedürel yaklaşımda validation bir fonksiyon içerisinde switch..case yapısıyla yapılıyor.
- OOP yaklaşımında ise her entity'nin kendi validate() fonksiyonu var.

İşte bu, iki teknik arasındaki temel farklılıklardan biridir. Ve tamamen tat meselesidir. Kimse birinin diğerine üstün olduğunu iddia edemez, etmez de. (acemiler hariç)

Sizin üzerinde durduğunuz konu; "zaten $_POST içinde duran verileri neden bir de class'a aktarayım" konusu, çok önemli değil. Gerekirse $_POST'daki değerleri sınıfa aktaran generik bir fonksiyon yazabilirsiniz. O işin teferruatı.

OOP ile prosedürel programlama arasındaki önemli fark şudur:
- OOP'da veri ile davranış (data & behavior yani fieldlar & metodlar) bir arada durur. Okuması daha kolaydır.
- Prosedürel programlamada veriler record tipi yapılarda saklanır. Verilerin metodları yoktur. Metodları yazar, verilerinizi bu metodlara parametre olarak gönderip çalışmasını sağlarsınız.

Her şeyde olduğu gibi yazılımda da tutuculuk gereksiz, faydasız hatta zararlı bir davranıştır. Eğer kullandığınız dil hem OOP'yi hem de prosedürel programlamayı destekliyorsa ikisinden de mümkün olduğunca, bilginiz ölçüsünde faydalanmaya çalışmalısınız.
fizikci
19 Eylül 2006 17:46
8.  Tamamdır Hocam konu kapanmıştır. Dediğiniz gibi deneyip sonucu bir alayım. İlginiz ve bilgilendirici yazılarınız için teşekkür ederim..
allenscoot
19 Eylül 2006 17:54
Bu konuda bildiklerinizi bizlerle paylaşabilirsiniz
Tabi bunun için yazarsanız giriş yapmalı, yazar değilseniz yazar olmalısınız.


Bu başlığa bkz veren girişlerin başlıkları nedir?

Bu başlığa bkz veren girişler başka hangi başlıklara bkz verdiler?
© 2005, Bilişim Kulübü. (1078 ms)
Ne yapabilirsin: SubtitleClick ile İngilizceni Geliştir, Çınar Framework ile kod yaz, Eglencelik.org'ta biraz eğlen