TextView ve Buton Ekleme

Merhaba arkadaşlar.

Bu yazımda basit bir şekilde textview ve buton eklemenin yolunu göstermeye çalışacağım.

Android uygulaması geliştiriken sürekli kurcalayacağımız bölümler aşağıda kırmızı ile belirtilmiştir. Biraz onlardan bahsedelim.

• src altında java kaynak kodlarının içinde bulunduğu com.example.butondenemesi  isimli paket bulunur. Bu paket içindeki kodlar .java uzantılı dosyada bulunur.
• gen altında oluşturduğumuz nesnelerin otomatik oluşturulmuş idleri R.java dosyasında bulunmaktadır. Bu sayede xml tarafında oluşturulan nesneleri java kodları içerisinde kullanılabilmektedir. Neslerin id ataması için findViewById(R.id.nesne_adi) metodu kullanılmaktadır. Burayı sürekli açıp bir eklemeyecek ya da değiştirmeyeceksiniz ama ne için kullanıldığını bilmekte fayda var.
• res aslında en uğrak noktalarımızdan biri olacaktır. İlk olarak layouttan bahsedelim. layout da .xml uzantılı dosya bulunmaktadır. Nesneleri burdan ekleriz ya da değişiklik yapılacaksa buradan yaparız. Uygulamanın tasarım kısmının yapıldığı yer diyebiliriz. 
• res altındaki diğer bir inceleyeceğimiz alan values. values içinde .xml dosyaları bulunur. Bunlardan strings.xml dosyası eklenen nesnelerin string kontrol noktasıdır. Nesnenin gördüğümüz yazıları burada yapılır. 

Şimdi de uygulamamıza geçelim. İlk olarak nesnelerimiz yani textview ve butonlarımızı layout kısmında ekliyoruz, yerleşimlerini yapıyoruz. Burada dikkat edilmesi gereken yerlerden biri oluşturduğunuz her nesneye id vermeyi unutmayın. Java kodunda nesneleri kullanmak için bu id ler şarttır.id ataması android:id="@+id/nesne_adi" şeklinde olur. 

İlk olarak 3 tane textview ekledim. Gördüğüünüz gibi her birinin id 'si var.İd isimleri farklı olmalı. Daha sonra layout seçimim relative olduğundan textview nesnelerin birbirlerine göre konumunu ayarladır. Bu ayarlamalar için ben kod yazarak uğraşamam diyorsanız şimdilik  Aynı pencerede altta Graphical layout kısmından nesneleri sürükle bırak şeklinde de ekleyebilirsiniz. Dikkat ederseniz son textview nesnesini uygulama ilk açıldığında görünmez yapmak için android:visibilty 'yi kullandım. Burada değinmek istediğim son şey ise values dizini altındaki strings.xml dosyasından nesne yazılarının nasıl çekildiğidir. Bunu resimde de görüldüğü üzere android:text="@string/text_adi_girin" şeklindedir.

Buton içinde aynı şekilde id veriyoruz ve yer ayarlamaları yapıyoruz. Text'leri string.xml'den çekiyoruz. Burada göstermek istediğim iki şey var. İlk buton tıklama işlemini tamamen java kodu üzerinden yaparken , ikinci buton için xml tarafında tanımladığım onClick metoduna göre yine java kodunu kullanarak yapacağım. Bunun için ise sadece ikinci butonumuz için bir metot ismi yazıyoruz.

Daha önce de dediğim gibi nesneleri java kodunda kullanabilmek için id'lerine ihtiyaç vardır. Bu nedenle onCreate metodu içinde kullanılacak tüm nesnelerin id ataması findViewById() metodu ile yapılır.

İlk olarak 1. butonumuza click özelliği kazandıralım.Bunun için setOnClickListener(new OnClickListener)

fonksiyonunu kullanıyoruz. Butona tıkladığımızda oluşacak işlemleri bu metot içinde otomatik oluşan onClick metodu içine yazıyoruz.

İkinci butonun farkı onCreate metodunun dışında tanımlanan metottur(xml de ismini vermiştik). Metodu kendimiz oluşturuyoruz sadece, metodun içi click yapıldıktan sonra gerçekleşecek olaylar ilk butondaki gibi doldurulabilir.

Evet artık uygulamayı yazdığımıza göre emülatörden görelim.Programı run ettiğimizde uygulama aşağıdaki gibi olacaktır.Sırasıyla uygulama ilk açıldığında, İlk butona(yukarıdaki) tıklandığında ve ikinci(alttaki) butona tıklandığında oluşan ekran görüntüleri yer almaktadır.

Herkese iyi çalışmalar...

XML NEDİR?

Extensible Markup Language(XML), World Wide Web Consortium(W3C ) tarafından geliştirilmiş hiç bir tekelin altında olmayan yani bağımsız bir dildir. W3C uluslararası ağ standartlarını belirleyen bir örgüttür. XML de bu belirlenen standartlardan biridir.
W3C 'yi bu kadar önemli kılan birkaç özellik aşağıdaki gibidir.

• Web sayfalarının arama motorlarında ilk sırada görüntülenmesinde etkilidir.
• Farklı tarayıcılarda web sitelerinin farklı görüntülenmesinin önüne geçer.
• Sayfa yükleme süresinin azalması.(max 20 saniye)

W3C hakkında daha fazla bilgiye  buradan erişebilirsiniz.

Şimdi de XML özelliklerinden biraz bahsetmek istiyorum. XML neden bu kadar önemli?Avantajları neler? Yakından tanıdığımız HTML ile ilişkisi var mı?

• XML, HTML'e yakın bir dildir.Aslında kardeşi diyebiliriz. Çünkü çıkış kökenleri aynıdır (SGML). HTML bildiğimiz üzere verinin sadece görünümüyle ilgilenen bir dildir. Oysa XML verinin direk kendisiyle ilgilenir. Yani veriyi ayrıca tanımlar ve taşır.
• XML, HTML dili gibi bir markup dilidir. Belgedeki veriler seçilip işaretlenebilir ve biçim kazandırılabilir.
• XML geliştiricileri kendi etiketlerini (tag) oluşturabilmektedirler.Bu da XML diline esneklik kazandırmaktadır.
• Her elemanın başlangıç ve bitiş tag'i vardır.
• XML ile kod geliştirilirken herhangi bir programlama aracına ihtiyaç yoktur. Tarayıcılarda da yapılabilir.
• XML dilinin büyük, küçük harf duyarlılığı vardır.
• XML'in en önemli özelliklerinden biri bir veri tabanındaki verinin dış sistemlere taşınabilmesidir.
• Farklı veri tabanları veya sistemler arası veri taşımasını sağlayabilir.
• XML  kod yapısı aslında ağaç yapısı gibidir. Kök, çocuklar ve onların çocukları şeklindedir.

