1-) Java - Nesneye Yönelik Tasarım ve Analiz
Nesneye Yönelik Tasarım ve Analiz 5.10.2016
Değişken
türleri 3 tanedir
1.
İnstance değişkenler kısaca global değişkenler
2.
Static / Sınıf değişkenleri
Bellekte yalnız 1 kopyası oluşturulur!!!
Static olarak olarak oluşturulmuş değişkenler başka classlar tarafından
oluşturulan nesne ile kullanılırsa her
nesne için aynı değişkeni kullanırlar bu sayede static olan değişkende son
değer ne ise ondan devam eder.
Static
olarak oluşturduğumuz değişkenleri diğer class dan nesne oluşturmadanda sınıf
ismi ile ulaşabiliriz örneğin
public
class A extends kus{
public
static void main(String[] args) {
int b=
kus.a;}}
class
kus{
static
int a;}
3.
Final/sabit değişkenler : sonradan değiştirilemezler.
final float pi=(float) 3.14;
1-) Encapsulation (Veri
soyutlama ve saklama)
kısaca bahsetmek gerekirse
private,public,protected yapıyoruzya ha buna Encapsulation deniyor bu kısımda get ve set i kesinlikle
yapalım.. örnek.
class B {
private int var1;
public int getVar1() {
return var1; }
public void setVar1(int var1) {
this.var1 = var1; }}
public class A {
public static void main(String[] args) {
B b = new B();
b.setVar1(10);
System.out.println(b.getVar1());}}
2-)Inheritance(kalitim)
Java da tum siniflar Object sinifinin altsinifidir (subclass). extends yazısını gördünmü bil ki orada kalıtım vardır.Peki kalıtım ne demektir ? Kalıtım kısaca üst sınıfdaki metotları değişkenleri kullanmak için üst sınıfı veya kütüphanede diyebiliriz bu kütüphaneyi extend ederek herşeyini kullanabiliriz. Ayrıtten kendi clasımızdada metodlar tanımlayabılırız. Hem ust sınıfın hem kendı sınıfımızın metotlarına sahip olduk iyi iyi.
Eğer diğer class'ı extend edersen onun metotlarına nesne oluşturmadan sanki kendi metodun gibi erişirsin yani “yazdır();” gibi tabi burada public olduğuna dıkkat edelım J
Örnek..
class Animal {
public void eat() {
System.out.println("eating..."); }}
public class Bird extends Animal{//üst sınıfı kütüphaneyi kendımıze yukledık J
public void fly() {//kendi sınıfımızın metodu
System.out.println("flying..."); }
public static void main(String[] args) {
Bird b = new Bird();
b.fly();// kuşumuz kendisi uçar her hayvan uçmaz :D
b.eat();}}//kuşumuz hayvandır her hayvan yemek yer
3-)Polymorphism (çokbiçimlilik)
Upcasting(tür dönüsümü) burada olur
Nesne realtime(çalışma zamanında) hangi nesneye bağlandığını anlar
Buna “geç bağlama(late binding)” denir.
En üst sınıftan türetilen nesne,,, subclassların suretine bürünebiliyor. Çünkü her subclass da upperclassların bilgisi mevcuttur.
Alt sınıflar üstteki siniflarin ozelliklerini taşır o yüzden polymorphism de parametre alam metot üst sinifin nesnesi olacakki alt siniflar bunun süretine burunebılsın cunku alt sınıf ust sınıfı kapsar
Örnek ile daha iyi anlayacaz!!!
-----------------------------------------------------------------------------------------
public class Ders3KISI {
public void benkimim() {
System.out.println("Ders3KISI benim"); }}
-----------------------------------------------------------------------------------------
class personel extends Ders3KISI {
@Override
public void benkimim() {
System.out.println("personel benim"); }}
-----------------------------------------------------------------------------------------
class muhendis extends personel {
@Override
public void benkimim() {
System.out.println("muhendis benim"); }}
-----------------------------------------------------------------------------------------
class teknisyen extends personel {
@Override
public void benkimim() {
System.out.println("teknisyen benim"); }}
-----------------------------------------------------------------------------------------
class mainn1 {
public static void main(String[] args) {
Ders3KISI kisi = new Ders3KISI();
personel perso = new personel();
muhendis muhe = new muhendis();
teknisyen tek = new teknisyen();
kimimonuyaz(kisi);//poltmorphism çok biçimlilik burdaki parametreden kaynaklanıyor
kimimonuyaz(perso);//poltmorphism çok biçimlilik burdaki parametreden kaynaklanıyor
kimimonuyaz(muhe);//poltmorphism çok biçimlilik burdaki parametreden kaynaklanıyor
kimimonuyaz(tek);//poltmorphism çok biçimlilik burdaki parametreden kaynaklanıyor
}
public static void kimimonuyaz(Ders3KISI birisi) {//poltmorphism çok biçimlilik burdaki parametreden kaynaklanıyor
birisi.benkimim(); }}
//buradaki parametre alan nesne kisi olduğu için subclasslarin hepsinde kisi ozelliğini taşır hatta fazlasını taşır o yüzden //gelen nesneler bu şekle bürünebilir misalen gelen nesne personel türünden olsaydı kisi sinifindan türetilen nesneyi //yollayamazdik çünkü kişi sinifindan türetilen nesne personeldeki özellikleri kapsayamaz eksik kalir birdaha misal //vereyim mühendis sinifindan parametre alsaydik yine olmazdi çünkü mühendis sinifindan türemeyen nesneler örneğin //kisi sinifindan parametre yollasak olmaz nedenmi kişi mühendis olmayabilir o yüzden onun sekline bürünemez //teknisyende bürünemez personelde bürünemez!!!
4-)Overloading veya Overload (aşırı yükleme)
Method Overload, aynı isme sahip birden fazla method'un olabilmesidir diyebiliriz. Kural olarak, overload edilmiş method'lar aynı imza'ya (signature) sahip olamazlar. Method İmzası (Method Signature), method'un ismi ve aldığı parametrelerin tipleri/adedidir. Method imzasına, method'un dönüş tipi dahil değildir örneğin
void test(){
System.out.println("void test()");//çalışır
}
void test(int a){
System.out.println("void test(int a)"); //çalışır
}
int test(int a){//hata veriri çünkü dönüş tipi önemli değil ayırt edemez “test” ismi farklı olması lazım
return 5;
}.
5-)@Override
Override türkçede ezmek, geçersiz kılmak anlamındadır.
Bizim yapacağımız şeyde budur üst sınıftan alınan bir özelliği
Alt sınıfta değiştirmektir. Metot imzaları,ismi,parametre sayisi ve tipi aynı olmalıdır aynı zamanda metodun dönüş tipi ayni olmalıdır kısaca aynısı :D sadece içerik değişecek..
Örneğin..
public class Ders2devam {
void test() {//eğer burası int olursa ve return olursa ovveride edilecek metotda aynı olmalıdır
System.out.println("Ders2devam");
}
}
class B extends Ders2devam {
public static void main(String[] args) {
B a = new B();
// B den türetilmiş bir nesne var ve bu nesnenin içerisinde 2 tane test() metodu var
// ayırt edebilmek için birini ovveride etmesi lazım o yüzden üst siniftaki ovveride ediyor ve subclasdakini kullanır
a.test();
}
@Override
void test() {
System.out.println("B");
}
}
NOT:Eğer türetilen nesne kapsamlı sınıf yani subclass değilse
ovveride o nesnede olmayacağından ezilmeyen metot çalışırJ
5-)Encapsulation özellikleri
Private = sadece kendi sinifindan
erişim sağlanır
Protected= kendi sinifi + alt sinif
Package = kendi sinifi + alt sinif
+ paketteki siniflar
Public = her yerden erişim vardır
5-) SOYUT SINIF(ABSTRACT CLASS)
Alt sınıflarda ovveride edilmesini zorunlu hale getirmek için kullanılabilir J
Her soyut sınıfın en az bir tane soyut metodu olmalıdır(olmayadabilir sallama :D denedim çünkü).
Soyut sınıf içinde somut metot olabilir.
Soyut sınıftan nesne oluşturulamaz(Sallama ben oluşturdum J ama böyle bil)
Constructor metodu tanımlanabilir.
Soyut sınıflarda gövdesiz(abstract{}) metot oluşturulabilir. Örn “public abstract yaz();”
Soyut sınıf , başka sınıfa extends edilirse tüm abstract metotları ovveride edilmek zorundadır.
Soyut sınıflarda yapılandırıcılar(contructor),static,private ve final metotlar soyut metot olamazlar.
Bir örnek yapalım J daha iyi anlayacaz.
Sınıfta Hocanın Örneği(2.11.2016)
abstract public class Ders4SoyutSekil {//2.11.2016
private String
isim;
public String
getIsim_ne() {
return isim; }
public void
setIsim_belirle(String isim) {
this.isim =
isim; }
public void
isimyazdir() {
System.out.println(getIsim_ne());
}
abstract public
double Alanhesapla();
public void
nedir() {//ovveride edilecek
System.out.println("Bu sinif bir şekil oluşturur"); }}
class Daire extends Ders4SoyutSekil {
int yaricap = 0;
final double pi =
3.14;
public Daire(int
yaricap) {
this.yaricap =
yaricap;
super.setIsim_belirle("Daire"); }
@Override
public void
nedir() {
System.out.println("Bu sinif bir daire oluşturur"); }
@Override
public double
Alanhesapla() {
return pi *
yaricap * yaricap; }}
class Dikdortgen extends Ders4SoyutSekil {
int kisa_kenar =
0;
int uzun_kenar =
0;
public
Dikdortgen(int kisa_kenar, int uzun_kenar) {
this.kisa_kenar = kisa_kenar;
this.uzun_kenar = uzun_kenar;
super.setIsim_belirle("Diktortgen"); }
@Override
public void
nedir() {
System.out.println("Bu sinif bir Dikdortgen oluşturur"); }
@Override
public double
Alanhesapla() {//ovveride etmek zorunda cunku abstact sınıfı extend ettı burada
bulunan tum abstract metotları ovverride etmek zorunda
return
uzun_kenar * kisa_kenar; }}
class ana_sinif {
public static void
main(String[] args) {
Daire
nesne_daire = new Daire(5);
nesne_daire.nedir();
System.out.println(nesne_daire.getIsim_ne());
System.out.println(nesne_daire.Alanhesapla());
Dikdortgen
nesne_dikdortgen = new Dikdortgen(5, 5);
nesne_dikdortgen.nedir();
System.out.println(nesne_dikdortgen.getIsim_ne());
System.out.println(nesne_dikdortgen.Alanhesapla()); }}
Kendi Yaptığım misal
abstract class soyut_sinif
{
final double boyut1; //soyut sınıflarda değişkenler final olabilir
private double boyut2; //soyut sınıflarda değişkenler private olabilir
private static double boyut3; //soyut sınıflarda değişkenler static olabilir
//abstract private void a(){} //hatali--> abstact metotlar private olamaz
//abstract final void aa(){} //hatali--> abstact metotlar final olamaz
//abstract public static void yaz1(); //hatali--> abstact metotlar static olamaz
//abstract public void
yaz(){System.out.println("naber");}; //hatali--> abstact metotların gövdesi olamaz
abstract public void yaz(); //doğru govdesi yok private,final veya static değil
soyut_sinif(double
a, double b) { //abstract classlarda
constractor olabilir.. fakat constractor abstract olmaz
boyut1 = a;
boyut2 = b; }
public void naber() { //abstract sınıflarda somut metot olabilir
System.out.println("naber"); }}
Şimdide
bu sınıfı extend edelim
public class Ders4Soyut extends soyut_sinif { //abstact
olan soyut sınıfı extend ettim
public Ders4Soyut(double a, double
b) { //hangi sinifi eklersen ekle
defaulttan farklı constractor'u varsa
super(a,
b); // onu eklemek zorundasın çunku extend ederken nesne oluşuyor ve onun
} //
constractor'unu çağırması lazım
@Override
public void yaz() {//soyut sinifi extend edersen
abstract metodu ovveride etmek zorundasın
System.out.println("naber"); }}
public static void main(String[]
args) {
Ders4Soyut a =
new Ders4Soyut(12, 21);
a.yaz(); }
5-) İnterface(Arayüz veya arabirim) à %100
abstracttır
1) Sen arayüzünü tasarla, içini ben doldururum :D
2) interface degiskenleri biz belirtelim ya da belirtmeyelim public static final dir demistik, yani sabittir. Interface de tanimlanan degiskenler implements eden sinifta degistirilemezler.
3) Bir interface icerisinde tanimlanabilecek degisken tanimlarindan hepsi birbirinin aynisidir.
public int x=1;
int x=1;
static int x=1;
final int x=1;
public static int x=1;
public final int x=1;
public static final in x=1;
4) Metot gövdeleri yoktur. yani { } icermezler.
5) Kurucu metot içermezler
6) Abstract class' larda abstract ve non-abstract metotlar tanimlanabilirken Interface ‘lerde sadece abstract metotlar tanimlanabilir.
7) Tum Interface metotlari belirtelim ya da belirtmeyelim public abstract tir. protected veya private olarak tanimlanamazlar.
8) Bir interface bir ya da daha fazla interface i extend edebilir. Java da siniflar sadece 1 sinifi extend edebilirken bu durum interfaceler icin gecerli degildir.
9) Bir interface diger bir interface i implement edemez.
10) interface taniminda yazalim ya da yazmayalim abstract anahtar kelimesi vardir yani ;
public interface NewInterface
public abstract interface NewInterface ayni anlama gelmektedir.
11) interface ve coklu kalitim a bir ornek
interface A {}
interface B {} à interface C extends A , B {}
12) İnterface , başka class tarafından implements edilirse etmiş olduğu inteface'in tüm metotlarını ovveride etmek zorunda çünkü bunların hepsi abstracttır.
13) abstract bir sinif , bir interface i uygulayabilir ve metotlarini uygulamak zorunda degildir, abstract olmayan bir sinif mutlaka metotlari uygulamak ,(override) , zorundadir.
Java 8
oncesinde interface'lerde sadece abstract (govdesiz) metotlar
tanimlanabiliyordu.
Java 8 ile birlikte artik interface ‘ler default
ve static metotlara sahip olabilmektedir!
public interface Java8Interface {
default void defaultMethod() {
System.out.println("default method java 8 new feature!"); }
default void defaultMethod2() {
System.out.println("default method2 java 8 new feature!"); }}
default metotlar , govdesiz metotlar gibi override edilmek zorunda degildir , dilersek override edebiliriz.
default metotlar icin access level govdesiz metotlar gibi public ‘ tir!
Sınıfta Hocanın Örneği(9.11.2016)
public class Ders5interfaceintStack {//9.11.2016
interface initStact {
void push(int item);//eleman ekleyecegı ıcın deger aldık
int pop();} //çıkan elemanı dondurmek için
class fixedStack implements initStact {
private int
stack[];
private int t;
public
fixedStack(int size) {
stack = new
int[size];
t = -1; }
@Override
public void
push(int item) {
if (t ==
stack.length - 1) {
System.out.println("yiğin dolundur");
} else {
stack[++t]
= item; } } //t'yi
arttır yani sifir yap ondan sonra elemanı ekle
@Override
public int pop() {
if (t == -1) {
System.out.println("yiğinda eleman yok");
} else {
return
stack[t--]; } //çıkan
elemanı dondur ve t'yi 1 azalt
return 0; }}
class DynStack implements initStact {
private int
stack[];
private int t,
size;
public
DynStack(int size) {
stack = new
int[size];
this.size =
size;
t = -1; }
@Override
public void
push(int item) {
if (t ==
stack.length - 1) {//yiğin dolduysa
size =
size * 2;//kapasiteyi 2 ye katla
int temp[]
= new int[size];//geçici kapasıteli dizi
oluştur
for (int i
= 0; i < stack.length; i++) {//değerleri
kopyala
temp[i] = stack[i]; }
stack =
temp;// geçiciyi gerçek dizimize kopyala
stack[++t]
= item;// arttır ve degerımızı yaz
} else {//yiğin
dolu degılse t'mizi arttır ve itemi yaz
stack[++t]
= item; } }
@Override
public int pop() {
if (t == -1) {
System.out.println("yiğinda eleman yok");
} else {
return
stack[t--]; } //çıkan
elemanı dondur ve t'yi 1 azalt
return 0; }}
public static
void main(String[] args) {
System.out.println("-----static--------");
fixedStack f_s
= new fixedStack(3);
f_s.push(12); f_s.push(123); f_s.push(124);
f_s.push(1268);//yiğin doludur mesajı alırsın
System.out.println(f_s.pop());
System.out.println(f_s.pop());
System.out.println(f_s.pop());
System.out.println(f_s.pop());//yiğin
eleman yok mesajı alırsın
System.out.println("-----dinamik--------");
DynStack d_s =
new DynStack(2);
d_s.push(12); d_s.push(123);
d_s.push(124);//yiğinin
kapasıtesı 4 e çıkar
d_s.push(1234);
d_s.push(1236);//yiğinin
kapasıtesı 8 e çıkar
System.out.println(d_s.pop());
System.out.println(d_s.pop());
System.out.println(d_s.pop());
System.out.println(d_s.pop());
System.out.println(d_s.pop());
System.out.println(d_s.pop());//yiğinda
çıkacak eleman kalmadı mesajı alırsın
}}