Bu Sayfayı Paylaş:

Bilgi/Açıklama

Sınıf ve Nesne Kavramı

Java nesneye yönelik bir programlama dilidir. Java'nın temeli sınıftır. Yazılım alanında sınıf (class) birden fazla veri içeren ve veriler üzerinde yapılabilecek işlemleri de tutan programlama birimidir. Sınıfın temel olarak üç bileşeni vardır.
  • field (alan) : sınıfın değişkenleri
  • method (yöntem) : sınıfın işlevleri
  • constructor (kurucu) : sınıfı oluşturan işlev
Şimdi bu üç kavramı açıklayacağız.

Field (Alan)

Bir sınıf birden fazla değişken içerebilir. Bu değişkenler o sınıfın alan (field) üyesidir.
// width ve height özelliği olan bir sınıf
class Rectangle{
	int width;
	int height;
}
Yukarıdaki Rectangle sınıfının width ve height adında iki alanı bulunmaktadır.

Yöntem (Method)

Bir kod parçasına bir isim verilerek bir çok kez kullanılması sağlanabilir. Bunun için o kod parçasını yöntem (method) haline getirmek gerekir. Yöntem genel olarak aşağıdaki gibi tanımlanır.
DönüşTipi methodAdı(Parametre1,Parameter2,..){
	yöntem içeriği
}
Bir yöntem dışarıdan parametre (parameter) alabilir. Ve geriye bir değer döndürebilir. Bir yöntem istenildiği kadar çağrılabilir. Aşağıda bazı yöntem tanımları görülmektedir.
void make(){
}
int get(){
}
int getX(int y){
}
double select(int a,double b){
}
Yukarıdaki örneklerde make yöntemi parametre almıyor ve geriye bir değer döndürmüyor. Örnekte get yöntemi parametre almıyor ve geriye int değeri döndürüyor. Öte yandan, getX yöntemi parametre olarak bir int değeri alıyor ve geriye bir int değeri döndürüyor. Son olarak select yöntemi ise iki parametre alıyor ve geriye double bir değer döndürüyor.
Yöntem çağrılması gerektiği zaman aldığı parametreler verilmek zorundadır. Ve parametrelerin tipleri de uymak zorundadır. Örneğin yukarıdaki getX yöntemine parametre olarak char tipi verilemez.
Bir sınıf birden çok yöntem içerebilir.

Kurucu (Constructor)

Sınıf ve nesne ilişkisini anlamak için İnsan örneğini düşünebiliriz. İnsan bir sınıftır. İnsan sınıfının adı, soyadı, boyu, kilosu alanıdır. Yürü, uyu gibi işlemlerini de yöntemleridir. Ama gerçek hayatta "insan" diye genel bir canlı yoktur. Onun yerine Ali Kaya, Mehmet Demir, Ayşe Taş gibi insanlar bulunmaktadır. Bu saydığım tüm insanlar insan sınıfının bir nesnesidir. Insan sınıfında boy gibi özellik olduğundan Ali, Mehmet ve Ayşe'nin de boy diye bir özelliği olacaktır. Çünkü bu nesneler insan sınıfın bir örneğidir.
class Human{
	double height;
	int weight;
}
Yukarıda bir Human sınıfı tanımlanmıştır. Şimdi bu sınıftan iki insan nesnesi yaratacağız.
// İki insan nesnesi yaratıyoruz. 
Insan a=new Insan();
Insan b=new Insan();
Örnekte a ve b nesnesi iki insan nesnesidir. Burada new (yeni) operatörü yeni bir nesne yaratmak için kullanılır. Burada Insan() şeklinde yazılan ifade constructor (kurucu) tanımıdır. Aslında yukarıdaki ifade aşağıdaki gibi yazılabilir.
Insan a;
a=new Insan();
Örnekte a , Insan tipinde bir nesne olduğununa ilişkin declare (birdirim) işlemi yapılıyor. Daha sonra new Insan() ile yeni bir insan nesnesi yaratıp a'ya atıyoruz.