XML verilerinin veri tabanına aktarılmasını düşündüğümüzde

 kök                    ->   veri tabanı

çocuk                  ->   tablo

çocuğun çocuğu   ->   alan 

şeklinde tanımlanır.

İşte basit bir XML kod parçası;

<Kitaplar>

<Kitap ISBN="9786055420796">

<baslik>Sherlock Holmes Akıl Oyunlarının Gölgesinde</baslik>

<yazar>Sir Arthur Conan Doyle</yazar>

</Kitap>

<Kitap ISBN="9789752894846">

<baslik>Bin Muhteşem Güneş</baslik>

<yazar>Khaled Hosseini</yazar>

</Kitap>

</Kitaplar>

Kitaplar, kitap, baslik ve yazar taglerini kendim oluşturdum yani önceden tanımlı değillerdi.Daha sonra taglere özgü verileri girdim.Taglerin '/' sembolü ile kapatıldığına yani o tag alanın sonlandırıldığına dikkat edin. 

Veri tabanına aktarım yaptığımızı düşünelim. Bu durumda Kitaplar (kök) veri tabanının adı, Kitap (çocuk) tablo, baslik ve yazar(çocuğun çocuğu) ise tablodaki alanlarımızdır(sütun).

XML hakkında detaylı bilgiye buradan  erişebilirsiniz.

Herkese iyi çalışmalar...

Android Dünyasına Giriş

Mobil donanım üreticilerinin maliyeti düşürmek istemeleri Android’e olan ilgiyi arttırmıştır.

Android; açık kaynak kodlu, ücretsiz, Linux tabanlı, Google tarafında geliştirilen bir mobil işletim sistemidir. Mobil işletim sistemi denir ancak tablet bilgisayarlarda, televizyonlarda da kullanılmaktadır. İhtiyaç duyulan tüm uygulamalar ücretsizdir. Windows mobile, Apple iPhone mobil uygulamaların aksine Android uygulamaları her platformda geliştirilebilir.

Android uygulamalarının geliştirilme aşamasında Java dili kullanılmaktadr. Javanın tercih edilmesinin nedeni, java uygulamalarının farklı donanım sistemlerinde de sorunsuz çalıyor olmasıdır.

Android uygulamaları, mobil cihazlara yüklemeden de Dalvik isimli sanal cihaz ile gerçekleştirilmektedir. Bu sayede daha kolay ve çabuk bir şekilde debug işlemleri gerçekleştirilebilmektedir.

Android, içerinde barındırdığı on binlerce kütüphasi sayesinde sayısız kaynak sunmaktadır.

Android uygulaması geliştirmek için gerekli ortamın hazırlanması şarttır. İhtiyazcınız duyulanları şu şekilde sıralamak gerekirse;

• Uygulama geliştirmek için IDE (Benim tercihim Eclipse’ den  yana oldu.)
• Android SDK
• Ecipse için ADT plugin
• SDK paketleri
• ADT’nin konfigürasyonu

 Bunları tek tek indirmek kurmak gerekirdi. Ancak android developers sitesinden tek bir indirmeyle içerinde hepsini barındıran ADT Bundle ile uygulama geliştirmeye hemen başlanabilir.

Android developers sitesinde yukarıdaki işaretli yer tıklayarak indirmeyi başlatabilirsiniz. Bunun yanı sıra eğer benim IDE'm var ya da Eclipse kullanmak istemiyorum derseniz yine bu siteden gerekli adımlar anlatılmıştır.

Android ortamını kurarken karşılaştığımız SDK, ADT ,IDE  terimlerinden bahsedelim birazda...

SDK : Android uygulamalarını debug, build ve test işlemlerini gerçekleştirmek için API kütüphaneleri ve geliştirme araçlarını temin eder.

ADT : Android fonksiyonlarını eclipse'e ekler.Aslında bir eklentidir.

IDE : Android uygulamalarının geliştirildiği yerdir.Yani kodun yazıldığı yer. Eclipse, Netbeans gibi seçenekler bulunmaktadır.

ROS ( Robot Operating System ) Nedir?

Robotiğe ilgi duyanların kesinlikle bilmesi gereken bir programla tanıştım bu yaz, ROS(Robot Operating System). ROS yani robot işletim sistemi, içerisinde barındırdığı kütüphaneler ve araçlarla robot  uygulamaları geliştirmeyi sağlayan bir yazılım sistemidir.Adının işletim sistemi olmasına bakmayın. Gerçekte bir işletim sistemi değil tabi kide.Böyle denmesinin nedeni , çalışırken işletim sistemine ihtiyaç duymasıdır.Yani, robotik bir uygulamayı çalıştırmak için birçok yazılım ve donanım gereçlerini birbiriyle haberleştirebilmektedir.

ROS, açık kaynak kodlu bir yazılımdır. ROS 'u kullanabilmeniz için Linux tabanlı bir işletim sistemine ihtiyacınız olacaktır.Benim tercihim Ubuntu oldu.Ardından ROS kurulumunu gerçekleştirmek ve ROS çalışma alanını (catkin workspace) oluşturmanız gerekmektedir.Bunları sırasıyla ROS wiki sitesinde bulunan bir çok dökümalardan faydalanarak gerçekleştirebilirisiniz. Burada bulunan tutorials sayesinde adım adım Robotik dünyasına gireceksiniz. Bende ilerleyen yazılarımda gerekli bilgileri vereceğim.
ROS, publisher/subscriber paradigması üzerine kuruludur.Hazırlanan robot davranışları node adı verilen program parçaları üzerinden simülasyon programına gönderilir (publish), hareketi için gerekli verileri çevreden alınır (subscribe). Bu konuyla ilgili ayrıntılı bilgiyi Publisher ve Subscriber yazımdan ulaşabilirsiniz.

ROS kullanırken karşınıza çıkacak diğer bir konu ise Gazebo.Gazebo kullanmaya henüz geçmedim ancak en yakın zamanda geçeceğim onunla ilgili de yazılarım olacak.Şimdilik kısaca bir tanım yapmakla yetineceğim. Gazebo, robot davranışlarının geliştirildiği üç boyutlu bir dünya oluşturur. ROS, Gazebo simülasyon programıyla iletişime geçerek davranış geliştirmenizi sağlamaktadır.Bu da robot modelinin üzerinden sensör verilerinin çekilmesiyle gerçekleştirilmektedir.

Publisher ve Subsciber Nedir?

Merhaba arkadaşlar. Bu yazımda, yazın yapmış olduğum stajın ilk araştırma konusundan yani publisher ve subscriber modelinden bahsedeceğim.

