Merhaba,

D dilinde sınıf tanımı yaparken public, private gibi erişim belirteçlerini kullanabiliyormuyuz. Örneğin aşağıdaki kodda class önündeki public belirtecinin bir anlamı var mı?

public class BirSınıf
{
	public this()
	{
		// Ben bir kurucuyum, bu sınıftan oluşturulacak nesneyi
		// kullanım için hazırlarım.
	}
}

Diğer bir sorum, sınıfları türetilmeye karşı kapatabiliyormuyuz. Örneğin C# dilinde **sealed **olarak işaretlenen sınıflardan türetilme yapılamıyor. Böyle bir şey D sınıfları içinde mümkün mü?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Hocam, hazır konu açılmışken; package {} olayını da bir irdeleyebilir miyiz?

Örneğin:

import std.stdio, std.string;

package {
   class Saat {
       int saat;
       int dakika;
       int saniye;

       this (int d, int s = 0)
       {
           this.saat = d/60;
           this.dakika = d%60;
           this.saniye = s;
       }

       override string toString() const
       {
           return format("%02s:%02s:%02s", saat, dakika, saniye);
       }
   }

   class Ortanca {

   }

   final class Sonuncu : Saat {
       this (int saat, int dakika, int saniye) {
           super(dakika + (saat * 60), saniye);
       }
   }
}

package {
   class deneme : Saat {
       this (int saat, int dakika, int saniye) {
           super(dakika + (saat * 60), saniye);
       }
   }
}

void main() {
   auto geceYarısı = new Saat(30);
   auto yenibirSaat = new Sonuncu(1, 23, 45);
   auto bozukSaat = new deneme (0, 0, 0);

   writeln(geceYarısı, "\n",
           yenibirSaat, "\n",
           bozukSaat
          );
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zafer):

Evet, anlamı var ama o sınıfın nerede tanımlandığına bağlı. En dışarıda modül düzeyinde tanımlanmışsa bile, eğer kendisinde önce başka bir erişim belirteci varsa bu sınıfı modülün kullanıcılarına açar:

private:

// ... buradaki bütün tanımlar modüle özel ...

public class BirSınıf  // Bu sınıf kullanıma açık
{}

// ... buradakiler de özel

Modül olarak söyledim ama bütün o kod başka bir sınıfın veya yapının içinde de olabilirdi.

Alıntı:

Bundan emin değildim. Evet, 'final' ile kapatılabiliyor:

class Üst
{}

final class Son : Üst
{}

class Türetemez : Son    // <-- Derleme hatası
{}

void main()
{}

'fina'l anahtar sözcüğü üye işlevlerin alt sınıflar tarafından tanımlanmasını da önler:

class BirSınıf
{
   final void foo()    // <-- Alt sınıflar anlamını değiştiremezler
   {}
}

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (Salih Dinçer):

Salih bu konuyu gündeme getirmen iyi olmuş, package hakkında benimde hiç bilgim yoktu.

Ali'nin anlattıklarından sanki bir isim alanı (namespace) kavramına karşılık geliyor gibi anladım. Acaba package'i bu şekilde düşünebilirmiyiz. Eğer böyle değilse isim alanına karşılık gelen bir D yapısı var mı?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Modülün 'package' olarak işaretlenen olanakları bu pakedin diğer modüllerine de açıktır. Ama bunu deneyebilmek için birden fazla modül dosyası kullanmak gerek.

Örneğin, gösterdiğin kodu saat.d ismiyle kaydet. Aynı klasöre bir de takvim.d diye bir modül yerleştir. Şimdi saat.d ve takvim.d aynı pakede ait olurlar. takvim.d, saat.d içindeki 'package' olanaklarına erişebilir. Ama modül isimlerine pakedin ismini de yazmak gerekiyor.

Bu konular bana çok karışık gelmişti ama sonunda çalışan örnekler bulabilmiştim. Paket kavramı için:

http://ddili.org/ders/d/moduller.html

