Class Mantıgına Kısa Bakış
Bir sınıf kendisine ait değişkenleri ve fonksiyonları olan bir kod birimidir. Sınıfın sahip olduğu fonsiyonlara method denir.
Sınıf(Class)-Nesne(Object)
Bir sınıf kendisine ait değişkenleri ve fonksiyonları olan bir kod birimidir. Sınıfın sahip olduğu fonsiyonlara method denir. Örneğin bir insan için göz rengi bir değişkendir. Yürümek ise bir metot. Yine insanın adı değişken ve düşünmek bir metottur. Aşağıda bir insan sınıf yaratılıyor. Bu sınıf bir name değişkeni ve run metodu içermektedir.
Sınıf Yapısı
Sınıflar dört bölümden oluşur.
• Erişim Belirleyici: Sınıfa nereden ulaşılabileceğini ifade eder.
• class Anahtar Kelimesi: Oluşturulan kodun sınıf olduğunu ifade etmek için class anahtar kelimesi kullanılır.
• Sınıf Adı: Sınıfa verilen isimdir. İsimlendirme standartlarına göre Pascal Case şeklinde isimlendirme yapılır.
• Sınıf Gövdesi: Sınıfın özellik ve metotlarının bulunduğu kısımdır.
Erişim Belirleyici class Sınıf Adı {
Sınıf Gövdesi
Metot
Metot
Metot
}
public class Person{
public String name;
public void run(){
......//bir şeyler yapıyor
}
}
Yukarıdaki Person sınıfı istenildiği kadar değişik değişken ve metodu barındırabilir. Şimdi bu sınıfın bir nesnesini yaratalım. İnsan sınıfı tüm insanların ortak özelliklerini içerir. Ancak geçek hayatta ahmet,mehmet,victor vs.. gibi nesneler bulunmaktadır. Biz de adı olan bir nesne yaratmak istiyoruz. Bir nesne şu şekilde yaratılır.
Yeni bir nesne tanımlamak için “new” anahtar kelimesi kullanılır. New anahtar kelimesi ile sınıftan bir nesne türetilir
my bir yaşayan nesne oldu. Ancak henüz bir ismi yok. Aşağıda my'a bir isim veriyoruz ve ondan çalışmasını istiyoruz.
Person my=new Person();
my.name="ali";
my.run();
Görüldüğü gibi bir nesne değikenlerine veya metotlarına erişmek için nokta kullanılmaktadır. "my.name" my nesnesinin name değişkeni anlamıdadır. "my.run()" ise my değişkenin run metodunu çağır anlamına gelir. Eğer bir nesne yaratıldığı sırada bazı değişkenlere ihtiyacın varsa "kurucu" kullanılmalıdır. Örneğin isimsiz bir kişi olamaz. O halde yeni bir Person yaratıldığında ismini de almak istiyorsan aşağıdaki gibi kurucu eklenmelidir.
Ogul static fonksiyonsa;
Ana Anax=new Ana();
Anax.Ogul();
isterseniz
Ana.Ogul();
public class Person{
public String name;
public Person(String n){
name=n;
}
public void run(){
......//bir şeyler yapıyor
}
}
Erişim Belirleyiciler (Erişim Düzeyleri)
Java programlama dilinde erişim belirleyiciler; bir sınıfın, özelliğin veya metodun erişilebilirliğini veya kapsamını belirtir. Dört tür Java erişim belirleyici vardır (Tablo 5.1).
1. Private (Özel): Erişim düzeyi sınıf düzeyindedir. Sınıf dışından erişilemez.
2. Default (Varsayılan): Varsayılan erişim düzeyi paketle sınırlıdır. Paket dışından erişilemez. Herhangi bir erişim belirleyici kullanılmazsa bu varsayılan erişim düzeyidir.
3. Protected (Korumalı): Bir alt sınıf aracılığıyla hem paket içinden hem de paket dışından erişilir.
4. Public (Genel): Her yerden ulaşılabilen erişim belirleyicisidir.
Default (Genel) Erişim Belirleyici
Herhangi bir erişim belirleyici kullanılmadığında default belirleyici tanımlanır.
|
package paket1;
public class A{ int deger = 10; void degistir(){ deger=15; } } |
package paket2;
import paket1.*; public class B{ A a = new A(); a.deger = 12; //Hata verir. a.degistir(); //Hata verir. } |
Public (Genel) Erişim Belirleyici
Public erişim belirleyicisine her yerden ulaşmak mümkündür. Herhangi bir kısıtlaması yoktur.
|
package paket1;
public class A{ public int deger = 10; public void degistir(){ deger=15; } } |
package paket2;
import paket1.*; public class B { A a = new A(); a.deger = 12; a.degistir(); } |
Private (Özel) Erişim Belirleyici
Özel erişim belirleyicisine yalnızca sınıfın üyeleri ulaşabilir.
|
public class A {
private int deger = 10; private void degistir(){ deger=15; } } |
public class B {
A a = new A(); a.deger = 12; //Hata verir. a.degistir(); //Hata verir. } |
Protected (Korumalı) Erişim Belirleyici
Paket dışından özellik ve metotlara erişim bir alt sınıf aracılığıyla mümkündür. Alt sınıf tanımlamadan özellik ve metotlara paket dışından erişilemez.
|
package paket1;
public class A{ protected int deger = 10; protected void degistir(){ deger=15; } } |
package paket2;
import paket1.*; public class B extends A{ A a = new A(); a.deger = 12; a.degistir(); } public class C{ A a = new A(); a.deger = 12; //Hata verir. a.degistir(); //Hata verir. } |
Kurucu veya Yapıcı Metotlar (Constructors)
Kurucu String n ile bir String almaktadır. Bu sınıfın nesnesini yaratmak istenildiği zaman bu kurucu kullanılacaktır. Ve böylece isim kesinlikte alınmış olur.
my.run();
Kurucu ile sınıf ismi aynı olmalıdır. Kurucu fonksiyon değildir. Dikkat edilirse geriye değer döndürüp döndürmeyeceği verilmemiştir. Kurucuda buna gerek yoktur. ancak kurucu fonksiyonlar gibi parametre alır.
Kapsülleme Yapısı
Kapsülleme iki adımda gerçekleştirilir. Bu adımlar şunlardır:
• Sınıf içindeki özelliklerin erişim belirleyicisi private olarak ayarlanır.
• Bu private üyelere erişmek ve değerlerini değiştirmek için sırasıyla public Getter ve Setter yöntemleri tanımlanır.
private int yas;
public int getYas() {
return yas;
}
public void setYas(int yas) {
this.yas = yas;
}}
Personel personel1 = new Personel();
personel1.setYas(18);
}
Kalıtım (Miras Alma, Inheritence)
Canlı sınıfını düşünelim. canlı sınıfında doğum tarihi bir değişkendir. Üremek veya ölmek fonksiyondur. Bunlar tüm canlılarda ortaktır. canlılar içinde sadece insan düşünür. İnsan sınıfının düşünmek metodu diğer canlılarda yoktur. İnsan sınıfı canlıdan türemiştir. Canlı sınıfının tüm özelliğini alır ve buna düşünme özelliğini ekler. Aşağıda bir canlı sınıfı yaratıyoruz. Daha sonra insan sıfını canlı sınıfından türetiyor ve düşün fonksiyonunu ekliyoruz.
public class Living{
public String name;
public void die(){
......
}
}
public class Human extends Living{
public void think(){
......
}
}
Önce Living(Canlı) sınıfını yarattık. Living sınıfının name değişkeni ve die(öl) metodu bulunmaktadır. Human(insanoğlu) Living sınıfından türediği için (Human extends Living ile bu işlem gerçekleşir) think(düşün) metoduna ek olarak name değişkeni ve die metoduna sahiptir. Aşağıda hem Living hem de Human yaratıyoruz.
Living l=new Living();
l.name="test";
l.die();
Human human=new Human();
human.name="ali";
human.think();
human.die();
Static Nedir?
Yukarıdaki örneklerde bir sınıfın değişkenini veya metodunu kullanmak için nesne yaratmak zorunda kalıyoruz. Nesne yaratmadan bir sınıfın değişkeninin veya metodunun kullanılması için o değişkenin ve metodun static olması gerekir. Aşağıda Living sınıfının run metodu static yapılıyor. static olduğu için de bir Living nesnesi yaratılmadan kullanılabiliyor.
public class Living(){
public static void run(){ //static metot
...
}
}
...
Living.run(); //static metot çağrılıyor. görüldüğü gibi nesne yaratılmıyor.
Eğer bir sınıfın değişkeni veya metodu static ise SınıfAdı.değişkenAdı veya SınıfAdı.metotAdı() şeklinde kullanılabilir.
int rollno;
String name;
static String college = "ITS";
//static method to change the value of static variable
static void change(){
college = "BBDIT";
}
//constructor to initialize the variable
Student(int r, String n){
rollno = r;
name = n;
}
//method to display values
void display(){System.out.println(rollno+" "+name+" "+college);}
}
//Test class to create and display the values of object
public class TestStaticMethod{
public static void main(String args[]){
Student.change();//calling change method
//creating objects
Student s1 = new Student(111,"Karan");
Student s2 = new Student(222,"Aryan");
Student s3 = new Student(333,"Sonoo");
//calling display method
s1.display();
s2.display();
s3.display();
}
}
İnterface(Arabirim)
İnterface sınıflar gibi temel bir kod birimidir. İnterface'te sadece değişkenler ve boş metotlar bulunur. İnterface'ler sınıflar arasında bir çeşit anlaşma gibi kullanılabilirler. İnterface'si implement eden bir sınıf o interface'teki tüm metodların içlerini doldurmak zorundadır. Örneğin Flyable interface'si olsun. Eagle(Kartal) sınıfı bu interface'si implement eder. Flyable interface'inde sadece fly() metodu bulunmaktadır. Eagle sınıfı bu interface'i implement ettiği için fly(uçmak) metodunu doldurur.
public interface Flyable(){
public void fly();
}
public class Eagle implements Flyable{
public void fly(){
......//burada bir şeyler yap
}
}
implements Flyable ile Eagle sınıfı Flyable sınıfını implement eder ve fly() metodunun içini doldurur. Böylece Eagle bir Flyable olur. Örneğin başka bir sınıf fly metodu olan tüm nesneler için bir işlem gerçekleştirsin. Örneğin fly yeteneği olan tüm nesneleri öldürmek(die) istesin. Bu die metodu parametre olarak Flyable alır.
...
public void die(Flyable f){
//f'yi öldür.
}
...
Eagle e=new Eagle(); //kartal
Hawk h=new Hawk(); //şahin
die(e);
die(h);
Eğer die metodunu sadece die(Eagle e) şeklinde yapsaydık sadece kartalı öldürebilirdik. şahini öldüremezdik. Ancak şimdi hem kartal hem de şahin Flyable interface'ni implement ettiği için ikisini de öldürebiliriz. Ancak tavukları öldüremeyiz. Çünkü onlar uçamaz. Yani Flyable interface'ni implement etmemişlerdir.
Şuna dikkat edilmelidir. Eğer bir interface implement edilmişse interface'in tüm metotları doldurulmalıdır. İnterface'lerin nesnesi yaratılamaz. Doğal olarak kurucuları yoktur. İnterface'ler parametre olarak kullanılabilir. Yukarıdaki die metodu bir interface'si parametre olarak almaktadır.
Abstract(Soyut) Sınıf,Metot
Flyable interface'si public void fly(); şeklinde bir metot içermektedir. Görüldüğü gibi {} şekilde metodun içi(metodun gövdesi) verilmemiştir. Bu tür fonksiyonlara soyut(abstract) fonksiyon denir. Örneğin kuş sınıfını düşünelim. Tüm kuşlar uçarlar. Ancak her kuş değişik bir şekilde uçar. Bu yüzden kuş sınıfında uçma özelliği soyut bırakılmalıdır. Kuş sınıfından türeyen yeni sınıf (örneğin kartal,şahin) uçma özelliğini doldurur. Aşağıda soyut kuş(Bird) sınıfı yaratılıyor ve bu sınıftan kartal(Eagle) ve şahin(Hawk) türüyor.
public abstract class Bird(){
abstract void fly(); //soyut metot.
public void die(){
...
}
...
}
public class Eagle extends Bird{
public void fly(){
....//soyut metot dolduruluyor
}
}
public class Hawk extends Bird{
public void fly(){
....//soyut metot dolduruluyor
}
}
Bir metodun veya Bir sınıfın soyut olduğunu belirtmek için başına abstract kelimesi eklenir. Bird sınıfı da fly metudu soyut olduğu için soyuttur. Soyut sınıfların nesnesi yaratılamaz. Ancak soyut sınıfların kurucuları olabilir. Eğer bir sınıf soyutsa o sınıftan yeni bir sınıf türetilip soyut metotların içi doldurulmalıdır.
Paket Kullanımı
Javada kullanılmak için çok sayıda sınıflar hazırlanmıştır. Bu sınıflar işlevlerine göre gruplandırılmış ve belirli paketlere konulmuştur. Örneğin pencere, menu, düğme, toolbar, kaydırma çubuğu gibi görsel bileşenleri için kullanılan sınıflar java.awt ve javax.swing paketindedir. Java standart olarak belirli paketlerle birlikte gelmektedir. Bu paketler tüm java ortamlarında vardır. Bir sınıfı kullanmak istiyorsanız o sınıfı import(çağırmak) etmeniz gerekir. örneğin Frame sınıfı java.awt paketindedir.
import java.awt.Frame;
public class Test(){
Frame f=new Frame();
}
Frame sınıfı kullanılmaktadır. import java.awt.Frame ile Frame sınıfı çağırılmıştır. Awt paketindeki başka sınıflarıda kullanmak istiyorsanız hepsini import etmeniz gerekir. Ancak hepsini ayrı ayrı import etmek yerine import java.awt.* demeniz yeterlidir. * tüm sınıflar (ve interface'ler) anlamına gelmektedir.
import java.awt.*;
public class Test(){
Frame f=new Frame();
Button b=new Button();
}
Kendi yaptığınız sınıflar içinde paketler yaratabilirsiniz. Örneğin Bird sınıfı için animal.bird paketi yaratabilirsiniz.
package animal.bird;
public class Bird{
...
}
Görüldüğü gibi package ile paketin yeri verilir. Bird sınıfı animal paketinin içindeki bird paketine koyulur. Örneğin Cat sınıfı için
package animal.cat;
public class Cat{
...
}
şeklinde bir paket yaratılabilir.
Kaynak