Publisher ve subcriber paradigması , publishers ‘ ın açıkça alıcıları belirtmeden ya da amaçlanan alıcıların bilgisine sahip olmadan mesajın yayınlanmasını gerektirir. Subscriber yayınlanan mesajlardan ilgili olanları kaydeder.

Publish ve subcribe ilişkisi şu şekildedir ; bir uygulama(publishers) belli bir konu üzreindeki mesajı yayınlar , diğer uygulamalar(subscribers) da yayınlanan mesajlara,konu ya da içerik tabanlı kuralları kullanarak abone olur.Bu form one-to-many communication  şeklindedir ve özünde eşzamanlı değildir çünkü mesajı yayınlayan bir uygulama diğer alıcı uygulamalar tarafından geri dönüş olmasını beklemez.

Publisher ve subscriber, ROS(Robot Operating System)' da kullanılan bir modeldir. Oluşturulan sınıflar üzerinden veri simülasyon programına gönderilir(publish), robotun aksesuarlarından sensör verileri program içerisine alınabilir(subscribe).

ÖZYİNELİ FONKSİYONLAR(RECURSIVE FUNCTION)

Yazdığımız programlarda aynı işlemi yapmak için döngüler kullanırız.Bazen programda döngüler kullanmak yerine özyineli(recursive) fonksiyonları kullanmak işimizi kolaylaştırır.Bu fonksiyonlar kendi içinde tekrar kendisini döndüren fonksiyonlardır.Yani bir döngü gibi çalışırlar.bu fonksiyonlar programa sadelik katar ,karmaşıklığı önler.Ancak bellekte daha fazla yer kaplarlar ve diğer şekilde yazdığınız programa göre daha yavaştır.Recursive fonksiyonlar sürekli kendilerini çağırdıkları için dikkat edilmesi gereken durum en son aşama için koşul koyulmasıdır.
Recurive fonksiyonlara bakınırken sürekli  karşımıza çıkan  ve mantığı en basit haliyle ortaya koyan örnek faktöriyel hesabı...

package Recursif_Algorithms;

import java.util.Scanner;

public class Test_Factorial {
 /**
  * @author Aylin COŞKUN
  */
 public static void main(String[] args) {
  int num;
  Scanner num_object=new Scanner(System.in);
  System.out.println("Enter a number to calculate the factorial");
  num=num_object.nextInt();
  System.out.println(factorial(num));
  
  }
 public static int factorial(int number)
 {
  if(number==0 ) 
   return 1;
  else 
   return factorial(number-1)*number;
  }
 }

Bu fonksiyonların mantığı nedir peki?İlk önce şekilde görüldüğü gibi factoriyel(5) için  factoriyel(4)*5 ,factoriyel(4) için factoriyel(3)*4  ve diğerleri içinde yandaki şekildeki gibi bu işlemler tekrar edilir.Ta ki fonksiyon factoriyel(1) i görene kadar.Çünkü biz fonksiyonu yazarken koşul koymuştuk ve bu durum da koşulu sağlamaktadır.Böylece artık factoriyel(2) ,factoriyel(3) ,factoriyel(4) ve son olarakta factoriyel(5) değeri bulunmuş olur.

FABRİKA METOT(FACTORY METHOD)

Factory method ,gerçekleştirilecek bir işlemin birden çok adayı olması durumunda istemci tarafından girilen veriye göre obje oluşturan methoddur.
Tanımdan da anlaşılacağı gibi patternimiz nesne üreten bit metod üzerine kuruludur.Kullanıcı istediği veriyi girer ve işlem gerçekleşir.Gerisi yani nesne oluşumu işlemin gerçekleştirme aşaması istemciyi ilgilendirmez.


Factoy method yapısı genel olarak şu şekildedir.

virtual Product *FactoryMethod(data_type)=0;

Bu tanımlama base (ana) class da yapılır subclass(altsınıf) da bu methedun override edilmesi gerekmektedir.

Şimdi bizde bir uygulama yazalım.Programımız mobile üzerinde çalıştırılan uygulamalar hakkında olsun.Kullanıcı sadece çalıştırmak ya da durdurmak istediği uygulamayı girsin programımızda istemcinin istediği nesneyi üretip gereken işlemleri yapsın.Bunun için de bir factory methoda ihtiyacımız var.Aldığı veri tipi de string olsun ve böylece istemci sadece istediği uygulamanın adını girsin gerisine karışmadan istediği işlem gerçekleşsin.


İşte programımız...

#include

using namespace std;
//**************
//AppStore
//**************
class AppStore
{
protected:
 virtual Applications *createApp(string app)=0;
public:
 void runApp(string app)
 {
  Applications *a;
  a=createApp(app);
  a->run();
 }
 void stopApp(string app)
 {
  Applications *a;
  a=createApp(app);
  a->stop();
 }
};