Bir nesne yaratıldıktan sonra o nesnenin sınıftaki değişkenlerine ve yöntemlerine erişebilir. Örneğin Insan sınıfında weight ve height değişkeni vardır.
// a Insan nesnesi yaratıp, özellikleri alınıyor.
Insan a=new Insan();
int w=a.weight;
double h=a.height;
Yukarı a nesnesinin weight değişkeninin değeri w'ye, height değişkeninin değeri h'ye atanmaktadır.
Bir sınıfta yöntemlerde bulunabilir. Örneğin Insan sınıfında walk() yöntemi var ise aşağıdaki gibi çağrılabilir.
// Insan nesnesi yaratılıp 
    yuru yöntemi çağrılıyor
Insan a=new Insan();
a.walk();
Eğer walk() yöntemi int bir parametre isterse
Insan a=new Insan();
a.walk(4);
şeklinde çağrılması gerekir.
Bir sınıfın birden fazla kurucusu olabilir. Örneğin eğer Insan sınıfının int değer alan bir kurucusu varsa
Insan a=new Insan(5);
şeklinde a nesnesi yaratılabilir. Kurucu bir nesneyi yaratmak için çağrılması gerekir. Parametre alabilir ancak geri dönüş tipi yoktur. Sınıf ismi ile kurucu ismi aynı olmak zorundadır.
Hafızada yaratılmış her nesne kendisine özel bir id (kimlik) değeri vardır. Örneğin a ve b insan nesnesi ise weight ve height özellikleri kendilerine aittir. Eğer a'nın height'i değiştirilirse sadece a nesnesinin height değişkeni değişmiş olur.
Insan a=new Insan();
Insan b=new Insan();
a.height=1.75;
Yukarıdaki örnekte sadece a nesnesinin height özelliği 1.75 yapılmıştır. b'nin height'i değişmemiştir.

Paket (Package) Kavramı

Java standart olarak birçok sınıf ile birlikte gelir. Hepsinin ayrı bir görevi vardır. Örneğin File sınıfı dosya işlemleri yapmak için kullanılabilir. Veya JFrame sınıfı bir pencere yapmak için kullanılabilir. Java bu çok farklı sınıfları yaptığı işlere göre sınıflandırmış ve paket (package) adı verilen yerleştirmiştir. Örneğin ArrayList sınıfı java.util;File sınıfı java.io ve JFrame sınıfı javax.swing paketindedir. Bu çok faklı paketlerdeki sınıfları kullanmak isteyebilirsiniz. Bir paketteki bir sınıfı kullanmanız için o sınıfı önce import (içe al) etmeniz gerekir. Örneğin ArrayList'i kullanmak için import etmeniz gerekir.
import java.util.ArrayList;
class Test{
	ArrayList list;
}
Yukarıda görüldüğü gibi en başa import java.util.ArrayList; ifadesi yazılmıştır. Bu ifade ile ArrayList sınıfını import etmiş oluruz. Bir paket içinde birden fazla sınıfı kullanmanız gerekebilir. Örneğin util paketinde Arrays sınıfını kullanmanız gerekebilir. Bunun için
 
import java.util.ArrayList;
import java.util.Arrays;
yazabiliriz. Bu iki satır yerine aşağıdaki gibi kullanabiliriz.
import java.util.*;

Yukarıda * ile tüm sınıfları import etmek istediğimiz belirtilmiş olur.
Bir paket içinde başka paketler olabilir. Örneğin java.awt.event , java.awt paketinin içindeki bir pakettir. java.awt.* şeklinde import etmeniz java.awt.event paketini import ettiğiniz anlamına gelmez. O yüzden java.awt.event paketi ayrı olarak import edilmesi gerekir.

Bilgi/Açıklama

Nesneye Yönelik Programlama

Sınıf ve Nesne

