Neden this veya prototype kullanırız?

PERFORMANS

Eğer bir A fonksyionundan new ile birçok nesne tanımlayacaksak, A fonksiyonunda this.xxx ile tanımlı her fonksiyon tüm nesneler için tek tek oluşturulur.

var A = function () {
    this.x = function () {
        //do something
    };
};

// Aşağıdaki tanımlamada tek bir fonksiyon tüm örnekler için kullanılır
// ve bu şekilde memory daha az kullanılır.
var A = function () { };
A.prototype.x = function () {
    //do something
};

Ref: http://jsperf.com/prototype-vs-this

GİZLEMEK

Fonksiyon içindeki private değişkenleri, public fonksiyonlardan gizlemek istersek, prototype içinde public fonksiyonlarını tanımlarız. Böylece A fonksyonu içindeki private_var erişilmez olur. Sadece A içinde this ile tanımlı kaynaklara prototype içinde tanımlı fonksiyonlar erişir.

__proto__ ne işe yarar

Bir fonksiyonun prototype özelliği otomatik olarak tanımlanır ve içindeki bilgiler o fonksiyondan üretilen nesnelere geçer. Üretilen her nesne __proto__ bilgisi içinde fonksyionun prototype özelliğindeki nesneyi saklar ve aranan her property eğer birinci seviyede nesnede yoksa __proto__ içinde aranır. Bulunamazsa __proto__.__proto__ içinde ve en son __proto__ ya kadar aranır.

prototype.constructor ne işe yarar

Fonksiyonun varsayılan özelliği prototype idi ve constructor ile __proto__ dan oluşuyordu.

Fonksiyonun atasını prototype içinden öğreniyoruz.

Function dan miras alınanlar:

Eğer prototype özelliğini başka bir fonksiyondan olma nesne ile ezersek:

Eğer daha A fonksiyonunun prototype'ını B fonksiyonuyla ezip,
A fonksiyonundan olma bir a nesnesinin constructor fonksiyonundan c nesnesi yaratmak istersek,
elbetteki B fonksiyonundan üretilmiş olacak çünkü A'nın prototype özelliğini B yapmıştık.

Kısaca constructor ile objenin atasına ait fonksiyona bağ kurmuş oluyoruz. Eğer nesnenin üstünden new ile bir başka nesne yaratmak istersek constructor fonksiyonu işimize yarayacaktır.

---

Javascript Sınıflarında prototype atanması

1)

2)


Sınıfların durumunu daha derin incelersek:

Herhangi bir inheritance(miras, kalıtım) uygulanmadığı için B sınıfı varsayılan olarak Object sınıfından miras alır. Bu durumda B'den yaratılacak nesneler için ilk aranacak metotlar B sınıfının içindekiler sonra B'nin miras aldığı Object sınıfı içindekiler olacak.
Nesnenin daima __proto__ su vardır ve inherit ettiği sınıfların bilgilerini barındırır.
Bir nesne içinde property araması yapıldığında önce kendi içinde (hasOwnProperty) sonra inherit ettiği sınıfların içinde propertylerde arama yapar.

var b = new B();
b.__proto__ 
B {}
b.__proto__.__proto__
Object {}
b.__proto__.__proto__.__proto__
null

Object.create ile inheritance:


new Operatörüyle inheritance:


B nin prototype'ı için Object.create ile A yı B sınıfının atası olarak tayin ettiğimizde, A dan bir nesne yaratılmaz ve tüm property leri B sınıfından yaratılan nesnelere geçirilmez.

Miras alan sınıfa, sanki atadan geliyormuş gibi yeni fonksiyon ve özellikler eklemek

Object.create(param1,param2)
param1: Miras alınan sınıf
param2: Sanki miras alınan sınıftan geliyormuş gibi eklenen fonksiyon ve özellikler. Dikkat edilecek nokta: Miras alınan sınıfa yeni eklenen fonksiyon ve özellikler geçmez!

KALITIMI YOK ETMEK

null veya Object.create(null) ile sınıfın, ata sınıfla ilişiği kesildiği anda, prototype'ı null yapılan sınıflardan türetilen nesnelerin __proto__ özelliği Object ile yer değişir.