Erişim hakları için:

http://ddili.org/ders/d/sarma.html

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zafer):

Aslında değil. 'package' anahtar sözcüğü yalnızca erişim hakları ile ilgili bir konu. 'package' olarak belirtilen olanaklar genele değil, pakede açıktır. (Erişim haklarıyla ilgili derleyici hatalarından söz ediliyordu. Denerken beklenmedik sonuçlar elde edebilirsiniz.

Alıntı:

Paket tanımlarken işin içine klasör girdiği için doğal olarak paket de isim alanı getiriyor ama tekrar söylemek gerekirse, 'package' anahtar sözcüğü isim alanı tanımlamıyor. Yalnızca erişim haklarını belirliyor.

Modüller isim alanıdır. Ek olarak modüllerin içindeki sınıflar ve yapılar da isim alanıdır: benimModül.BenimSınıf.benimÜye gibi...

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli:1336521300):

Hocam, şu paket olayını diğer dillerden arınmış bir şekilde anlamaya çalışsam da hala buna vakıf olamadım...:)

Öncelikle D.ershane'deki okul/öğrenci örneğini denedim. Bahsedildiği gibi 3 dosya oluşturdum ve yapıda işaretli olan package'ları kaldırdım. Uygulama yine çalıştı.

Zaten erişimde bir kısıtlama var mı? Özetle yararı ne ki?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Şimdi anlaşıldı, gayet net ama vereceği hata kodunu nakletmek için denemeliydim...

Karşılacağımız hata şu olacakmış:
Alıntı:

Bu arada örnekte küçük bir değişiklik yaptım. Dershane ile Okul isminde 2 klasör oluşturdum ve okul.d dosyasını defteri.d şeklinde değiştirdim. Ancak olayı gözlemleyebilmemiz için Okul/defteri.d haricinde bir de Dershane/defteri.d dosyamız var. Sadece modül ismi değişik.

Özetle paket ismi Okul olan kod, Dershane'ye erişebilir ama package şeklinde işaretliler de avcunu yalar...:)

Başarılar...

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu konuya biraz daha devam etmeliyiz!

Şimdilik küçük notlar halinde devam edelim; belki sonra makaleleştirebiliriz de...

• module:

Bunu, bizim kodların bulunduğu paket/klasör ismimiz gibi düşünebiliriz. Her zaman en başta yer almak zorunda ve şu şekilde tanımlanmakta:

Alıntı ("denemelerim.d"):

> module DENEMELER;
>
> void main() {
>   //...
> }
> ```

>

Eğer bunu ana dosyada kullanmazsanız varsayılan olarak ''**'module'** denemelerim;'' gibi tanımlanmış oluyor. Yok harici bir dosyada tanımlayacaksanız, dosya ve klasör ismi ile uyumlu olmak zorunda. Ayrıca doğal olarak Türkçe karakter içermemeli. Harici dosyayı çağırırken de konumuzla dolaylı ilişkili olan **'import'**'u kullanıyoruz. Bu başlığı en sona bırakalım.

* **public:**

Öncelikle, tek dosyadan oluşan her sınıf ve üyesi her zaman public (herkese açık) gibi davranıyor. Yani siz, bu ve ileride göreceğimiz erişim haklarını, tek dosyada kullanırken işler halde olduğunu göremeyebilirsiniz. Çünkü hepsi varsayılan isim alanı içerisinde kardeş kardeş yaşamayı tercih ediyorlar...:)

Belki makalenin tamamını okumamak için çok aceleci olabilirsiniz. Bu durumda D.ershane'deki Sarma Dersi (<http://ddili.org/ders/d/sarma.html>) ile devam edin...

D dilinde yazdıklarınız, aksi belirtilmediği müddetçe her zaman public, yani sözcük anlamıyla halka açık. Dolayısıyla kural ihlali olmadığı müddetçe her sınıfın/yapının üyesine erişebilirsiniz. Tabi kısıtlamalara gidilmezse. Bunlar modül seviyesinde ve içinde olmak üzere iki çeşitler:

* **I.package:**

Bildiğimiz gibi, **'import'** kullanarak derleme anında herhangi bir yerdeki, her hangi bir kodu, ana koda dahil edebiliriz. Ama bunlar ilk maddede kısaca değindiğimiz **'module'**'den dolayı ana isim alanı, yani main()'nin içinde bulunduğu bölgedeymiş gibi temsil edilmezler. Öyleyse her modül ayrı bir paket (klasör) içinde varlığını sürdürür. Örnekle açıklarsak, evim ve mahalle isminde 2 paketimiz (directory, dizin) olsun:

Alıntı ("evim/odam.d"):
>
>

Farz edelim mahalleden, Ali'yi ziyaret etmek istiyorlar. Komşuları, bir patikadan geçip Aliler'in (Anadolu'da bazı yörelerde Aligiller de denir) olduğu eve gidecek. Kapıya kadar gelebilirler, çünkü kurucu işlev this()'de salona açılan ODA() tanımlanmış.

Alıntı ("mahalle/yollar.d"):

> module mahalle.yollar;
> import evim.odam;
>
> class YOL {
>   auto patika = "Ali'nin evine giden en kestirme yol";
>   ODA salonAligillerin;
>
>   this() {
>     salonAligillerin = new ODA();
>   }
> }
> ```
üyedir
>