Daha önce ArrayList, HashMap, Arrays, String gibi sınıfları kullandık. Bu sınıfların hepsinin faklı bir görevi olmasına rağmen hep aynı şekilde kullanılmışlardır. Bir sınıfın nesnesi yaratılmış ve o nesnenin alan veya yöntemlerine erişilmiştir.
X a=new X();
a.methodAdi();
a.methodAdi2(3);
Yukarıda X sınıfından a nesnesi yaratılmıştır. Burada a nesnesi kullanılarak iki yöntem çağrılmıştır. Örnekteki new X() ise bir X nesnesi yaratmak için kullanılır. X(), X sınıfının kurucu (constuctor) durumundadır.. Bir sınıfta birden fazla kurucu olabilir. Örneğin StringTokenizer'ın birden fazla kurucusu vardır.
Bu bölümde artık kendi sınıflarımızı yapmaya başlayacağız. Projenizde sürekli aynı kodların tekrar ettiğini gördüğünüzde bu kodları bir sınıfa koymanız gerekir. Böylece tek bir kod birçok yerden kullanılabilir. Sınıf yapmanızın temel amacı budur.
Bir sınıfın aşağıdaki gibi bir yapısı olmalıdır.
class ClassAdı{
  Field (Alan) (Class Değişkenleri)
  Constructor (Kurucular) 
  Method (Yöntem) (Fonksiyonlar)  
}
Aşağıda Point (Nokta) sınıfı görülmektedir.
// Point sınıfı tanımlanıyor
public class Point{
  // x ve y değişkenleri yaratılıyor.	
  int x;
  int y;
  // İki kurucu yaratılıyor
  Point(){}
  Point(int x,int y){
    setX(x);
    setY(y);
  }
  
  // x için ve y için 
  // set/get yöntemleri yazılıyor.
  int getX(){
    return x;
  }
  void setX(int x){
    this.x=x;
  }
  int getY(){
    return y;
  }
  void setY(int y){
    this.y=y;
  }
}
Point sınıfının iki alanı bulunmaktadır: x ve y. İki kurucusu vardır. Bir kurucusu hiç parametre almamaktadır. İkincisi ise iki int parametre almaktadır. Dört yöntemi bulunmaktadır. Sınıftaki getX() (x'i edin) ve getY() (y'i edin) yöntemleri geriye int değer döndürmektedir ve hiç parametre almamaktadırlar. Sınıftaki setX() (x'e ata) ve setY() (y'ye ata) ise int parametre almaktadırlar ve geriye hiçbir değer döndürmemektedir.

Sınıftaki getX() yöntemi x değişkenini, getY() ise y değişkenini geriye döndürmektedir. Yöntemlerden setX() x değişkenini değiştirirken setY() de y değişkeninin değerini değiştirir. İkinci kurucu parametre olarak x ve y değerlerini almaktadır. Gelen değerler ile setX ve setY yöntemlerini çağırmaktadır. Böylece nesne kurulurken x ve y değerleri verilmiş olur. Şimdi Point sınıfını kullanalım:
Point p1=new Point();
Point p2=new Point(1,2);
int x1=p1.getX();
int x2=p2.getX();
p1.setY(3);
p2.setY(5);
int y1=p1.getY();
int y2=p2.getY();
Örnekte p1 ve p2 nesnesi yaratılmıştır. Dikkat edilirse p1 boş kurucu kullanılarak yaratılmıştır. Bu nedenle p1 nesnesinin x ve y değeri 0 olacaktır. Örnekte p2 nesnesinde ise x ve y değerleri kurucuda verilmiştir. Bu nedenle örnekte x1 değeri 0, x2 değeri 1 olacaktır. Çünkü p1 nesnesinde x değerine henüz bir değer verilmemiştir. Daha sonra her iki nesnenin y değerleri değiştirilmiştir. Yeni y değerleri geçerli olacaktır. Bu sonuca göre p1 noktası 1:3 , p2 noktası ise 2:5 değerinde olur.
Kurucuda bir int dizisi alan ve bu dizi ile ilgili işlemler yapmanızı sağlayan bir sınıf yapalım:
// Kurucuda verilen bir dizi üzerinde 
// işlemler yapan bir class
public class ArrayManager {
  private int[] array;
  // diziyi kurucuda alıyor.
  public ArrayManager(int[] array){
    setArray(array);
  }    
  public void setArray(int[] array){
    this.array=array;
  }
  // Dizi elemanlarını ekrana basan yöntem
  public void print(){
    for(int i=0;i<array.length;i++){
      System.out.println(array[i]);
    }
  }
  // dizinin toplamını bulan yöntem
  public int getSum(){
    int sum=0;
    for(int i=0;i<array.length;i++){
      sum+=array[i];
    }
    return sum;
  }
  