Güzel Kaynaklar:
http://javascriptweblog.wordpress.com/2010/06/07/understanding-javascript-prototypes/
http://dailyjs.com/2012/06/04/js101-object-create/
http://www.javascripture.com/

Nesne Yönelimli Programla Nedir? başlıklı anlatımımın notları

Interface


ILDASM


VIRTUAL


BASE


ABSTRACT

using System;
using System.Collections.Generic;
using Fresenius.Turkiye.Dersler.CSharp.OOP;
using Fresenius.Turkiye.Dersler.CSharp.OOP.Abstract;
using Fresenius.Turkiye.Dersler.CSharp.OOP.Interface;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main()
        {
            #region Genel
            try
            {
                Kisi kisi = new Kisi('E', "Cem", "Topkaya", "83450930945", DateTime.Now);
                Ogrenci og = new Ogrenci()
                                 {
                                     OgrenciNo = 111,
                                     Sinifi = 2,
                                     mDersleri = new List()
                                                     {
                                                         new Ders()
                                                             {
                                                                 Adi = "Coğrafya",
                                                                 Dersligi = "C101"
                                                             },
                                                         new Ders()
                                                             {
                                                                 Adi = "Matematik",
                                                                 Dersligi = "Mat101"
                                                             }
                                                     }
                                 };
            }
            catch (ArgumentOutOfRangeException aor)
            {
                Console.WriteLine("Başlangıç parametleri hatalıdır.");
                Console.WriteLine("İstisna: " + aor.ToString());
            }
            catch (Exception e)
            {
                throw (e);
            }
            #endregion

            #region interface anlatımı
            Akitler akit = new Akitler();
            IKontrat kontrat = new Akitler();
            IKontrat contract = new Contracts();
            kontrat.Anlas();
            kontrat.Boz(1);

            contract.Anlas();
            contract.Boz(1);

            Console.WriteLine(kontrat.GetType());
            Console.WriteLine(contract.GetType());
            #endregion

            #region Abstract
            AKontrat ak1 = new Akit();
            AKontrat ak2 = new Contract();

            Akit akt = new Akit(); 
            #endregion
        }
    }
}

namespace Fresenius.Turkiye.Dersler.CSharp.OOP.Abstract
{
    public abstract class AKontrat
    {
        public abstract void Anlas();
        protected abstract bool Boz(int _iAnlasmaId);

        public void OrtakMetot()
        {
            // code....
        }
    }

    public class Akit : AKontrat
    {
        public override void Anlas() { }
        protected override bool Boz(int _iAnlasmaId) { return false; }
    }

    public class Contract:AKontrat
    {
        public override void Anlas() { }
        protected override bool Boz(int _iAnlasmaId) { return false; }
    }
}

namespace Fresenius.Turkiye.Dersler.CSharp.OOP
{
    class Kisi
    {
        #region Props & Backing Fields
        char mCinsiyet;
        /// 

        /// Cinsiyet bilgisini içerir. Sadece 'E' ve 'K' karakterlerini alır.
        /// 
        public char Sex
        {
            get
            {
                // if (mCinsiyet != 'E' && mCinsiyet != 'K') : Henüz değer atanmamış
                // {
                //      DB  bağlantısı kur,
                //      TC Kimlikten elemanın cinsiyetini çek
                //      DB bağlantısını kapat
                //      mCinsiyet = bulunanDeger
                // }
                // return mCinsiyet;
                return mCinsiyet;
            }
            set
            {
                char[] kabulEdilenDegerler = new[] { 'E', 'K' };
                foreach (char cDeger in kabulEdilenDegerler)
                {
                    if (cDeger.Equals(value))
                    {
                        mCinsiyet = value;
                        return;
                    }
                }


                throw new ArgumentOutOfRangeException();

            }
        }
        #endregion


        #region Fields
        string mTcKimlik;
        string mAdi;
        string mSoyadi;
        DateTime mDogumTarihi;
        #endregion