//**************
//MobileAppStore
//**************
class MobileAppStore:public AppStore
{
private:
 Applications *createApp(string app)
 {
  if(app=="twitter")
   return new TwitterOnMobile();
  else if(app=="skype")
   return new SkypeOnMobile();
  else if(app=="angry bird")
   return new AngryBirdOnMobile();
 }
};
/**************
//Applications
//**************
class Applications
{
public:
 virtual void run()=0;
 virtual void stop()=0;
};

//**************
//SkypeOnMobile
//**************
class SkypeOnMobile:public Applications
{
public:
 void run()
 {
  cout<<"Skype is run on the mobile\n\n";
 }
 void stop()
 {
  cout<<"Skype is stopped on the mobile\n\n";
 }
};

//**************
//AngryBirdOnMobile
//**************
class AngryBirdOnMobile:public Applications
{
public:
 void run()
 {
  cout<<"AngryBird is run on the mobile\n\n";
 }
 void stop()
 {
  cout<<"AngryBird is stopped on the mobile\n\n";
 }
};

//****************
//TwitterOnMobile
//****************
class TwitterOnMobile:public Applications
{
public:
 void run()
 {
  cout<<"Twitter is run on the mobile\n\n";
 }
 void stop()
 {
  cout<<"Twitter is stopped on the mobile\n\n";
 }
};

//**************
//Main
//**************
int main()
{

 AppStore *appstore=new MobileAppStore();

 appstore->runApp("skype");
 appstore->runApp("angry bird");
 appstore->stopApp("skype");
 appstore->runApp("twitter");
 appstore->stopApp("twitter");
 appstore->stopApp("angry bird");



 system("pause");
 return 0;
}

Son olarak bir noktaya daha değinmek istiyorum.Dikkat ederseniz sınıf isimlerimde sürekli mobile kullandım ama istenirse masaüstü uygulamaları da kolayca eklenebilir.

Output...

GÖZLEMCİ TASARIM MODELİ(OBSERVER DESIGN PATTERN)

Observer pattern,değişiklik yaşanan durum hakkında gerekli birimleri bilgilendirmek için kullanılan bir patern yapısıdır.Observer pattern yapısının genel uml diagramı yandaki gibidir.Peki ne anlatıyor bize bu uml diagram?
Öncelikle elimizde gözlenen(subject) ve gözlemci(observer) sınıfımız olmak zorundadır.Gözlemci sınıfımız altında bulunan update() fonksiyonuyla subject yani gözlenen sınıfında meydana gelen değişikliklerden haberdar edilir.Subject sınıfımızda da addObserver() ve deleteObserver() fonksiyonlarıyla değişen durumlardan haberdar olacak gözemciyi ekleme ve silme işlemleri yapılır.notifyObserver() fonksiyonu ise Observer sınıfının update() fonksiyonunu çağırarak değişikliklerden haberdar etmiş olur.
Observer Pattern yapısı,fonksiyonları bu şekildedir.Fonksiyonların işleyişini örnek bir uygulama üzerinden anlatalım...

Yandaki resimde görüldüğü gibi uygulamamız restaurantta verilen siparişlerin işleyişleri hakkında olacaktır.Mutfakta çalışan aşçımız,kasada bulunan kasiyer ve siparişi alan garson bulunmaktadır.Aşçı yapacağı yemekleri bilmek,kasiyerde yemeklerden alınması gereken parayı bilmek ister.O zaman garson sipariş alınca hem aşçıyı hem de kasiyeri bilgilendirsin.Elimizde bu durum da iki gözlemci; mutfak(Kitchen) ,kasiyer(Chaier) ve bir de gözlenen/öznemiz garson (Waiter) vardır.




Uml aşağıdaki gibi olacaktır...

İşte kodumuz.....

#include<iostream>
#include<vector>
#include<string>
#include<list>

using namespace std;

//***********
//Observer
//***********
class Observer
{
public:
virtual void updata(string s,int i,double d)=0;
};

/***********
//Chaier
//***********
class Chaier:public Observer,Display
{
Waiter *w;
vector<string> name;
vector<int >number;
vector<double >cost;
public:
Chaier(Waiter *w)
{
this->w=w;
w->registerObserver(this);
}
~Chaier()
{
w->removeObserver(this);
}
void updata(string new_name,int new_number,double new_cost)
{
name.push_back(new_name);
number.push_back(new_number);
cost.push_back(new_cost);
display();
}
void display()
{
double total_cost=0;
cout<<endl<<"***************** CHAIER DISPLAY ***************"<<"\n\n";
cout<<"Name       Number     Cost"<<endl<<"--------------------------"<<"\n";
for(int i=0;i<name.size();i++)
{
cout<<name[i]<<"         "<<number[i]<<"        "<<number[i]*cost[i]<<"\n";
total_cost+=number[i]*cost[i];
}
cout<<endl<<"TOTAL COST : "<<total_cost<<"\n";
}
};

//***********
//Kitchen
//***********
class Kitchen:public Observer,Display
{
Waiter *w;
vector<string> name;
vector<int >number;
vector<double >cost;
public:
Kitchen(Waiter *w)
{
this->w=w;
w->registerObserver(this);
}
~Kitchen()
{
w->removeObserver(this);
}
void display()
{

cout<<endl<<"************ KITCHEN DISPLAY **************"<<"\n\n";
cout<<"Name       Number"<<endl<<"---------------------"<<"\n\n";
for(int i=0;i<name.size();i++)
{
cout<<name[i]<<"        "<<number[i]<<"      "<<"\n";
}
}
void updata(string new_name,int new_number,double new_cost)
{
name.push_back(new_name);
number.push_back(new_number);
cost.push_back(new_cost);
display();
}

};

//***********
//Display
//***********
class Display
{
public:
virtual void display()=0;
};

//***********
//Subject
//***********
class Subject
{
protected:
string name;
int number;
double cost;
list<Observer*> observer; //Tüm izliyicelerin tutulduğu liste
public:
virtual void registerObserver(Observer *o)=0;
virtual void removeObserver(Observer *o)=0;
virtual void notifyObserver()=0;

};

//***********
//Waiter
//***********
class Waiter:public Subject
{
public:
void registerObserver(Observer *o)
{
observer.push_back(o);
}
void removeObserver(Observer *o)
{
observer.remove(o);
}
void notifyObserver() //Tüm izlyicilerin bilgilerini yeniler.
{
for(list<Observer*>::iterator it=observer.begin();it!=observer.end();it++)
(*it)->updata(name,number,cost);
}
void setOrder(string name,int number,double cost)
{
this->name=name;
this->number=number;
this->cost=cost;
         notifyObserver();
}

};

//***********
//Main
//***********
int main()
{
Waiter *waiter=new Waiter();

Kitchen *kitchen=new Kitchen(waiter); //Kitchen gözlemci olarak eklenniyor.
Chaier *chaier=new Chaier(waiter);    // Chaier gözlemci olarak ekleniyor.

waiter->setOrder("Waffle",2,10);
waiter->setOrder("Kumpir",3,7.5);

delete kitchen; //Kitchen gözlemcilerden çıkarılıyor.Artık değişikliklerden haberda edilmeyecek.

waiter->setOrder("Sutlac",1,7.50);
system("pause");
return 0;
}

Buda output...

JAVA'DA SOYUT SINIF(ABSTRACT CLASS)

Kalıtım(inheritance) konusundan bildiğimiz üzere bir süper sınıf ve onun alt sınıflarında oluşur.Soyut sınıflar da bu aşamada işe yarıyor.Görevleri birleştiricilik yapmaktır yani alt sınıflar için süper sınıf olurlar.Soyut sınıfları  şimdiye kadar  oluşturduğumuz sınıflardan farklı yapan şey bu sınıfın eksik bir sınıf oluşu diyebiliriz.Ne demek bu? Normalde bir sınıf oluşturduğumuzda tüm fonksiyonların gövdesini(body) yazıyorduk.Ancak soyut sınıflarda en az bir metodunun gövdesi yazılmaz.Bu metotlara soyut metot denir ve bu metotlar alt sınıflar için ortak  kullanılan,işlevi aynı olan fakat döndürdükleri değer açısından farklılık gösteren fonksiyonlardır ve her  alt sınıfta override edilmek zorundadır.

Soyut sınıflarda  yapılandırıcılar(contructor),static metotlar soyut metot olamazlar ve bu sınıflardan nesne üretilemez.

Java'da soyut sınıf gösterimi abstract anahtar sözcüğü ile yabılmaktadır.extends kelimesiylede alt sınıfı super sınıfa bağlarız (inherit etmesini sağlarız).Kullanımı şu şekildedir:

public abstract class super_class_name //sınıf tanımlaması
{
         public abstract data_type method_name(); //soyut method tanımlaması
         //other function with body
}
 public class derived_class_name extends super_class_name //alt sınıf tanımlaması
{
   //override...
   //other functions
}

Şimdi de örnek bir uygulama yazalım.Oldukça basit bit  bir örnek.Şekill adında  super soyut sınıfımız var ve alt sınıfları kare ve dikdörtgendir(İstediğimiz kadar şekil ekleyebiliriz.).Alt sınıfların ortak yaptıkları işlev alan hesaplamadır.Bu nedenle alan metodumuzu soyut metot yapacağız.

//*************
//Şekill
//*************
package AbstractClass;

public abstract class Şekill {
	public abstract double alan(); 

}
//*************
//Kare
//*************
package AbstractClass;

public class Kare extends Şekill{
	private double kenar1;
	public Kare(double kenar1)
	{
		this.setKenar1(kenar1);
	}
	public double getKenar1() {
		return kenar1;
	}
	public void setKenar1(double kenar1) {
		this.kenar1 = kenar1;
	}
	public double alan()
	{
		return Math.pow(kenar1, 2);
	}

}
//*************
//Dikdörtgen
//*************
package AbstractClass;

public class Dikdörtgen extends Şekill{
	private double kenar1,kenar2;
	
	public Dikdörtgen(double kenar1,double kenar2)
	{
		this.kenar1=kenar1;
		this.kenar2=kenar2;
	}

	public double getKenar1() {
		return kenar1;
	}

	public void setKenar1(double kenar1) {
		this.kenar1 = kenar1;
	}

	public double getKenar2() {
		return kenar2;
	}

	public void setKenar2(double kenar2) {
		this.kenar2 = kenar2;
	}
	public double alan()
	{
		return kenar1*kenar2;
	}
}
//*************
//Mainn
//*************
package AbstractClass;

public class Mainn {

	/**
	 * @author Aylin COSKUN
	 */
	public static void main(String[] args) {
		Şekill sekil=new Kare(3);
		System.out.println("Karenin alanı : "+sekil.alan());
		
		Şekill sekil2=new Dikdörtgen(2, 7);
		System.out.println("Dikdörtgenin alanı : "+sekil2.alan());
		
		
		

	}

}