  public static void main(String[] args){
    int[] a={2,1,4,3,6,7};
    // ArrayManager nesnesi yaratılıyor.
    ArrayManager manager=new ArrayManager(a);
    manager.print();
    int sum=manager.getSum();
    System.out.println("toplam: "+sum);
  }
}
Sınıfımızın adı ArrayManager (Dizi Yöneticisi) biçimindedir. Tek bir kurucusu var ve parametre olarak bir dizi almaktadır. Sınıf, parametre olarak aldığı diziyi setArray() (diziyi ata) yöntemini çağırarak array adlı değişkene atıyor. ArrayManager sınıfı iki yöntem içeriyor. print() (bas) yöntemi dizinin tüm elemanlarını ekrana basıyor. Sınıftakı getSum() (toplamı edin) yöntemi ise dizinin toplamını bulup geri döndürüyor.
Bu sınıfı test edebilmek için sınıfa main yöntemi eklenmiştir. Burada bir a dizisi ve ArrayManager nesnesi yaratılmıştır. Daha sonra print() ve getSum() yöntemleri çağrılmıştır. Uygulama çıktısı aşağıdaki gibi olacaktır :
 
2
1
4
3
6
7
toplam: 23

Inheritance (Kalıtım)

Bazı sınıflar ortak özellikler içerirler. Örneğin insan ile kuş arasında çok faklılıklar olmasına rağmen ortak özellikler bulunmaktadır. Örneğin uyuma, ölme, yaş, boy, kilo gibi özellikler hem insanda hem de kuşta bulunmaktadır. O halde kuş ve insan ortak bir kavramdan türemiştir. Bu kavram "Canlı" olabilir. Java'ya uyarlarsak Canlı sınıfı yaratılmalıdır. Bu sınıftan Insan ve Kus türetilmelidir. Insan ve Kus , Canlı sınıfından türediği için Canlı sınıfının tüm alan ve yöntemlerini içerir. Bu kavrama inheritance (kalıtım) denir.
Java'da bir sınıfın başka bir sınıftan türediğini belirtmek için extends (genişletir) kelimesi kullanılır.
 
class Insan extends Canlı{
   // Insan sınıfı Canlı sınıfından türemiştir.
}
Örnek olarak bir Rect (Dikdörtgen) sınıfı yaratalım. Daha sonra özel bir dikdörtgen olan Square (Kare) sınıfı yaratalım.
 
// width ve height değişkenleri olan 
// bir Rect sınıfı yaratılıyor.
public class Rect{
  int width;
  int height;    
  public Rect(){
  
  }
  public Rect(int width,int height){
    setWidth(width);
    setHeight(height);
  }   
  public int getWidth(){
    return width;
  }
  public void setWidth(int width){
    this.width=width;
  }
  public int getHeight(){
    return height;
  }
  public void setHeight(int height){
    this.height=height;
  }    
}
Rect sınıfının width (genişlik) ve height (yükseklik) alanı bulunmaktadır.
// Rect sınıfından türüyen bir sınıf yaratılıyor.
public class Square extends Rect{
  public Square(){}
  // Sadece tek bir değişken alıyor.
  public Square(int a){
    setWidth(a);
    setHeight(a);
  }
  public static void main(String[] args){
    Rect r=new Rect(2,5);
    Square s=new Square(3);
    System.out.println(r.getWidth());
    System.out.println(s.getWidth());
    System.out.println(r.getHeight());
    System.out.println(s.getHeight());
  }
}
Yukarıda Square sınıfı yaratılmıştır ve Square sınıfı ve Rect sınıfını extend etmektedir. Square kare olmasından dolayı genişlik ve yüksekliği eşittir. Bu nedenle kurucuda tek parametre alınabilir. Square sınıfının içinde main ile test yapılmıştır. Dikkat edilirse Square sınıfı içinde Rect sınıfının içindeki yöntemler kullanılmaktadır. Uygulama çalıştırıldığında aşağıdaki gibi bir çıktısı olacaktır :
2
3
5
3
Türeyen sınıf üst sınıfın bazı yöntemlerini değiştirebilir. Buna override (ezme) denir. Örneğin üst sınıfta test() yöntemi olsun. Eğer türeyen sınıf test yöntemi yerine değişik bir test() yöntemi yapmak isterse yapması gereken sadece test() yöntemini kendisine eklemek olacaktır. Böylece üst sınıftaki test() yöntemi alt sınıf için geçersiz hale gelir. Alt sınıfta test() yöntemi çağrıldığı zaman üst sınıftaki test değil alt sınıftaki test çağrılır.

