Sanal Metotlar Örneği (c#)

Temel Ev Sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

   /*kalitimda türetilen classların namespaceleri aynı olması tek bir referans üzerinden erişmemiz için kolaylık 
      sağlar.*/
namespace emlakci
{
    public class Ev
    {
        private int odasayisi;
        public int Odasayisi
        {
            get { return odasayisi; }
            set { odasayisi = value; }
        }
        private int katno;

        public int Katno
        {
            get { return katno; }
            set { katno = value; }
        }
        private int alan;

        public int Alan
        {
            get { return alan; }
            set { alan = value; }
        }
        private string semt;

        public string Semt
        {
            get { return semt; }
            set { semt = value; }
        }

        public Ev()
        {
        }
        public Ev(int odasayisi, int katno, string semt, int alan)
        {
            this.odasayisi = odasayisi;
            this.katno = katno;
            this.semt = semt;
            this.alan = alan;
        }

        /* virtual sanal anlamına gelir. virtual tanımlanan metotlar override ile tanımlanan metotlar tarafından 
          ezilebilir.*/
        public virtual string EvGoruntule()
        {
            return string.Format(" Odasayisi: {0} Katno: {1} Alan: {2} Semt: {3}", odasayisi, katno, alan, semt);
        }
    }
}


Türeyen Satılık Ev Sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/*kalitimda türetilen classların namespaceleri aynı olması tek bir referans üzerinden erişmemiz için kolaylık sağlar.*/
namespace emlakci
{
    public class satilikev : Ev
    {
        private int fiyat;

        public int Fiyat
        {
            get { return fiyat; }
            set { fiyat = value; }
        }
        private int kapora;

        public int Kapora
        {
            get { return kapora; }
            set { kapora = value; }
        }

        public satilikev(int odasayisi, int katno, int alan, string semt, int fiyat, int kapora) : base()
        {
            base.Alan = alan;
            base.Katno = katno;
            base.Semt = semt;
            base.Odasayisi = odasayisi;
            this.fiyat = fiyat;
            this.kapora = kapora;
        }

        /*override ezmek anlamına gelir. Base sınıfındaki virual tanımlanmış metodun yerine önceliği alır. Artık
          virtual metot yerine aktif
         * olan sınıf override sınıfı olur. base sınıfındaki virtual metodu yerine öncelikli olarak override sınıflarla 
           işlem yapılır. eğer 
         * override sınıfı bulunmaz ise virtual sınıf ile işleme devam edilir. */
        /* override tanımladığımız metot türetilen sınıftaki virtual metodu yerine çağrışır. bir anlamda virtual 
           metodunu ezer. */

        public override string EvGoruntule()
        {
            return base.EvGoruntule() + " Fiyat: " + fiyat +  " Kapora: " + kapora;
        }
    }
}

Türetilen Kiralık Ev Sınıfı:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/*kalitimda türetilen classların namespaceleri aynı olması tek bir referans üzerinden erişmemiz için kolaylık sağlar.*/
namespace emlakci
{
    public class kiralikev:Ev
    {
        public kiralikev()
        {
        }

        public kiralikev(int odasayisi, int katno, int alan, string semt, double kira) : base(/*aşağıdaki tanımları 
                                                                                                                              burada yapabilirdik.*/)
        {
           /*yukarıdaki boş base constructori dolu olsaydı tekrardan base ile ataması yapmamıza gerek 
             kalmayacaktı. */
           base.Odasayisi = odasayisi;
           base.Katno = katno;
           base.Alan = alan;
           base.Semt = semt;
           this.kira = kira;
         
        }

        public double kira;
        public double depozito;

        /*override ezmek anlamına gelir. Base sınıfındaki virual tanımlanmış metodun yerine önceliği alır. Artık 
         virtual metot yerine aktif
         * olan sınıf override sınıfı olur. base sınıfındaki virtual metodu yerine öncelikli olarak override sınıflarla 
            işlem yapılır. eğer 
         * override sınıfı bulunmaz ise virtual sınıf ile işleme devam edilir. */
        /* override tanımladığımız metot türetilen sınıftaki virtual metodu yerine çağrışır. bir anlamda virtual 
         metodunu ezer. */
        public override string EvGoruntule()
        {
            return base.EvGoruntule() + " Kira " + kira + " Depozito: " + depozito;
        }
    }
}




Main Sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using emlakci;

//Not: base sınıf üzerinden kalıtım sınıflarına erişebilme:

namespace kalitimsinifi
{
    class Program
    {
        static void Main(string[] args)
        {
            /*kalitim tüm sınıfları base sınıf üzerinden kullanabilme imkanı verir.
            fakat o sınıflara has alanı görmek için gerçek tipine cast etmemiz gereklidir. */

            Ev ev1 = new kiralikev(1, 1, 1, "1", 1);
            Ev ev2 = new satilikev(2, 2, 2, "2", 2, 2);
            Ev ev3 = new kiralikev(3, 3, 3, "3", 3);
            Ev ev4 = new satilikev(4, 4, 4, "4", 4, 4);
            kiralikev ev5 = new kiralikev(5, 5, 5, "5", 5);
            satilikev ev6 = new satilikev(6, 6, 6, "6", 6, 6);

            Ev[] evler = new Ev[6];
            evler[0] = ev1;
            evler[1] = ev2;
            evler[2] = ev3;
            evler[3] = ev4;
            evler[4] = ev5;
            evler[5] = ev6;
         
            for (int i = 0; i < evler.Length; i++)
            {
                Console.WriteLine(evler[i].EvGoruntule());

                if (evler[i] is kiralikev)
                {
                   /* kiralikev sinifindan bir nesne tanımlıyoruz ve bu nesneye evler[i] nesnesini (kiralikev) 
                    operatörüyle casting edip atıyoruz.)*/

                   kiralikev ke = (kiralikev)evler[i];

                   /* NOT: (evler[i] as kiralikev).depozito deyimi casting ile aynı görevi görür. */
                   Console.WriteLine(" depozito: "+ ke.depozito);
                }
            }

            Console.ReadLine();
        }

    }
}

Sanal Metotlar (c#)

Şu ana kadar bir nesne üzerinden çağırdığımız metotların tamamı derleme zamanında belirgindi. Yani derleme
aşamasında hangi nesne üzerinden hangi metotların çaığrabileceği belliydi. Sanal metotlar yardımıyla çalışma
zamanında metot seçme işinin nasıl olduğunu inceleyeceğiz.

Sanal metotlar temel sınıflar içinde bildirilmiş ve türeyen sınıflar içinde de tekrar bildirilen metotlardır.
Sanal metotlar nesne yönelimli programlama tekniğindeki çok biçimliliği(polimorphism) uygulayan yapılardır.
Temel sınıfta bir sanal metot bildirildiğinde bu temel sınıflar, temel sınıftaki sanal metodu devre dışı bırakarak
kendi metot gövdelerini oluşturabilirler.

Sanal metotlar sayesinde Temel sınıf türünden bir referansa türeyen sınıf referansları aktarıldığında, temel
sınıf referansı üzerinden kendisine aktarılan türeyen sınıfın sanal metodu çağrılabilir. Eğer türeyen sınıf
sanal metodu devre dışı bırakmamış ise temel sınıftaki sanal metot çağrılır. Çağrılan metodun hangi türe ait
olduğu çalışma zamanında belirlenir. Metotların bu şekilde çalışma zamanında belirlenmesine geç bağlama
(late binding) denilmektedir.

Sanal metotlar virtual anahtar sözcüğü kullanılarak bildirilir. Bu anahtar sözcük, metot bildirimin başına
eklenirse soyut metotlar bildirilmiş olur. Türeyen sınıfta, temel sınıftaki soyut netotları devre dışı
bırakmak için ise override anahtar sözcüğü kullanılır.


Sanal metotların etkin kullanılığı bir örnek;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SanalMetotlar
{
    class Memeli
    {
        public double Boy;
        public double Agirlik;

        public Memeli(double boy, double agirlik)
        {
            this.Boy = boy;
            this.Agirlik = agirlik;
        }

        virtual public void Konus()  /* Türetilen sınıflar ile işlem yapılacağı zaman, Konus() metodu 
                                    türetilen sınıfta override anahtar sözcüğü ile tanımlanmış ise
                                                   Türetilen sınıftaki metot çağıralacak. */
        {
            Console.WriteLine("ben konusamam");
        }
    }

    class kedi : Memeli
    {
        public string Turu;
        public kedi(string turu, int boy, int agirlik)
            : base(boy, agirlik)
        {
            this.Turu = turu;
        }

        override public void Konus()  /* Kedi sınıfı ile işlem yapılacağı zaman Base sınıftaki virtual ile
                                tanımlanan Konus() metodu yerine buradaki konus() metodu çağıralacak.*/
                               
        {
            Console.WriteLine("Ben bir kediyim");
        }
    }

    class koyun : Memeli
    {
        public string Turu;
        public koyun(string turu, int boy, int agirlik)   : base(boy, agirlik)  /* alınan değerleri türetilen sınıftaki  
                                                          değişkenlere gönderiyor. Base.Boy  tanımlamamıza gerek kalmıyor */
        {
            this.Turu = turu;
        }

        override public void Konus() /* Koyun sınıfı ile işlem yapılacağı zaman Base sınıftaki virtual ile
                                tanımlanan Konus() metodu yerine buraki konus() metodu çağıralacak.*/
        {
            Console.WriteLine("Ben bir koyunum");
        }
    }

    class MainMetodu
    {
        static void Main()
        {
            Memeli memeli1 = new Memeli(20, 30);
            kedi kedi1 = new kedi("Van", 10, 15);
            koyun koyun1 = new koyun("keçiören", 60, 80);

            memeli1.Konus();


            memeli1 = kedi1;
            memeli1.Konus();


            memeli1 = koyun1;
            memeli1.Konus();

           

            Console.ReadLine();

        }
    }
}

ekran çıktısı;

ben konusamam
ben kediyim
ben koyunum  

 Şeklinde olacaktır. Kedi ve Koyun nesneleri ait referans aktarılmasına rağmen çalışma zamanında bu Memeli
 referansı üzerinden Konus() metodunu çağırdığımızda Memeli sınıfındaki Konus() metodu yerine kendisine
 atanan sınıflara ait Konus() metotları çağrılmıştır.

 Sanal metotlar sayesinde temel sınıf referanslarına türeyen sınıf referansları atandığında, temel sınıf
 referansı üzerinden türeyen sınıfa ait metotları çağırabilmekteyiz. Bu yöntemle sadece temel sınıfta sanal
 olarak bildirilmiş metotların türeyen sınıfta devre dışı bırakılmış olan metotlara erişilebilir.

Is ve As Operatörleri (c#)

As  Operatörü

as operatörü uygun türler arasındaki dönüşümü sağlar. Kullanımı aşağıdaki biçimdedir.

<referans tipi üretitilecek ifade>   as   <referans türü>

as operatörü kullanımı fazla yaygın değildir. as operatörün ürettiği değer referans türündendir, eğer dönüşüm işlemi
başarızsa null değer üretilir. Örneğin object türünden olan bir nesne string türüne aşağıdaki şekilde dönüştürülür.

Using System;

class Operatorler
{
   static void main()
   {
      object i = "50";
      string s = i as string;
      console.writeline(s);
   }
}


Is Operatörü

is operatörü çalışma zamanında bir nesnesinin türünün operand ile verilen türe uyumlu olup olmadığını kontrol eder.
Kullanımı aşağıdaki gibidir.

<ifade> is <tür>

is operatörü de as operatörü gibi pek fazla kullanılmamaktadır. Ancak yine de dilin olanaklarından haberdar olmak önemlidir.
is operatörünün ürettiği değer true ya da false değeridir. Eğer operandlardaki türler uyumlu ise true, değilse false
değeri üretilir.

<ifade> is <tür> ifadesinin her zaman true ya da her zaman false üretmesi durumunda derleyici hata bir uyarı verecektir.
ancak bu derleme işlemine engel değildir.

Aşağıda ki programı derlediğimizde derleyicinin verdiği uyarının ekran görüntüsü şöyledir:

using Operatorler
{
  static void main()
  {
    int i = 50;
    bool b1 = is int;
    bool b2 = is double;
    bool b3 = is object;
 
   console.writeline(b1);
   console.writeline(b2);
   console.writeline(b3);

  }
}

  Verilen ifade her zaman ('int') türünü sağlar.
  Verilen ifade hiçbir zaman ('double') türünü sağlamaz.
  Verilen ifade her zaman ('object') türünü sağlar.

  Yukaridaki programı çalıştırdığımızda ise aşağıdaki ekran görüntüsünü elde ederiz.
  True
  False
  True

Kalıtım Örneği (c#)

Bu örneğimizde temel bir Ev sınıfı oluşturacağız. Oluşturduğumuz temel ev sınıfında tüm evler için kullanılabilinir özellikler olan kat numarası, oda sayısı, alanı, semti gibi özellikler olacak. Temel Ev sınıfından bir KiralıkEv sınıfı türeteceğiz ve bu sınıfımızda sadece kiralik evler için geçerli olan depozito ve kira özelliklerini ekleyeceğiz. Ardından Main metodunun bulunduğu sınıfta nesne örneklerimizi oluşturacağız.


Temel Ev Sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace evsinifi
{
    public class Ev
    {
        private int odasayisi;

        public int Odasayisi
        {
            get { return odasayisi; }
            set { odasayisi = value; }
        }
        private int katno;

        public int Katno
        {
            get { return katno; }
            set { katno = value; }
        }
        private int alan;

        public int Alan
        {
            get { return alan; }
            set { alan = value; }
        }
        private string semt;

        public string Semt
        {
            get { return semt; }
            set { semt = value; }
        }

   

        public string EvGoruntule()
        {
            return string.Format(" Odasayisi: {0} Katno: {1} Alan: {2} Semt: {3}", odasayisi, katno, alan, semt);
        }
    }
}

Ev sınıfından türetilen KiralıkEv sınıfı:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/*kalitimda türetilen classların namespaceleri aynı olması tek bir referans üzerinden erişmemiz için kolaylık sağlar.*/

namespace kiraliksinifi
{
    public class kiralikev:Ev
    {
        public kiralikev()
        {
        }

        public kiralikev(int odasayisi, int katno, int alan, string semt, double kira) : base(/*boş yerine dolu olabilirdi*/)
        {
           /*yukarıdaki boş base constructori dolu olsaydı tekrardan base ile ataması yapmamıza gerek kalmayacaktı. */
           base.Odasayisi = odasayisi;
           base.Katno = katno;
           base.Alan = alan;
           base.Semt = semt;
           this.kira = kira;
           
        }

        public double kira;
        public double depozito;

        public string EvGoruntule()
        {
            return string.Format(" Odasayisi: {0}, Katno: {1}, Alan: {2}, Semt: {3}, kira: {4}", Odasayisi, Katno, Alan, Semt, kira);
        }
    }
}

Main metodunun bulunduğu ana sınıf:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using evsinifi;
using kiraliksinifi;


namespace Kalitim
{
    class Program
    {
        static void Main(string[] args)
        {
            kiralikev ev1 = new kiralikev();
            ev1.Alan = 120;
            ev1.Katno = 3;
            ev1.Odasayisi = 4;
            ev1.Semt = "bebek";
            ev1.kira = 550;

            Ev ev2 = new Ev();
            ev2.Alan = 120;
            ev2.Katno = 3;
            ev2.Odasayisi = 4;
            ev2.Semt = "Etiler";

            kiralikev ev3 = new kiralikev(3,7,120,"besiktas",430);

            Console.WriteLine(ev1.EvGoruntule());
            Console.WriteLine(ev2.EvGoruntule());
            Console.WriteLine(ev3.EvGoruntule());

           
            Console.ReadLine();
        }
    }
}

Kalıtım (c#)

Temel bir Memeli sınıfı tasarlayacağız. Her memeli hayvan da  bulunan özellikler boy, ağırlık gibi fiziksel özellikler
olabilir. Daha sonra Kedi sınıfını tasarlayacağız. Ancak Kedi sınıfı Memeli sınıfından türeteceğiz. Yani Memeli sınıfının
tüm özelliklerini Kedi sınıfına aktaracağız. Memeli sınıfında boy ve ağırlık bilgilerini gösteren OzelliklerGoster()
isimli bir metot olacak. Kedi sınıfında da hayvanın kedi olduğunu gösteren string türünden bir özellik olacak.
Ayrıca Kedi sınıfında kedinin türünü yazdıracak bir de metot olmalıdır.

Türetme işlemi aşağıdaki gibi yapılır.

class Kedi: Memeli
{


}

burada kedi sınıfından türemiş sınıf(derived class) Memeli ise temel sınıf (base class) olarak adlandırılır. Şimdi bu sınıfların nasıl yazıldığına bakalım.

using system;

class Memeli
{
  puplic double Boy;
  puplic double Agirlik;

  puplic void OzellikGoster()
  {
    console.WriteLine("Boy = " + Boy);
    console.WriteLİne("Ağırlık = " Agirlik);
  }

}


class Kedi:Memeli
{
  puplic string Tur;

  puplic void TurGoster();
  {
   console.writeline("Turu: " + Tur);
  }
}

Class MainMetodu
{
  Private void Main(String [] Args)
  {
   Kedi kedi1 = new Kedi();

   kedi1.Boy= 15;
   kedi1.Agırlık = 4;
   kedi1.Tur = "Van";
 
   kedi1.OzellikGoster();
   kedi1.TurGoster();

   Kedi kedi2 = new Kedi();
   kedi2.Boy= 19;
   kedi2.Agırlık = 8;
   kedi2.Tur = "kara";
 
   kedi2.OzellikGoster();
   kedi2.TurGoster();

   Console.ReadLine();
  }
}

Bu programın ekran çıktısı;

Boy = 15
Agırlık = 4
Turu = Van

Boy =  19
Agırlık = 8
Turu = Kara

şeklinde olacaktır.


Gördüğünüz üzere Kedi sınıfı üzerinden Memeli sınıfına ait bütün özelliklere ve metotlara erişebiliyoruz.
Bunu sağlayan,

class Kedi : Memeli
{
}
satırıdır.

Ancak yazdığımız programda;

Memeli memeli = new Memeli();
memeli.TurGoster();

şeklinde Türeyen sınıftaki metoda erişmemiz mümkün değildir.

Programı derlemeye çalıştığımızda hata mesajı alırız; çünkü memeli nesnesi üzerinden TurGoster() metoduna ulaşamayız.
Yani temel sınıf olarak Memeli sınıfının kendisinden türeyen Kedi sınıfındaki üye elemanlardan haberi yoktur.
Ancak tersi doğru değildir.

Singleton Tasarım Örneği (C#)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Evler
{
    public class Ev
    {
        /*static elemanlar içerisinde static elemanlar çağrılabileceği için static tanımladık. */
       static Ev instance;


       /* dışardan bir müdahale olmaması için private tanımlanan ev türünden instance değerine belirleyici yazmalıyız.*/
        public static Ev Instance
        {
            get
            {
                /* ev sınıfının nesne örneğini geri döndürmek için; */
                return Ev.instance;
            }
        }

        /* yeni sınıf oluşturulmaması için dışardan ulaşılmamak üzere private tanımlanmalı. */
        private Ev()
        {
         

        }

        public void deneme(double alan2)
        {
            this.Alan=alan2;
        }

      /* static constructorlar parametre almazlar ve private olarak tanımlanırlar. */
      /* ev sınıfından nesne kurulmadan çalıştırılması gerektiği için static tanımladık. diğer türlü sınıfı kurmadan
       constructor çağırmamız mümkün olmayacak ve new anahtar sözcüğünü bir kereyle sınırlandırma şansımız 
       olmayacaktı. */
        static Ev()
        {
            /* instance static olarak tanımlandığı için buradaki static metot tarafından çağrılabiliyor. */
            /* instance değişkeni ile Ev sınıfı kurulduğu anda bellekte bir kereye mahsus olmak üzere new anahtar 
             sözcüğü ile Ev sınıfı için yer oluşturuluyor. daha sonra ev sınıfından üretilen nesneler aynı özellikleri 
             taşıyacaktır. */
            instance = new Ev();
        }

        private static int katno;
        private int odasayisi;
        private double alan;
        private string semt;

        public int Katno
        {
            get
            {
                return katno;
            }

            set
            {
                katno = value;
            }
        }

        public int Odasayisi
        {
            get
            {
                return odasayisi;
            }

            set
            {
                odasayisi = value;
            }
        }

        public double Alan
        {
            get
            {
                return alan;
            }

            set
            {
                alan = value;
            }
        }

        public string Semt
        {
            get
            {
                return semt;
            }

            set
            {
                semt = value;
            }
        }

        public String EvBilgileriniGetir()
        {
            return string.Format(" katno: {0} \n odasayisi: {1} \n alan: {2} \n semt: {3}", katno, odasayisi, alan, semt);
        }

    }


ana program;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Evler;

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            /* ev ilk kurulduğu anda instance sözcüğü new anahtar sözcüğünü işaret edicek bellekte bir kereliğine
             sınıf için yer açılacak. ardından kurulan her nesne örneği aynı referansı temsil edecektir. */
            Ev ev1 = Ev.Instance;

            ev1.Katno = 3;
            ev1.Odasayisi = 2;
            ev1.Semt = "besiktas";

            Ev ev2 = Ev.Instance();
            ev2.deneme(2);
            ev2.Katno = 11;

            /* ev1 veya ev2 yazmamız bir şeyi değiştirmicektir üzerinde çalıştığımız nesne aynıdır. */
            Console.WriteLine(ev1.EvBilgileriniGetir());

            Console.ReadLine();
        }
    }
}

}

Singleton (Tek) Nesneler (C#)

Singleton (Tek) Nesneler

singleton deseni bir programın yaşam süresince belirli olan bir nesneden sadece bir örneğin(instance) olmasını garantiler.
Aynı zamanda bu desen, yaratılan tek nesneye ilgili sınıfın dışından global düzeyde mutlaka erişilmesini hedefler.

Yeni bir nesne oluşturmak için new anahtar sözcüğünün temsil ettiği yapıcı metoduna dışarıdan erişimin olması gerekir.
Yani yapıcı metodun puplic olarak bildirilmiş olması gerekir. Ancak singleton desenine göre belirli bir anda sadece bir
nesne olabileceği için new anahtar sözcüğünün kullanımının yasaklanması gerekir yani yapıcı metotodun protected ya da private
olarak bildirilmesi gerekir.

Eğer bir metodun varsayılan yapıcı metodu puplic olarak bildirilmemiş ise ilgili sınıf türünden herhangi bir nesnenin sınıfın
dışında tanımlanması mümkün değildir.

Bizim istediğimiz yalnızca bir sınıfın yaratılması olduğuna göre bunu ancak statik üye elemanlar ile yapabiliriz.

1. yöntem:

Puplic class Ev
{

   /*static elemanlar içerisinde static elemanlar çağrılabileceği için static tanımladık. */
   private static Ev ornek;
 
   /* dışardan bir müdahale olmaması için private tanımlanan ev türünden instance değerine belirleyici yazmalıyız.*/
   Puplic Static Ev Ornek
   {
     get
     {
      /* ev sınıfının nesne örneğini geri döndürmek için; */   
       return Ev.ornek;
     }
   }

  /* yeni sınıf oluşturulmaması için dışardan ulaşılmamak üzere private tanımlanmalı. */
  Private Ev()
  {

  }


   /* static constructorlar parametre almazlar ve private olarak tanımlanırlar. */
   /* ev sınıfından nesne kurulmadan çalıştırılması gerektiği için static tanımladık. diğer türlü sınıfı kurmadan constructorı
    * çağırmamız mümkün olmucak ve new anahtar sözcüğünü bir kereyle sınırlandırma şansımız olmucaktı. */
   Static Ev()
  {

       /* instance static olarak tanımlandığı için buradaki static metot tarafından çağrılabiliyor. */
       /* instance değişkeni ile Ev sınıfı kurulduğu anda bellekte bir kereye mahsus olmak üzere new anahtar sözcüğü ile
        * Ev sınıfı için yer oluşturuluyor. daha sonra ev sınıfından üretilen nesneler aynı özellikleri taşıyacaktır. */
     ornek= New Ev();
  }


2.yöntem:

Puplic class Ev
{
  private static Ev ornek;

  Private Ev()
  {
  }

 /* nesne üzerinden erişilmesine gerek kalmadan direkt sınıf ile erişilmesi için statik olmak zorunda */
 
  Puplic static Ev Ornek()
  {
   
      if ( nesne == null)
          nesne = new Ev();
   
     return nesne;
    }

 }
    Gördüğümüz üzere nesne ile ilk olarak sınıf belleğe yüklediğinde değilde o nesneyi ilk defa kullanmak istediğimizde
   yaratılıyor. ilgili nesneyi her istediğimizde yeni bir nesnenin yaratılmaması içinde
   if(nesne == null)
   şeklinde bir koşul yazdığımıza dikkat edin.
 
   sınıf yaratmak için Ev evim = Ev.Ornek();