Main de ne yaptık peki? Şekil sınıfımızdan nesne oluşturamayız bu nedenle sekil adında instance yapıp buna Kare nesnesi atadık.Böylece artık sekill instance artık Kare gibi davranacaktır ve alan metodu çağrıldığında Kare'nin alanını hesaplayacaktır.Dikdörtgen için de aynı şeyleri yaptık...

Son olarakta program çıktımız...

STRATEJİ TASARIM MODELİ(STRATEGY DESIGN PATTERN)

 

Strateji model(strategy pattern),bir işlemi yapmak için birden fazla yöntem varsa kullanılır.Her bir strateji için diğer bir deyişle her bir algoritma ailesi için  kapsüllenme yapılır.Böylece programa değişebilirlik özelliği verilir.Yani istenilen yöntem rahatlıkla
eklenebilir,silinebilir.Aksi halde programda if-else bloglarından oluşan bir karmaşa hakim olurdu.
Strategy patternin önemli özelliklerinden biri de programın çalışma esnasında(runtime) değiştirilebilir olmasıdır.Ayrıca yandaki umlden de görüldüğü gibi içerikten(context)  bağımsızdır.

Lafı fazla uzatmadan parmakları çalıştırıp koda dökelim demek istediklerimizi...

Yandaki şekilde görüldüğü üzere helikopter,vapur ve bisiklet olmak üzere üç taşıtım var.Üç taşıtta bir yerden bir yere gidince hangi ulaşım yolunu  kullanılır? Sorunun yanıtı bize ulaşım da kullandıkları strateji yi verecektir.Programımızda da bunu kodlayacağız.Ancak istenildiği kadar taşıt,strategy eklenebilir.Bu programın akışını değiştirmez.
Örneğin ben benzin kullanma,korna çalma gibi yeni stratejilerde ekleyebilirdim.

//*************
//Taşıt
//*************


class Taşıt
{
protected:
	KullanılanYol *k;
public:
	void yol()
	{
		k->kullanılanyol();
	}
	void setYol(KullanılanYol *x)
	{
		k=x;
	}
};

//*************
//Bisiklet
//*************
class Bisiklet:public Taşıt
{
public:
	Bisiklet()
	{
		k=new Kara();
	}

};

//*************
//Helikopter
//*************
class Helikopter:public Taşıt
{
public:
	Helikopter()
	{
		k=new Hava();
	}
};

//*************
//Vapur
//*************

class Vapur:public Taşıt
{
public:
	Vapur()
	{
		k=new Deniz();
	}

};
//*************
//Kullanılan Yol
//*************
#include

using namespace std;

class KullanılanYol
{
public:
	virtual void kullanılanyol()=0;
};

//*************
//Kara Yolu
//*************

class Kara:public KullanılanYol
{
public:
	void kullanılanyol()
	{
		cout<<"Kara yolunu kullanilir...\n";
	}
};

//*************
//Hava Yolu
//*************

class Hava:public KullanılanYol
{
public:
	void kullanılanyol()
	{
		cout<<"Hava yolunu kullanilir...\n";
	}
};

//*************
//Deniz Yolu
//*************
class Deniz:public KullanılanYol
{
public:
	void kullanılanyol()
	{
		cout<<"Deniz yolunu kullanilir...\n";
	}
};
//*************
//Main
//*************
int main()
{
	Taşıt *taşıt=new Bisiklet();
	taşıt->yol();
	taşıt->setYol(new Deniz);
	taşıt->yol();
	cout<<"----------------------------\n";
	Taşıt *taşıt2=new Helikopter();
	taşıt2->setYol(new Kara);
	taşıt2->yol();
	taşıt2->setYol(new Deniz);
	taşıt2->yol();
	



	system("pause");
	return 0;
}

Yukarıdaki kodda maninde önce bisiklet taşıtını çağırdık.Onun yapılandırıcısında yol default olarak kara seçilmiştir.İlk yol fonksiyonu çağrıldığında kara yolu der.Ancak set fonksiyonu ile ben bisikletin kullandığı yolu değiştirdim.İkinci taşıt içinde aynı şeyleri yaptım...

Program çıktımız...

JAVA'DA KALITIM(INHERITANCE)