Encapsulation

Sınıfların, alanların veya yöntemlerin başında public, private gibi ifadeler dikkatinizi çekmiştir. Bu ifadeler bir sınıfa, alana veya yönteme erişimi sınırlandırmak için kullanılırlar.
  • public (kamusal) : Her yerden erişilebilir.
  • private (özel) : Sadece sınıf içinden erişilebilir. Bir alan veya yöntem private yapılırsa sadece o sınıf içinden erişilebilir.
  • protected : Sadece sınıf içinden ve sınıftan türeyen sınıflardan erişilebilir demektir.
  • (boş) : Bir sınıf, alan veya yöntem için herhangi bir encapsulation keyword'ü tanımlanmaz ise package-private (pakete özel) olur. Pakete özel olan sınıf, alan veya yöntemlere sadece aynı paket içerisinde olan sınıflar erişebilir.
public class Test{
   private int a;
   protected int b;
   private void test(){
   }
   public int get(){
   }
}
Yukarıda Test sınıfı tanımlanmıştır. Örnekte a değişkeni private tanımlandığı için sınıf dışından erişilemez. Öte yandan b değişkeni protected tanımlandığı için sadece sınıf içinden ve bu sınıftan türeyen sınıflar içinden kullanılabilir. Sınıftaki get() yöntemi public olmasından dolayı her yerden erişilebilir.
Sınıfı değişkenlerini her zaman private yapmanız tavsiye edilir. Bununla birlikte private yapılmış değişkenin değerinin alınması ve set edilebilmesi için set (ata) ve get (edin) yöntemlerinin yapılması önerilmektedir.
public class Test{
	private int year=1990;
	public void setYear(int year){
		this.year=year
	}
	public int getYear(){
		return year;
	}
}
Yukarıda görüldüğü year (yıl) değişkeninin değeri sadece setYear() (yılı ata) ile değiştirilebilir. Özellikle bir değişken set edildiğinde başka bir takım işlemler yapmak gerekiyorsa set yöntemi kullanmak şart olur. Örneğin yıl set edildiğinde bir boolean değişkeni set etmemiz gerekebilir :
public void setYear(int year){
	this.year=year
	isYear=true;
}
Eğer year değişkeni public olsaydı şu şekilde değiştirilebilirdi
Test t=new Test();
t.year=2001;
bu şekilde year alanı set edilirse isYear (yıl mı) değişkeni true olarak set edilmemiş olur ve bir takım hatalara neden olabilir.

Abstract Sınıf

Bir sınıfta yöntemler abstract (soyut) tanımlanabilir. Bir sınıftaki abstract bir yöntemin gövde (body) bölümü yazılmaz. Bu şu anlama gelir: "Ben bir yöntem tanımladım ancak içini doldurmuyorum. Benden türetilen eden sınıf bu yöntemi doldurabilir".
Bir örnek için çeşitli 3D şekiller düşünelim : küre, küp, dikdörtgenler prizması gibi. Bu şekillerin hepsi ortak bir sınıftan türeyebilir. Bu sınıfa Matter (Madde) diyebiliriz. Bu şekillerin hepsinin kütlesi, hacmi, yoğunluğu vardır. Ancak hacim ve kütle hesapları şekilden şekile değişebilir. Ama yoğunluk değişmez. Kütlenin hacme bölünmesidir sadece. O halde Matter sınıfını aşağıdaki gibi tanımlayabiliriz.
// abstract Matter sınıfı tanımlanıyor. 
public abstract class Matter {
  public double getDensity(){
    return getMass()/getVolume();
  }
 