        #region Constructor (Yapıcı) Metotlar
        public Kisi(char _cinsiyet, string _adi, string _soyadi, string _tc, DateTime _dogum)
        {

            if (_cinsiyet != 'E' && _cinsiyet != 'K')
            {
                throw new ArgumentOutOfRangeException("Cinsiyet E ya da K olmak zorundadır.");
            }
            mCinsiyet = _cinsiyet;
            mAdi = _adi;
            mSoyadi = _soyadi;
            mTcKimlik = _tc;
            mDogumTarihi = _dogum;


            #region this ayrımını yapmak için
            char Sex = 'A';
            this.Sex = _cinsiyet;
            #endregion
        }

        public Kisi()
        {

        }
        #endregion

        protected string SadeceAltSiniftan()
        {
            return base.ToString();
        }

        public string TumBilgiler()
        {
            string sonuc;
            sonuc = String.Format("Adı: {0}\nSoyadı: {1}", mAdi, mSoyadi);
            return sonuc;
        }

        public override string ToString()
        {
            string sonuc;

            sonuc = "üst sınıftan gelen: " + base.ToString();
            sonuc += "\nEzilmiş metodun dönen değeri.";

            return sonuc;
        }

    }

    class Ogrenci : Kisi
    {
        private int mOgrenciNo;
        public int OgrenciNo
        {
            get { return mOgrenciNo; }
            set { mOgrenciNo = value; }
        }

        private int mSinifi;
        public int Sinifi
        {
            get { return mSinifi; }
            set { mSinifi = value; }
        }

        public List mDersleri = new List();


        public Ogrenci()
        {
            Ders dersi = new Ders()
            {
                Adi = "Tarih",
                Dersligi = "T101"
            };
            mDersleri.Add(dersi);

        }
    }

    public class Ders
    {
        public string Adi { get; set; }
        public string Dersligi { get; set; }
    }
}
namespace Fresenius.Turkiye.Dersler.CSharp.OOP.Interface
{
    public interface IKontrat
    {
        void Anlas();
        bool Boz(int _iAnlasmaId);
    }

    public class Akitler : IKontrat
    {
        public void Anlas() { }
        public bool Boz(int _iAnlasmaId) { return true; }

        public void AkitMetodu() { }
    }

    public class Contracts : IKontrat
    {
        public void Anlas() { }
        public bool Boz(int _iAnlasmaId) { return true; }

        public void ContractMethod() { }
    }
}

// Program : Çalışmayan ama çalıştırılabilen dosya
// Process : Programın RAM üzerine alındığı (yani çalıştırıldığı) hali

// Ezgi : Object (Bir sınıftan türeyen nesne)
// Ogrenci : Class (Bir varlığın bilgi/eylemlerini içeren yapı sınıftır)
// Kisi : Class (Class aynı zamanda Tip tir)


// dll(dynamic link library),exe : Assembly
// Ne kodu olursa olsun en az 1 class vardır.
// CSharp : %100 OO
// Executable uygulamalarda başlangıç noktası(entry point) Main fonksiyonudur.

// Hiyerarşik gruplandırma sistemidir.
// namespace HizliBilisim.Media.Sound.Recording { }
// namespace HizliBilisim.Media.Video.Editing { }

// Yapıcı metotlar nesenin başlatıldığı noktaya erişmemizi sağlar. Bu sayede başlangıç değerlerinin uygunluğunu kontrol edebiliriz.
// Default Constructor (Yapıcı Metot) parametresizdir: SınıfınAdı() {}
// Sınıf içinde tanımlı hiç yapıcı metot yoksa compiler otomatik olarak yapıcı metot ekler.
// Parametre alan diğer yapıcı metotlar Overloaded (aşırı yüklenmiş) metotlardır.

// Sınıfa bağlı özellik veya metotlara erişebilmek için, onları "public static " ile tanımlamız gerekir.

// Ctrl + H : find & replace
// Ctrl + K , D : Kodu düzenle
// F9 : Break Point eklemek.
// F5 : Çalıştır
// F10 : Satırın kodunu çalıştır ilerle
// F11 : Satırın içine git ilerle
// Ctrl + K,S kod bloğunu sarmak için