Kalıtım konusuna C++ başlığı altındaki kalıtım(inheritance) adlı yazımda değinmiştim.Zaten mantık hepsi için aynıdır farklı olan ise kullanılan bazı anahtar sözcükler ve metodlardır.Bu yazımda da bunlardan bahsedeceğim.
Kısaca kalıtım neydi?Bir ana/süper sınıf ve ondan türeyen alt sınıfımız vardır.Böylece kod tekrarından kurtularak güvenilir ve kullanışlı programlar yazmış oluruz.
Şimdi de java da  kalıtım(inheritance)  konusuna dönelim.

Extends :Alt sınıfın süper sınıftan miras almasını sağlar.Kullanımı şu şekildedir.
public class derived_class extends super_class{//body}

Super() metodu:Kalıtımda yapılandırıcılar yukarıdan aşağıya yani süper sınıftan alt sınıfa doğru çalışır.Super sınıfın yapılandırıcılarını alt sınıflarda super() metodu ile çağırırız.Eğer super sınıf parametre almışsa super() metodu da onun parametrelerini alır.Aşağıdaki programda belirtilmiştir.

@Override:Metot overriding ile süper sınıfta tanımlanmış aynı isim,parametre ve dönüş tipine  sahip metotların alt sınıflarda kullanımı sağlamak için  kullanılan bir yöntemdir.Metodun işlevi aynıdır fakat değerlerinde ,dönüş tiplerinde değişiklik yapılır.

İşte program....

//*************
//Super class
//**************
package kalitim;
public class personel {
 private String ad;
 private int tc;
 public personel(String ad,int tc)
 {
  this.setAd(ad);
  this.setTc(tc);
 }
 public String getAd() {
  return ad;
 }
       public void setAd(String ad) {
  this.ad = ad;
 }
      public int getTc() {
  return tc;
 }
      public void setTc(int tc) {
  this.tc = tc;
 }
     public String print()
 {
  return "ad : "+getAd()+"\ntc : "+getTc();
 }
}


//*************
//Derived class
//**************
package kalitim;
public class ogrenci extends personel {
 private int okul_no;
 
 public ogrenci(String ad,int tc,int okul_no)
 {
   super(ad,tc);  //super sınıfın parametreli yapılandırıcısı çağrılır ve atama yapılır.
   this.okul_no=okul_no;
 }
 public int getOkul_no() {
  return okul_no;
 }
 public void setOkul_no(int okul_no) {
  this.okul_no = okul_no;
 }
 @Override
 public String print() //print metodu override edilmiştir çünkü okul no eklenmiştir.
 {
  return super.print()+"\nokul no : "+getOkul_no();
 }
}


//*************
//Main
//**************
package kalitim;

public class mainn {

 /**
  * @author Aylin COSKUN
  */
 public static void main(String[] args) {
  personel i=new personel("Aylin COSKUN",12345);
  System.out.println(i.print());
  System.out.println("**********************");
  ogrenci o=new ogrenci("Aynur GUNDOGAN",23456,21);
  System.out.println(o.print());
 }
}

Program çıktısı:

YAPILANDIRICILAR(CONTRUCTORS)

Bir sınıfın değişkenleri ve fonksiyonları o sınıftan nesne üretilmedikçe hiç bir anlam ifade etmezler.Zaten sınıflar bellekte yer kaplamazlar ama ne zaman ki nesne oluşturulur nesneler hemen bellekte yer edinirler.Peki nesnemizi oluşturduk sizce o sınıftan çağrılan ilk fonksiyon hangisidir?Cevabı tabi ki de yapılandırıcılardır.Yapılandırıcılar nesne oluşturulduğu an çağrılan fonksiyondur.Yani sınıfımızın olmazsa olmaz  metodudur.Belki de şimdiye kadar yazılan basit programlarınızda constructorı siz yazmadınız ama programınız hala hatasız bir şekilde çalışıyor.Bunun cevabı da şu, siz her ne kadar yapılandırıcıyı yazmasanızda , unutsanızda java derleyicisi sizin için siz farkında olmadan bir default contructor yaratır.Ama baktı ki siz yazmışsınız hiç yazma zahmetinde bulunmaz.
Yapılandırıcılarınız public olmalıdır.Eğer başka sınıflarda nesne oluşumunu engellemek istiyorsanız private yapabilirsiniz ama bu özel durumlar haricinde kullanılan bir yol değildir.
Peki yapılandırıcımız hangi özelliklere sahip olmalıdır?

1. Sınıfla aynı adı taşımak zorundadır.
2. Dönüş değeri yoktur.
3. Parametreli ya da parametresiz yapılandırıcı olabilir.

Bu üç özellik bizim temel özelliklerimiz.Artık kodlama zamanııı....

package Constructor;

public class Student {
 private String name;
 private int age;
 private int no;
 //Default contructor
 public Student()
 {
  //Değişkenlerimizin default değerleridir.
  name="There  are no name";
  age=0;
  no=0;
 }
 //Non-default contructor
 public Student(String name,int age,int no)
 {
  this.name=name;
  this.age=age;
  this.no=no;
 }
 public void setname(String name)
 {
  this.name=name;
 }
 public void setage(int age)
 {
  this.age=age;
 }
 public void setno(int no)
 {

  this.no=no;
 }
 public  String printID()
 {
  return "name : "+name+"\n"+"age : "+age+"\n"+"no : "+no.
 }
}

Yukarıdaki sınıfımızın işlevi bir öğrencinin adı yaşı ve numarasını edinmektir.Default contructor,parametreli contructor ,set ve printID() fonksiyonlarım bulunmaktadır.

DEFAULT CONSTRUCTOR:
Parametre almayan contructorlardır.Fonksiyonun body kısmında sınıfın değer atamalarına isteğiniz değerleri atayabilirsiniz.(Ben en başta hiç bir ögrenci olmadığını varsayarak default olarak yukarıdaki değerleri atadım.)

NON-DEFAULT CONTRUCTORS:
Parametre alan yapılandırıcılardır.Kullanıcı nesne oluşturma anında bu değerleri de girer ve sınıfımız değişkenlerine o değerler atanır.

Programımızın main kısmı...

package Constructor;

public class Test_main {