  // iki yöntem abstract tanımlanıyor.	
  abstract public double getMass();
  abstract public double getVolume();
}
Matter sınıfında iki tane abstract yöntem tanımlanmıştır. Görüldüğü gibi bu yöntemlerin içeriği yoktur. Harhangi bir abstract yöntem içeren bir sınıfın abstract olarak tanımlanması gerekmektedir. Bu nedenle sınıf ifadesinin başına abstract eklenmiştir. Sınıftaki getDensity() (yoğunluğu edin) yöntemi kütleyi hacme bölerek hesaplanmaktadır.
Şimdi bir küp bir de küre için iki sınıf yaratalım.
// Abstract Matter sınıfından Sphere 
// sınıfı türetiliyor.
public class Sphere extends Matter{
  int radius=1;
  double mass=1;
  public Sphere(int radius){
    this.radius=radius;
  }
  // abstract getMass ve getVolume dolduruluyor.
  public double getMass(){
    return mass;
  }     	 
  public void setMass(double mass){
    this.mass=mass;
  }    
  public double getVolume(){
    return Math.PI*radius*radius*radius/3;
  }
}
Sphere sınıfı görüldüğü gibi Matter sınıfını extend etmiştir. Sonra getMass() (kütleyi edin) ve getVolume() (hacmi edin) yöntemi doldurulmuştur.
// Abstract Matter sınıfından Cube 
// sınıfı türetiliyor.
public class Cube extends Matter{
    private int edge=1;
    double mass=12;
    public Cube(int edge){
        this.edge=edge;
    }
    // abstract getMass ve 
    // getVolume dolduruluyor.  
    public double getMass() {
        return mass;
    } 
    public void setMass(double mass){
        this.mass=mass;
    }
    public double getVolume() {
        return edge*edge*edge;
    } 
    public static void main(String[] args){
        Sphere s=new Sphere(10);
        s.setMass(10);
        Cube c=new Cube(5);
        c.setMass(2);
        System.out.println(s.getDensity());
        System.out.println(c.getDensity());
    }
}
Aynı şekilde Cube sınıfı Matter'ı extend etmiş ve getMass() ve getVolume() yöntemini doldurmuştur. Cube sınıfın içine main() koyulup test edilmiştir. getDensity() yöntemi her iki nesnenin yoğunluğu vermektedir. Uygulama çalıştığında aşağıdaki bilgiyi basacaktır :
0.00954929658551372
0.016

Interface

Java'da interface (arayüz) tüm yöntemleri abstract olarak tanımlanmış bir sınıf çeşididir. Aşağıda basit bir interface örneği bulunmaktadır.
// İki boş yöntemi olan Shape interface'i tanımlanıyor.
public interface Shape {
    public double getArea();
    public double getPerimeter();
}
Yukarıda Shape interface'si tanımlanmıştır. Bu interface getArea() (alanı edin) ve getPerimeter() (çevreyi edin) yöntemlerini içermektedir. Ama görüldüğü yöntemler boştur.
Java'da interface birçok sınıf arasında ilişki kurulabilmesini sağlar. Örneğin yukarıdaki Shape (Şekil) her 2D şekilde olan iki özellik içerir. Alan ve Çevre. Her şekil (kare, daire, elips, yamuk) alanı ve çevresi olmaktadır. İşte Shape interface'i bu şekilleri birbirine bağlayan bir arabirimdir. Şimdi Daire ve Dikdörtgen için iki şekil nesnesi yapıp Shape'i implement (gerçekleştirme) işlemini yapacağız.
// Shape interface'sini Rect2D implements ediyor.
public class Rect2D implements Shape{
    int width;
    int height;
    public Rect2D(int width,int height){
        setWidth(width);
        setHeight(height);
    }
    public int getWidth(){
        return width;
    }
    public void setWidth(int width){
        this.width=width;
    }
    public int getHeight(){
        return height;
    }
    public void setHeight(int height){
        this.height=height;
    }   
    // Interface'deki iki yöntem dolduruluyor.      
    public double getArea(){
        return width*height;
    }    
    public double getPerimeter(){
        return 2*(width+height);
    }
}
Rect2D sınıfı implements Shape ifadesi ile Shape sınıfını implement etmiştir. Eğer bir sınıf bir interface'i implement etmişse interface'te boş olarak tanımlanmış tüm yöntemleri yazmak zorundadır. Rect2D sınıfında getArea() ve getPerimeter() yöntemleri yazılmıştır. Aynı şekilde Circle2D yaratılabilir.
// Shape interface'sini 
// Circle2D implements ediyor.
public class Circle2D implements Shape{
    int radius=1;
    public Circle2D(int radius){
        setRadius(radius);
    }
    public void setRadius(int radius){
        this.radius=radius;
    }
    public int getRadius(){
        return radius;
    }  
      
