Object Oriented Javascript. 
Nesneye Dayalı Programlama tekniklerini, JavaScript’te benzetim yaparak kullanabiliriz. Böylece yazdığımız kodlar daha okunaklı, düzenli, genişletilebilir ve bakımı daha kolay hale gelir.
NEDIR JAVASCRIPT
HTML dokmaninda kullanici tarafli etkilesimi artirmak amaciyla ilk olarak netscape firmasinin olusturdugu bir dil. Dilin isminin javascript konulmasinin nedeni; o donem un kazanan ve halada ununu koruyan java dilinin isminden faydalanmaktir.
Basit bir dildir. C ye yada Java ya asina olan herkes js kodu yazabilir. Her browser in js destegi vardir. Ve her browser ureticisinin implementasyonu kendine aittir. Buna ragmen standartlar(ECMA SCRIPT standarlari) var ve bu standartlar yazilan kodun browserlarda tasinabilirligini sagliyor.
Goruldugu gibi sinif tanimini "class" keyword u kullanarak yapmadim. Onun yerine "function" nesnesini kullandim. Js de "function" olarak kullandigimiz keyword'u "class" keyword u bigi dusunecegiz.
Nesne olusturma diger dillerde(Java, C++) oldugu gibi "new" keyword u kullanarak yapacagiz.
Alt alan ekliyoruz;
"this" nesnenin kendisine referanstir.
"this" keywordu ve devamiyla tanimladigimiz degiskenler "public" tir. Yani bu alt alanlara nesne disindan
direkt ulasilabilir.
"var" keywordu ile tanimladiklarimiza disaridan erismemiz mumkun degildir. Bunlar "private" elemanlar gibidir.
Alt alanlara ulasim soyle:
Nesneye hem argumanli hemde argumansiz iki method ekledik.
Dikkat edilirse tanimladigim "constructor" fonksiyonunu daha siniftan cikmadan cagirdim. Cunku "costructor" mekanizmasi nesneye dayali dillerde "compiler" tarafindan saglanir. Ayni etkiyi vermek icin kullanicinin bu fonksiyonu cagirmasina gerek kalmadan otomatik olarak constructor i cagirmis oldum.
Bu yontemde "constructor" gibi bir fonksiyona ihtiyac duymadan "Java" daki "static initializer" lari kopya edebiliriz. En nihayetinde sinif dedigimiz sey bir fonksiyondur ve cagrildigi yerde, bastan sona kadar islettirilecektir. Dolayisiyla kodun hemen bas tarafina "construction" islemlerini koyabilirim.
>myClass fonksiyonunun (sinifinin) argumanlari kontrol edilerek, farkli argumanli "constructor"lar (overloaded contructor)
elde edilebilir.
>Nesneyi olustururken:
var nesne = new myClass("hosgeldin", 2345);
"Inheritance" OOP nin en onemli konularindan biridir. Aslinda js gibi bir script dilinde kalitimin ne kadar anlamli olacagi tartisilabilir ama yinede kullanilabilecegi yerler var diye dusunuyorum. En azindan bu mekanizmayla birbirine benzeyen siniflar yazarken fazla kod yazmamis oluruz ve saglam, bakimi kolay yapilabilir kodlar elde edebiliriz. Dahasi kodumuz genislemeye musait olmus olur.
"Multiple inheritance" yapmayacagiz (daha dogrusu yapamayacagiz) Burada kullanacagimiz anahtar kelimeler "prototype" ve "call".( ayrintili aciklama icin)
>Buraya kadar olan kisimda siniflarin tanimi yaptik. Dikkat edilirse Object Oriented JS yi anlattigimiz maddelerde(6. maddeye kadar)
tum uygulamalari bu ornekte birlestirdik.
>Kalitimi saglayan iki onemli JS yapisindan kisaca bahsetmek istiyorum.
Ilki "prototype" tanimi.
<YAZAR>GrandChild.prototype.init=function(arg1,arg2,arg3){.......</YAZAR>
Prototype tanimi ile bir sinifa (nesneye degil)
yeni alt alanlar veya methodlar ekleyebilirsiniz. Bunlar sinifa ait olacagi icin(nesneye degil) hafiza kullanimda da buyuk olcude
fayda saglayacaktir. Prototye taniminin kalitim icin onemli bir yapi olmasinin sebebi su: Interpreter bir nesnede bir alt alan yada
method ariyorsa ilk once nesnenin kendisine bakar, eger bulamazsa prototype tanimlamasina bakar ve orada arar. Bulamazsa
prototype in prototype tanimlamasina bakar taki ozyinelemeli dongu sona erene kadar; buda iki sartla olur ya aradigini bulur yada
bakacak baska prototype kalmaz.
Ikinci onemli husus "call" fonksiyonu.
<YAZAR>GrandChild.base.init.call(this,arg1,arg2)</YAZAR>
"Call" fonksiyonu hangi nesnenin methodunu cagirmak istiyorsak onu cagirmamizi saglar. Eger "call" fonksiyonu kullanilmazsa;
(ornege gore) interpreter ilk gordugu (init) methodunu cagiracak ve hicbir zaman base class lari construct edemeyecek ve sonsuz
donguye girecek.Yani hep kendi kendini cagiracak. Bu duruma dusmemek icin call fonksiyonunu kullaniyoruz.
>Asagidaki kod parcasi kalitim i saglayan asil kod parcasidir. "Child" sinifi "prototype" ina "Parent" sinifina alarak genisliyor ve yine
"Child" sinifi kendi sinif tanimina "base" nesnesi olarak Parent in prototype ini aliyor. Akla gelen soru neden Parent degilde Parent in
"prototype" i cevabi da zaten kendisi veriyor. Interpreter prototype yapisi sayesinde bir methodu ozyinelemeli olarak arayabiliyor.
Child.prototype = new Parent();
Child.base=Parent.prototype;
GrandChild.prototype = new Child();
GrandChild.base=Child.prototype;
/*test test test test test test test test test*/
var gcObj=new GrandChild(5,7,22)
alert(gcObj.pVar)
alert(gcObj.cVar)
alert(gcObj.gcVar)
alert(gcObj.getFamilyNo())
alert(gcObj.returnAnArbitrarilyNumber())
alert(gcObj.privateMember) //!!!undefined verir.
/*test test test test test test test test test*/
Bu yazida JS nin nasil nesneye dayali yazilabilecegini gormus olduk. JS yazmayi dusunen yada yazan arkadaslara yardimci olabilecegini
dusunuyorum.
Mehmet Dogan
memetdo@hotmail.com
Kaynak
HTML dokmaninda kullanici tarafli etkilesimi artirmak amaciyla ilk olarak netscape firmasinin olusturdugu bir dil. Dilin isminin javascript konulmasinin nedeni; o donem un kazanan ve halada ununu koruyan java dilinin isminden faydalanmaktir.
Basit bir dildir. C ye yada Java ya asina olan herkes js kodu yazabilir. Her browser in js destegi vardir. Ve her browser ureticisinin implementasyonu kendine aittir. Buna ragmen standartlar(ECMA SCRIPT standarlari) var ve bu standartlar yazilan kodun browserlarda tasinabilirligini sagliyor.
Class Tanimlaması
function myClass(){ ... }
class Car {
this.brand = name;
}
Nesne Olusturma
var object = new myClass();
Alt alan ekliyoruz;
function myClass(){
this.variable1="ben degiskenim";
this.variable2=3244;
var privateVar=333;
}
"this" keywordu ve devamiyla tanimladigimiz degiskenler "public" tir. Yani bu alt alanlara nesne disindan
direkt ulasilabilir.
"var" keywordu ile tanimladiklarimiza disaridan erismemiz mumkun degildir. Bunlar "private" elemanlar gibidir.
Alt alanlara ulasim soyle:
var object1 = new myClass();
var object2 = new myClass();
object1.variable2=43534;
object1.variable1="merhaba dunya";
object2.variable1="ben degistim";
object2.privateVar=34; // "private" alana ulasamaz . Yeni bir "public" alt alan olusturur. "Private" degisken degismez.
Nesneye Method Ekliyoruz
function myClass(){
this.variable1="ben degiskenim";
this.variable2=3244;
this.method1=function(){
this.variable2++;
return (this.variable2 % 20);
}
this.method2=function(arg1, arg2){
return (arg1*this.variable2 + arg2);
}
}
class Car {
constructor(name) {
this.brand = name;
}
present() {
return 'I have a ' + this.brand;
}
}
const mycar = new Car("Ford");
mycar.present();
Costructor
class Araba {
constructor(name, model) { //class objeye çevrildiğinde ilk çalışan fonksiyondur.
this.brand=name;
this.model=model;
}
AbamiYaz() {
return `${this.brand} / ${this.model}`;
}
}
//const Arabam = new Araba("Ford", 2003); //nesne objeye çevriliyor
const Arabam = new Araba(); //nesne objeye çevriliyor
Arabam.brand='Volvo';
Arabam.model=2010;
//document.write(`${Arabam.brand} ${Arabam.model}`);
document.write(Arabam.AbamiYaz());
function myClass(arg1, arg2){
this.variable1="";
this.variable2=0;
this.myClass=function(a1, a2){
this.variable1=a1;
this.variable2=a2;
}
.....
.....
//diger kod parcalari
//constructor i en sonda cagiriyorum
this.myClass(arg1, arg2);
}
Bu yontemde "constructor" gibi bir fonksiyona ihtiyac duymadan "Java" daki "static initializer" lari kopya edebiliriz. En nihayetinde sinif dedigimiz sey bir fonksiyondur ve cagrildigi yerde, bastan sona kadar islettirilecektir. Dolayisiyla kodun hemen bas tarafina "construction" islemlerini koyabilirim.
function myClass(arg1, arg2){
this.variable1=arg1;
this.variable2=arg2;
.....
.....
//diger construction islemleri
//methodlar
}
>myClass fonksiyonunun (sinifinin) argumanlari kontrol edilerek, farkli argumanli "constructor"lar (overloaded contructor)
elde edilebilir.
>Nesneyi olustururken:
var nesne = new myClass("hosgeldin", 2345);
Kalitim (Inheritance)
class Araba {
constructor(marka) {
this.marka = marka;
}
tanit() {
return "Bir " + this.marka + " aracım var";
}
}
class Model extends Araba {
constructor(marka, model) {
super(marka);
this.model = model;
}
goster() {
return this.tanit() + ", modeli " + this.model;
}
}
const benimArabam = new Model("Ford", "Mustang");
benimArabam.goster();
super() metodu üst (parent) sınıfı ifade eder.
Constructor (kurucu) içinde super() metodunu çağırarak, üst sınıfın constructor’ını çalıştırırız ve böylece üst sınıfın özelliklerine (properties) ve metotlarına erişim sağlarız.
"Multiple inheritance" yapmayacagiz (daha dogrusu yapamayacagiz) Burada kullanacagimiz anahtar kelimeler "prototype" ve "call".( ayrintili aciklama icin)
function Parent(arg1){
this.babaNo=1;
var anaNo=1;
Parent.prototype.init=function(arg1){
this.pVar=arg1;
}
this.getFamilyNo=function(){
return ("Baba:"+this.babaNo+" Ana:"+anaNo);
}
this.init(arg1)
}
function Child(arg1,arg2){
this.publicMember="Child Member";
this.pMember2="Merhaba Child";
var privateMember=9999;
Child.prototype.init=function(arg1,arg2){
Child.base.init.call(this,arg1)
this.cVar=arg2;
}
this.returnAnArbitrarilyNumber=function(){
return Math.round(Math.random()*10+1);
}
this.init(arg1,arg2)
}
function GrandChild(arg1,arg2,arg3){
GrandChild.prototype.init=function(arg1,arg2,arg3){
GrandChild.base.init.call(this,arg1,arg2)
this.gcVar=arg3;
}
this.init(arg1,arg2,arg3);
}
>Buraya kadar olan kisimda siniflarin tanimi yaptik. Dikkat edilirse Object Oriented JS yi anlattigimiz maddelerde(6. maddeye kadar)
tum uygulamalari bu ornekte birlestirdik.
>Kalitimi saglayan iki onemli JS yapisindan kisaca bahsetmek istiyorum.
Ilki "prototype" tanimi.
<YAZAR>GrandChild.prototype.init=function(arg1,arg2,arg3){.......</YAZAR>
Prototype tanimi ile bir sinifa (nesneye degil)
yeni alt alanlar veya methodlar ekleyebilirsiniz. Bunlar sinifa ait olacagi icin(nesneye degil) hafiza kullanimda da buyuk olcude
fayda saglayacaktir. Prototye taniminin kalitim icin onemli bir yapi olmasinin sebebi su: Interpreter bir nesnede bir alt alan yada
method ariyorsa ilk once nesnenin kendisine bakar, eger bulamazsa prototype tanimlamasina bakar ve orada arar. Bulamazsa
prototype in prototype tanimlamasina bakar taki ozyinelemeli dongu sona erene kadar; buda iki sartla olur ya aradigini bulur yada
bakacak baska prototype kalmaz.
Ikinci onemli husus "call" fonksiyonu.
<YAZAR>GrandChild.base.init.call(this,arg1,arg2)</YAZAR>
"Call" fonksiyonu hangi nesnenin methodunu cagirmak istiyorsak onu cagirmamizi saglar. Eger "call" fonksiyonu kullanilmazsa;
(ornege gore) interpreter ilk gordugu (init) methodunu cagiracak ve hicbir zaman base class lari construct edemeyecek ve sonsuz
donguye girecek.Yani hep kendi kendini cagiracak. Bu duruma dusmemek icin call fonksiyonunu kullaniyoruz.
>Asagidaki kod parcasi kalitim i saglayan asil kod parcasidir. "Child" sinifi "prototype" ina "Parent" sinifina alarak genisliyor ve yine
"Child" sinifi kendi sinif tanimina "base" nesnesi olarak Parent in prototype ini aliyor. Akla gelen soru neden Parent degilde Parent in
"prototype" i cevabi da zaten kendisi veriyor. Interpreter prototype yapisi sayesinde bir methodu ozyinelemeli olarak arayabiliyor.
Child.prototype = new Parent();
Child.base=Parent.prototype;
GrandChild.prototype = new Child();
GrandChild.base=Child.prototype;
/*test test test test test test test test test*/
var gcObj=new GrandChild(5,7,22)
alert(gcObj.pVar)
alert(gcObj.cVar)
alert(gcObj.gcVar)
alert(gcObj.getFamilyNo())
alert(gcObj.returnAnArbitrarilyNumber())
alert(gcObj.privateMember) //!!!undefined verir.
/*test test test test test test test test test*/
Bu yazida JS nin nasil nesneye dayali yazilabilecegini gormus olduk. JS yazmayi dusunen yada yazan arkadaslara yardimci olabilecegini
dusunuyorum.
Mehmet Dogan
memetdo@hotmail.com
Kaynak