 public static void main(String[] args) {
  
  //Default constructor çağrılır
  Student student=new Student();
  System.out.println(student.printID());
  System.out.println("**********************");
  //Set fonksiyonlar ile default değerlere yeni değerler atanır
  student.setname("Aylin");
  student.setage(21);
  student.setno(1236);
  System.out.println(student.printID());
  System.out.println("**********************");
  //Parametreli yani default olmayan contructor çağrılır
  Student student2=new Student("Anil",22,1163);
  System.out.println(student2.printID());
  }

}

Mainde önce default yapılandırıyı çağırmış olduk çünkü parametre girmedik ve böylece Student sınıfımızın değişkenlerine default yapılandırıcı oluştururken atadığımız değerler atanır.Daha sonra set fonksiyonlarla değerleri değiştirip tekrar ekrana yazdırdık.Son olarakta başka bir nesne oluşturduk ve bu sefer parametreli yapılandırıcıyı kullandık.Böylece sınıfın değişkenlerine girdiğimiz değerler atanmış oldu.

Son olarak değinmek istediğim bir konu daha var.Yapılandırıcıyı eğer parametreli yaptıysanız ve default olan yapılandırıcıyı yazmadıysanız derleyici bunun yapılandırıcısı var madem ben yazmam der.Eğer siz nesne oluştururken yukarıdaki student nesnesini oluşturduğumuz gibi yani parametre almadan oluşturursanız program default yapılandırıcı yok diye hata verir.Bu durum tam tersi içnde geçerlidir.Yani sadece default var ama siz nesne oluştururken parametre girerseniz bu seferde parametreli yapılandırıcı yok diye hata verecektir.

Yukarıdaki programımızın çıktısınız da verip yazımı sonlandırıyorum.Herkese iyi çalışmalar :)

METOT AŞIRI YÜKLEME(METHOD OVERLOADING)

Method overloading ,bir sınıf içerinde aynı işleve sahip fonksiyonların yine aynı isimli fakat parametre sayısı,türü ya da fonksiyonun dönüş tipi değiştirilerek kullanılmasıdır.Genel tanım budur.Ne demek istedim peki?Örnek üzerinden açıklayayım.

 Yandaki kodda Sum classı altında aynı işlevi gören yani girilen sayıları toplayan üç fonksiyonumuz var.İsimlerini değiştirmeden bu fonksiyonları kullandım ama dikkat edilmesi gereken konu şu ki ilk fonksiyonda dönüş tipim int , parametre sayım iki ve tipi int;ikinci fonksiyona baktığımızda ise yine aynı isimli,dönüş tipi int fakat parametre sayısı üçtür.Yani isimler ve kullanış amacı aynıdır ama parametre sayıları farklıdır.En altta hatalı kullanım olan bir bölüm vardır.Derleyici hata verir çünkü aynı özelliklere sahip zaten bir fonksiyon vardır.
Özetle ben bir fonksiyonun ismini değiştirmeden dönüş tipi,parametre sayısı ya da parametrelerin dönüş tipinden en az birini farklı yaparak kullanabilirim.

Programımızın uygulama kısmında ise her add fonksiyonunu çağırıp farkı görmüş olduk.
Method overloading , çok fazla karmaşık programlarda aynı işlevi olan fonksiyonlara farklı isim verip isim karmaşası yaşatmaktan kurtarır.
















Herkese iyi çalışmalar :)

PAKET(PACKAGE) NEDİR?

Java öğrenirken karşımıza en çok  paket ve import yapıları çıkacaktır .Yeni başlayanlar için oldukça yabancı terimler olabilir benim içinde öyleydi.Ancak ilk öğrendiğiniz dil java değil ve az da olsa c++ ya da c# biliyorsanız anlamanız oldukça kolay olacaktır.Gelin artık başlayalım.

PAKET(PACKAGE)
Java dilinde oldukça fazla sınıf vardır.Sınıflar paket klasörleri içinde yer alan dosyalardır.Mantıksal olarak bağlantısı olan ya da başka bir deyişle birbiriyle ilişkili sınıflar aynı paket içerinde yer almaktadırlar.
(C++ dilini öğrenmiş olanlar bunu namespace kavramıyla bağdaştırmıştır.)Paket tanımı java.paketAdı.sınıfAdı  şeklinde olur.
import ise sınıfı tanımlar.Yani eğer aynı pakette olmayan bir sınıf kullanılmak istenirse önce
sınıfın import edilmesi gerekmektedir.(C++ dilindeki using kelimesiyle benzerdir.)Kullanımı  import  java.paketAdı.sınıfAdı;
Bazen sınıfAdı yerine * işareti ile karşılaşabilirsiniz.Kullanımı şu şekildedir.
import java.paketAdı.*;  Bu,java.paketAdı paketindeki tüm sınıfları çağırabilirsin demektir.

Anlattıklarımızı basit bir uygulama üzerinde görelim...

Yanda ilk_adim adlı projemizin ,oluşturduğum 3 paketi ve her birinin de bir alt birimi yani sınıfı vardır.Sınıflar yani kaynak kodlarımız .java uzantılı dosyada bulunmaktadır.Aslında burada göstermek istediğim  paket kullanımın amacıdır.Yazdığım aynı isimli ve aynı amaçlı metotların farklı paketler aracılığıyla isim değişikliği yapmadan ve karışıklık olmadan kullanabiliriz.Tek yapmamız gereken hangi paketteki metodu kullanacağımızı belirtmektir.

Yukarıda ilk iki paketimizin içindeki sınıfların içerdiği metotlar yer almaktadır.İki pakette aynı görevi gören ve aynı isimli metotları kullanmaktadır.(Resimleri büyütmek için üzerine tıklayın.)

Buda Test_package adlı  main sınıfımızı içeren son paketimiz.package_1 ve package_2 paketlerimizi import ettim çünkü main kısmında sum() ve print() fonksiyonlarını kullanmadık.Yani bu iki fonksiyonumuzda Test_package paketinde yer almadığı için iki paketi de import etmek zorundayım aksi halde o paketlerin metotlarını kullanamam.

Başka bir nokta ise hangi sınıfın metodunu çağırmak istiyorsak o sınıfın  adını kullandığımıza dikkat edelim.Bu şekilde aynı görevi gören metotları farklı isim kullanarak isim karmaşasına neden olmadan programımı yazdım Bu durum belki böylesine basit bir program için size çok mantıklı gelmeyebilir ancak büyük projelerde oldukça kullanışlıdır.

Son olarak işte program çıktımız...

Herkese iyi çalışmalar... :)

JAVA'YA İLK ADIM

Öncelikte java hakkında kısa ve önemli birkaç özellikten bahsetmek istiyorum.

• Nesne yönelimli bir programlama dilidir.
• İşaretçiler(pointer) yoktur.işaretçi yerine nesne referansı kullanılır.
• Hem derlenen hem de yorumlanan bir dildir.
• Platformdan bağımsızdır.Yani aynı kaynak kodu farklı işletim sistemleri üzerinde de değiştirmeden çalıştırabilirsiniz.(Yazının devamında bu konuyu ayrıntılı olarak açıklayacağım.)

JVM,JRE,JDK NEDİR?