Ancak, biz mahalliler olarak ya da main() içindeki bir yönetici, Ali'nin evine erişebilsek de evin reisinin olduğu koltuğa hiç bir zaman oturamayız. Çünkü **'package'** ile işaretlenmiş. Yani ev içindekilere açık ama dışarıya değil. Oysa varsayılan olarak halka açık (public) olan kapıya erişebilir ve hakkında bilgi edinebiliriz:

auto ziyaretYolu = new YOL();
ziyaretYolu.salonAligillerin.kapısı.writeln; //...koltuğum.writeln; ile bitseydi 'not accessible' derleme hatası alırdık...

* **II.private:**

Şimdi de Ali'nin çalışmaOfisi olduğunu ve ondan başkasını giremeyeceği bir oda hayal edelim. Bunu kodlara dökmeye gerek yok çünkü işin içine başka nesneler gireceği için temsil etmesi zor olabilir. Ama bileceğimiz tek bir şey var: Eğer '**package**' yerine bu sefer '**private**' kullanırsak, aynı modül içinden başka bir sınıf (örn. class KİŞİ), herhangi bir tanımlanmış ('**new**' ile hafızada yer ayrılmış) ODA'ya erişse de özel (private)  olarak tanımlanmış hiç bir üyesine erişemeyecektir. Çünkü bu, o sınıf içindekilerin erişebileceği nitelikte işaretlenmiştir. Öyleyse, modüller arasında yaptığımız kısıtlamayı modül içinde de yapabiliriz...

* **II.protected:**

* **shared:**

* **static:**

**Düzenleme Notu:** Bir daha ki sefer sarma'dan diğer nesne özelliklerine (bir kaçı hemen yukarıda) geçeceğiz. Ama hala sarma konusunu kendi çapımda bitirebilmiş değilim. Çünkü '**private**' ile '**protected**' arasında henüz bir fark göremiyorum...:)

**Ek Not ve Soru:** Ayrıca yukarıdaki nitelikleri enum'lar için de denediğimde geçersiz olduklarını gördüm. Bunun nedenini bilmiyorum, oysa enum'lar da bir sınıf içinde üye/nesne gibi davranması gerekiyordu! Şu örnekte neden public gibi davranır?

class Foo {
// private auto Bar = "isn't public";/*
private enum Bar = "is public";//*/
}

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Alıntı (Salih Dinçer):

Varsayılan erişim 'public' olduğu için öyle yapınca herkese açmış oldun. 'package', yabancılara kapalı ama pakede açık olan erişim belirliyor.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]