   // Interface’deki iki yöntem dolduruluyor.    
    public double getArea() {
        return Math.PI*radius*radius;
    }    
    public double getPerimeter(){
        return 2*Math.PI*radius;
    }
    public static void main(String[] args){
        Rect2D rect=new Rect2D(5,10);
        System.out.println(rect.getArea()); 
        System.out.println(rect.getEnv());
        Circle2D circle=new Circle2D(5);
        System.out.println(circle.getArea());
        System.out.println(circle.getEnv());
    }
}
Circle2D sınıfı da Shape'i implement etmiş ve getArea() ve getPerimeter() yöntemlerini yazmıştır. Bu sınıfa bir main koyulup Rect2D ile birlikte test yapılmıştır. Yukarıdaki uygulama çalıştığında aşağıdaki gibi çıktı oluşur :
50.0
30.0
78.53981633974483
31.41592653589793
Elimizde birden fazla dikdörtgen veya daire şekli olduğunu düşünelim. Biz toplam alanı nasıl bulabiliriz? Aşağıdaki örnek bunu yapmaktadır.
 
// Bir listedeki Shape’lerin alanlarını 
// toplayan örnek
import java.util.*;
public class ShapeSumArea {
    public static void main(String[] args){
        Rect2D rect1=new Rect2D(10,20);
        Circle2D circle1=new Circle2D(3);        
        Rect2D rect2=new Rect2D(10,4);
        Circle2D circle2=new Circle2D(5);
        Circle2D circle3=new Circle2D(6);
        ArrayList list=new ArrayList();
        list.add(rect1);
        list.add(circle1);
        list.add(rect2);
        list.add(circle2);
        list.add(circle3);  
        double sum=0;
        for(int i=0;i<list.size();i++){
            Shape s=(Shape)list.get(i);
            sum+=s.getArea();
        }
        System.out.println(sum);
  }
}
5 şekil nesnesi yaratılmış ve bir listeye eklenmiştir. En sonunda döngü açılmış ve her şeklin alanı toplama eklenmiştir.
Shape s=(Shape)list.get(i);
Satırına dikkat edilirse biz listeye Circle2D ve Rect2D koymamıza rağmen listeden Shape olarak alabiliyoruz. Hem Circle2D hem de Rect2D Shape interface'ni implement ettiği için bu şekilde Shape'e çevrilebilirler. Uygulama çalıştığında 459.91148575128557 değeri çıktıda gözükür.

Polymorphism (Çok Biçimlilik)

Aynı yöntemin farklı sınıflarda farklı şekilde çalışması özelliğinde polymorphism (çok biçimlilik) denir. Basit bir polymorphism örneği yapalım.
public interface Alet{
  public void power(boolean power);
}
Bu interface'i gerçekleştiren sınıflar :
public class TV implements Alet{
  public void power(boolean on){
    if(on){
      gucubaslat();
      ac();
    }else{
      kes();
    }
  }
}
ve
public class SacKurutma implements Alet{
  public void power(boolean on) {
    if(on){
      isit();
      havaver();
    }else{
      kes();
    }
  }
}
TV ile SacKurutma sınıflarında power() yöntemi aynı yapıda olmasına rağmen çağrıldığı durumda farklı bir şekilde çalışmakta ve farklı bir işlev görmektedir. Bu nedenle power() bir polymorphism örneğidir. Aşağıda nasıl kullanılacağı gösterilmiştir.
TV tv=new TV();
tv.power(true);
SacKurutma dryer=new SacKurutma();
dryer.power (true);
tv.power (false);
dryer.power (false);




Bu Sayfayı Paylaş:

İletişim/Bize Yazın   mh@fibiler.com   Google+   Facebook   Twitter   fibiler@googlegroups.com
Her Hakkı Saklıdır
Bu sitede yayınlanan tüm bilgi ve fikirlerin kullanımından fibiler.com sorumlu değildir.
Bu sitede üretilmiş , derlenmiş içerikleri, fibiler.com'u kaynak göstermek koşuluyla kendi sitenizde kullanılabilirsiniz. Ancak telif hakkı olan içeriklerin hakları sahiplerine aittir