JVM(Java Virtual Machine):Java dilinin özelliklerini sayarken platformdan bağımsız olmasından bahsetmiştim.Peki bu nasıl gerçekleşir? İşte yanıtı...JVM java dilinin taşınabilir olmasını sağlamaktadır ve işletim sisteminin üzerinde bulunur.Java derleyicileri .java uzantılı dosyalarda bulunan kaynak kodu(source code) .class uzantılı dosyalarda saklanan bytecodelara dönüştürür.Bu kodlar bildiğimiz üzere 1 ve 0 'lardan oluşmuştur. Yani binary formatındadır.Ancak bir makine dili değildir. JVM(Java Virtual Machine)  .class uzantısındaki bytecode'u programın çalışması esnasında makine diline çevirir yani yorumlama işlemi gerçekleştirilir ve 

program çalıştırılır.

Kaynak kodun öncelikle  bytecode a çevrilmesi java dilini taşınabilir yapar.Yani platformdan bağımsız anlamına gelmektedir bu.

JRE(Java Runtime Enviroment):Java programlarımızı çalıştırmak için kullandığız bir ortamdır.JVM'yi ve standart java kütüphanelerini içerir.Program yazmak için değil çalıştırmak için kullanılır.

JDK(Java Development Kit):Java da yazılan programın çalıştırılabilmesi için gerekli java derleyicisi,java yorumlayıcısı,java API kütüphanelerini,diğer araçları ve aynı zamanda JVM,JRE'yi de içerir.

Herkese iyi çalışmalar :)

TEMPLATE

Template yapısını şu şekilde anlatayım..

 Yandaki ilk fonksiyonumuz iki integer tipindeki değeri toplayıp yine integer tipinde bir değer döndürür.

ikinci fonksiyonumuz da iki double değer vardır ve fonksiyonun dönüş tipide doubledır.






Verilen iki fonksiyonla aynı işlemi yaptık ama ver tiplerimiz ve dönüş tipimiz faklıydı.Bu aslında function overloading  yapmaktır.Yani aynı işlevi gören bir fonksiyonu farklı parametreler için tekrar yazmaktır.
Her veri tipi için ayrı ayrı fonksiyon yazmak yerine gelin bunu tek fonksiyona indirgeyelim ve bunun için de tabiki template yapısını kullanalım.

Yanda görüldüğü gibi template yapısını kullandım.Function template yapısı için fonksiyonun başına template<typename T> yazmak gereklidir.typename yerine class da yazılabilir.veri tipi olarakta T tipini yazdım.



class template,function template ve farklı sayıda veri tipi içeren template fonksiyon örnek uygulamaları aşağıdaki programdadır.

İşte program...


#include<iostream>
using namespace std;
template<typename T>  // class template için classın en başına bu tanımlama yapılmak zorundadır
class Pair
{
T first;
T second;
public:
Pair(T a,T b)
{
first =a;
second =b;
}
void setFirst(T a)
{
firt=a;
}
void setSecond(T a)
{
second=a;
}
T getFirst()const
{
return first;
}
T getSecond()const
{
return second;
}

};


template<typename T>           //function tamplate için bu tanımlama yapılmalıdır.
T addUp(const Pair<T> &thePair)
{

return thePair.getFirst()+thePair.getSecond(); //dönen değer T tipinde olacaktır.
}

template<typename T,typename K>         //birden fazla veri tipi vardır.
T addUp(T a,K b)
{
return a+b;           //dönüş değeri fonksiyonun aldığı ilk parametreyle aynıdır.
}

int main()
{
Pair<int> a(2,7);                  // <int> nesneye ait verilerin int tipinde olduğu belirtilmiştir.
Pair<double> b(2.2,7.2);      // <double> nesneye ait verilerin double tipinde olduğu belirtilmiştir.


cout<<"first number : "<<a.getFirst()<<endl;
cout<<"second number: "<<a.getSecond()<<endl;
cout<<"sum is  "<<addUp(a)<<endl;
cout<<"----------------------"<<endl;
cout<<"first number  "<<b.getFirst()<<endl;
cout<<"second number "<<b.getSecond()<<endl;
cout<<"sum  is "<<addUp(b)<<endl;
cout<<"----------------------"<<endl;
cout<<"call the addUp(2.3,5) : "<< addUp(2.3,5)<<endl;
cout<<"call the addUp(4,5.2) : "<< addUp(4,5.6)<<endl;
        system("pause");
return 0;
}


Program çıktısı...

ABSTRACT CLASS(SOYUT SINIF)

Kalıtımı(inheritance) programımızda kullanmışsak her zaman ana sınıfı doğrudan kullanmak zorunda değiliz.Yani bir arayüz gibi de kullanabiliriz.İşte abstract class yapısı bunu sağlıyor.Bir sınıfı abastract yapmak için ,sınıfın bir metodunun başına virtual kelimesi ekleyip 0(sıfır)' a eşitlemek yeterli olacaktır.Abstract sınıf için bir tane fonksiyonu  sıfıra eşitlemek yeterlidir.Sıfıra eşitlenen fonksiyon ise pure virtual function adını alır.Bu fonksiyonlar için tanımlama yapılmaz.Bu ,artık o sınıftan nesne oluşturamayacağınız anlamına gelmektedir.

Örneğimize geçmeden önce pure virtual destructordan bahsetmek istiyorum.Bunu destructorın başına virtual kelimesini getirerek yapıyoruz.Amaç ise destructoru pure virtual destructor olan ana sınıfımızdan oluşturulan bir pointer silinirken önce işaret ettiği nesnenin destructorı,çağrılır,sonrada kendi destructorı.

İşte basit bir örnek...

#include<iostream>

using namespace std;

class Base

{

public:

Base()

{

cout<<"Constructor of Base"<<endl;

}

virtual void f()=0; // f() fonksunu pure virtual functiondur.

void g()

{

cout<<"Base::g()"<<endl;

}

virtual ~Base() // Destructorda virtual tanımlanmıştır.

{

cout<<"~Base()"<<endl;

}

};

class Derived:public Base

{

public:

Derived()

{

cout<<"Contructor of Derived"<<endl;

}

void f()

{

cout<<"Derived::f()"<<endl;

}

virtual ~Derived()

{

cout<<"~Derived()"<<endl;

}

};

int main()

{

//Base b; hatalı kullanım çünkü Base abstractır ve abstract sınıftan nesne oluşturulamaz.

Base *ptr; //Base tipinde pointer oluşturdum.

ptr=new Derived;  // ptr pointerı Derivedden oluşturulan nesnenin adresini işaret eder.

ptr->f(); //Derived::f() çağrılır.

ptr->g();// Derivedda olmadığı için Base deki g() çağrılır.

delete ptr;

system("pause");

return 0;

}

Program çıktısı şu şekilde olur...