// region ile kodları daraltabiliyoruz.

// override : üst sınıfta tanımlı metodun alt sınıfta ezilerek tekrar yazılmasıdır.
// base : üst sınıfı işaret eder.
// unreachable code : örneğin, return den sonraki satırlar

// public : Umuma açık
// private : Sadece sınıfın içinden erişilebilen
// protected : Türetilen sınıfın içinden ulaşılabilen (Hiç bir obje erişemez).
// property içindeki get ve set metotları eğer {get;set;} şekilde ise, IL koduna compiler tarafından otomatik olarak eklenirler.
// Backing Field : property içinde set ve get edilen sınıf değişkenleridir(Sınıf değişkenleri(field) global değişkenlerdir ve tüm sınıf içinden erişilebilirler).

// Exception : İstisnaları sınıflandırmak ve istisnaya uygun eylemleri gerçekleştirmek için kullanırız.
// İstisnalarda en üst sınıf Exception, alt sınıflar daha belirli istisnaları işaret eder.

// IL : Intermediate Language (Ara dil): .NET içinde yazılan her dilin framework tarafından anlaşılabilen ortak dili

// Encapsulation : Kapsulleyerek erişimini yalıtma.

// Polymorphism : Bir sınıfa bir ya da daha fazla üst sınıf atanabilmesi hali.

// this, bulunduğumuz yeri (yani sınıf) işaret eder. 

// virtual : alt sınıf tarafından ezilebilir demektir ve metod imzasına eklenir (protected virtual void ff())

// Dizi başlatıldığı anda boyutu verilmek zorundadır.
// List değişkenlerin boyutu her hangi bir anda değişebilir. Bu yüzden dizilere göre daha yavaştır.

// interface : Arayüzü uygulayan sınıflara tanımlaması mecburi metotların imzasını(metot gövdesi olmayan kısmı) içerir. Bir kontrattır ve aynı zaman ortak tip demektir.
// arayüzlerden nesne türetilemez. Sadece concrete class lardan obje türetilebilir.
// arayüzlerdeki tüm metot imzaları varsayılan olarak public tir. Ve Accessor Type verilemez(public, private, protected yazılamaz).

// abstract sınıflar interface ile sınıf arasındaki yapılardır ve bu yapılardan nesne üretilemez.
// abstract sınıflarda belirtilen abstract metotlar public ya da protected erişim belirleyicisi alabilirler.
// abstract sınıflar gövdesi olan metotlarıda içerebilir. Bu metotlar istenirse alt sınıflara(protected) ya da nesnelere(public) kullandırılabilir. Bu sayede ortak metotları "abstract class" içinde bir kere yazmış oluruz.

OOP Disadvantages

ref: http://wiki.tcl.tk/13398
Concepts of OOP:
Objects
Classes
Data Abstraction
Encapsulation
Inheritance
Polymorphism

The main difference between procedural and object oriented programming is that the functional programmer try to split function and data (data structures). But object oriented programmers think in objects that hold data and functions (methods) together in one structure.

The problem with polymorphism means that simply finding a function with the right name is not sufficient, you have to also look at the parameters. Trying to read code without a good class browser is almost impossible. It IS impossible once you get into virtual functions where the decision of which function gets called is only determined at runtime.

For example, suppose you're trying to figure out the following line of code
obj.Write(a);
. Which function is being called? Well, if you're lucky and you know what type obj is then you probably only have about 10 different versions of Write() to pick from depending upon what a is. If you're unlucky and obj can be of several types, then you got a lot of work cut out for you.

---

ref:http://www.macs.hw.ac.uk/~alison/ds98/node47.html
As objects are normally referenced by pointers, with memory allocated dynamically, there is a small space ovearhead to store the pointers, and a small speed overhead to find space on the heap (at run-time) to store the objects. For dynamic methods there is an additional small time penalty, as the method to choose is found at run time, by searching through the object hierarchy (using the class precedence list for the object). These days, these efficiency penalties seem to be of relatively little importance compared with the software engineering benefits.