You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
LocalDate sınıfı (ve tüm diğer Java 8 tarih-zaman sınıfları) geçerlilik kontrolü yapar.
/*---------------------------------------------------------------------------------------------------------------------- LocalDate sınıfı (ve tüm diğer Java 8 tarih-zaman sınıfları) geçerlilik kontrolü yapar. Bu sınıflar geçerli olmayan bilgiler için DateTimeException nesnesi fırlatır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importorg.csystem.util.Console; importjava.time.LocalDate; importjava.time.Month; classApp { publicstaticvoidmain(String[] args) { vardate = LocalDate.of(2019, Month.FEBRUARY, 29); Console.writeLine("%02d/%02d/%04d", date.getDayOfMonth(), date.getMonthValue(), date.getYear()); Console.writeLine("%02d %s %04d %s", date.getDayOfMonth(), date.getMonth(), date.getYear(), date.getDayOfWeek()); } }
LocalDate sınıfının now iismli static metodu sistemin tarih bilgisini elde etmekte kullanılır
/*---------------------------------------------------------------------------------------------------------------------- LocalDate sınıfının now iismli static metodu sistemin tarih bilgisini elde etmekte kullanılır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importorg.csystem.util.Console; importjava.time.LocalDate; classApp { publicstaticvoidmain(String[] args) { vardate = LocalDate.now(); Console.writeLine("%02d/%02d/%04d", date.getDayOfMonth(), date.getMonthValue(), date.getYear()); Console.writeLine("%02d %s %04d %s", date.getDayOfMonth(), date.getMonth(), date.getYear(), date.getDayOfWeek()); } }
/*---------------------------------------------------------------------------------------------------------------------- Sınıf Çalışması: 17.08.1999 tarihinde 03:02:00 zamanında gerçekleşmiş olan büyük depremden bu zamana kadar geçen süreyi saniye olarak artarak devam eden bir biçimde ekrana basan metodu yazınız (ileride daha iyisi yazılacak. Bu efektif olmayan versiyon) (İşletim sisteminin console'nu (terminal) kullanarak test ediniz----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importorg.csystem.samples.bigearthquakeremainderapp.BigEarthquakeRemainderApp; classApp { publicstaticvoidmain(String[] args) { BigEarthquakeRemainderApp.run(); } } packageorg.csystem.samples.bigearthquakeremainderapp; importjava.time.LocalDateTime; importjava.time.Month; importjava.time.temporal.ChronoUnit; publicfinalclassBigEarthquakeRemainderApp { privateBigEarthquakeRemainderApp() {} publicstaticvoidrun() { varearthQuakeDateTime = LocalDateTime.of(1999, Month.AUGUST, 17, 3, 2); while (true) { varnow = LocalDateTime.now(); varseconds = ChronoUnit.SECONDS.between(earthQuakeDateTime, now); System.out.printf("Depremden bu zamana kadar geçen saniye:%d\r", seconds); } } }
LocalDateTime sınıfının toLocalDate ve toLocalTime sınıfları
/*---------------------------------------------------------------------------------------------------------------------- Java'da içiçe tür bildirimleri (nested types): Java'da içiçe tür bildirimleri yapılabilir. Burada öncelikle sınıf içerisinde sınıf bildirimleri ele alınacaktır. Java'da 4(dört) şekilde sınıf içerisinde sınıf bildirimi yapılabilir: 1. static sınıf bildirimi (nested class) 2. non-static sınıf bildirimi (inner class) 3. Yerel sınıf bildirimi (local classes) 4. Anonim sınıf bildirimi (anonymous class) Anahtar Notlar: Bunlar dışında Java 8 ile eklenmiş fonksiyonel programlama tekniklerinin daha gelişmiş olarak yapılabilmesini sağlayan "Lambda ifadeleri ve metot referansları" konusu ileride detaylı olarak ele alınacaktır----------------------------------------------------------------------------------------------------------------------*/
Hiç bir tür içerisinde bulunmayan bir sınıfa "top-level class" denir
/*---------------------------------------------------------------------------------------------------------------------- Hiç bir tür içerisinde bulunmayan bir sınıfa "top-level class" denir----------------------------------------------------------------------------------------------------------------------*/
Top-level class'lar static olarak bildirilemez
/*---------------------------------------------------------------------------------------------------------------------- Top-level class'lar static olarak bildirilemez----------------------------------------------------------------------------------------------------------------------*/staticclassSample { //error }
Bir sınıf içerisinde başka bir sınıf static olarak bildirilebilir.
/*---------------------------------------------------------------------------------------------------------------------- Bir sınıf içerisinde başka bir sınıf static olarak bildirilebilir. Bu durumda içteki sınıf dıştaki sınıfın bir elemanıdır (member). Dolayısıyla sınıfın bir elemanı static olabileceğinden (ctor hariç) içteki sınıf da static anahtar sözcüğü ile bildirilebilir. Tüm sınıf elemanlarında olduğu gibi içte bildirilen bir sınıf da erişim belirleyici alabilir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classA { publicstaticclassB { //... } privatestaticclassC { //... } staticclassD { //... } protectedstaticclassE { //... } }
static sınıfların da elemanları olabilir.
/*---------------------------------------------------------------------------------------------------------------------- static sınıfların da elemanları olabilir. static bir sınıfa sınıf dışından onu kapsayan sınıf ismi ve nokta operatörü ile erişilebilir. Şüphesiz bu durumda erişim belirleyicinin de uygun olması gerekir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { A.Bb = newA.B(); b.x = 10; b.foo(); A.B.bar(); } } classA { publicstaticclassB { publicintx; publicvoidfoo() { System.out.println("foo"); } publicstaticvoidbar() { System.out.println("bar"); } } }
static sınıflar static elemanlar olduğundan import static bildirimi ile isimleri doğrudan kullanılabilir.
/*---------------------------------------------------------------------------------------------------------------------- static sınıflar static elemanlar olduğundan import static bildirimi ile isimleri doğrudan kullanılabilir. Ancak bu durumda kullanım "yop-level class" biçiminde olduğundan okunabilirliğin bozulmamasına dikkat edilmelidir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importstaticorg.csystem.app.A.B; classApp { publicstaticvoidmain(String[] args) { Bb = newB(); b.x = 10; b.foo(); B.bar(); } } classA { publicstaticclassB { publicintx; publicvoidfoo() { System.out.println("foo"); } publicstaticvoidbar() { System.out.println("bar"); } } }
Kapsayan sınıfta static sınıfın elemanlarına erişilebilir
/*---------------------------------------------------------------------------------------------------------------------- Aşağıdaki bar çağrısı doğrudan yapılmıştır. Bu durumda bar ismi B sınıfında bulunmadığından onu kapsayan A sınıfına da bakılır. Yani aşağıdaki durumda bar çağrısı için sınıf ismi kullanmaya gerek yoktur----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { A.Ba = newA.B(); a.foo(10); } } classA { privatestaticvoidbar(intval) { System.out.println("A.bar"); } publicstaticclassB { publicvoidfoo(intval) { System.out.println("B.foo"); bar(val); } } }
Bir sınıf içerisinde non-static bildirilmiş bir sınıf olabilir (inner class)
/*---------------------------------------------------------------------------------------------------------------------- Bir sınıf içerisinde non-static bildirilmiş bir sınıf olabilir (inner class)----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classA { publicclassB { //... } }
inner class türünden bir nesne kapsadığı sınıf dışında referans.new sentaksı ile yaratılabilir.
/*---------------------------------------------------------------------------------------------------------------------- inner class türünden bir nesne kapsadığı sınıf dışında <referans>.new sentaksı ile yaratılabilir. Yani bir inner class türünden nesnenin yaratılabilmesi için kapsayan sınıf türünden bir nesne yaratılmış olmalıdır. Daha açık olarak söylemek gerekirse, inner class türünden bir nesne kapsadığı sınıf türünden bir nesne kullanılarak yaratılabilir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Ax = newA(); A.By = x.newB(); y.foo(); A.Bz = x.newB(); z.foo(); } } classA { publicclassB { publicvoidfoo() { System.out.println("B.foo"); } } }
non-static bildirilmiş bir sınıf içerisinde o nesnenin ilişkin olduğu kapsayan sınıf nesnesinin non-static veri elemanlarına doğrudan erişilebilir
/*---------------------------------------------------------------------------------------------------------------------- non-static bildirilmiş bir sınıf içerisinde o nesnenin ilişkin olduğu kapsayan sınıf nesnesinin non-static veri elemanlarına doğrudan erişilebilir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Ax = newA(); A.By = x.newB(); y.foo(23); System.out.printf("x.m_a=%d%n", x.getA()); varz = x.newB(); z.foo(67); System.out.printf("x.m_a=%d%n", x.getA()); } } classA { privateintm_a; publicintgetA() {returnm_a;} publicclassB { publicvoidfoo(intval) { m_a = val; } } }
Anahtar Notlar: static ve non-static sınıflar için derleyici ürettiği arakod isimlendirmesinde kapsayan sınıf ismini de dahil eder.
/*---------------------------------------------------------------------------------------------------------------------- Anahtar Notlar: static ve non-static sınıflar için derleyici ürettiği arakod isimlendirmesinde kapsayan sınıf ismini de dahil eder. Genel isimlendirme: class A { publix class B { } } bildirimi için B ister static ister non-static olsun, B'nin byte kodu A$B.class dosyası biçiminde yaratılır----------------------------------------------------------------------------------------------------------------------*/
inner class içerisinde A nın static metotları da doğrudan çağrılabilir
/*---------------------------------------------------------------------------------------------------------------------- inner class içerisinde A nın static metotları da doğrudan çağrılabilir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Ax = newA(); A.By = x.newB(); y.bar(); } } classA { publicstaticvoidfoo() { System.out.println("A.foo"); } publicclassB { publicvoidbar() { foo(); } } }
Aşağıdaki örnekte B'nin foo metodu içerisinde kendisini çağırmaması için A sınıfının foo metodu çağrısında sınıf ismi kullanılmıştır
/*---------------------------------------------------------------------------------------------------------------------- Aşağıdaki örnekte B'nin foo metodu içerisinde kendisini çağırmaması için A sınıfının foo metodu çağrısında sınıf ismi kullanılmıştır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Ax = newA(); A.By = x.newB(); y.foo(); } } classA { publicstaticvoidfoo() { System.out.println("A.foo"); } publicclassB { publicvoidfoo() { A.foo(); } } }
Tekrar: "non-static bir metoda metodu çağırmakta kullanılan referans gizlice geçirilir"
/*---------------------------------------------------------------------------------------------------------------------- Tekrar: Arakod düzeyinde non-stati metot kavramı doğrudan yoktur. Tüm metotlar static metotlara dönüştürülür. Şüphesiz bu mantıksal bir anlatımdır. Daha aşağı seviyede static metot kavramı da yoktur. Çağırma işleminde de non-static metodu çağırmada kullanılan referans argüman olarak oluşturulan static metoda geçilir. Aşağıdaki kodlar temsili yazılmış kodlardır Yani kısaca şu söylenebilir: "non-static bir metoda metodu çağırmakta kullanılan referans gizlice geçirilir"----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Samples = newSample(); s.foo(20); //Bu çağrının arakod temsili karşılığıSample.foo(s, 20); } } classSample { privateintm_val; //...publicvoidfoo(intval) { m_val = val; } //foo metodunun arakoddaki temsili karşılığıpublicstaticvoidfoo(Samples, intval) { s.m_val = val; } }
Tekrar: İşte yukarıda belirtilen gizlice geçirilen adrese non-static metot içerisinde this referansı ile erişilebilir
/*---------------------------------------------------------------------------------------------------------------------- Tekrar: İşte yukarıda belirtilen gizlice geçirilen adrese non-static metot içerisinde this referansı ile erişilebilir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { } } classSample { privateintm_val; //...publicvoidfoo(intval) { this.m_val = val; this.bar(); } privatevoidbar() { //... } }
Tekrar: this referansını okunabilirliği bozmamak kaydıyla non-static metot çağrılarında kullanılmalıdır.
/*---------------------------------------------------------------------------------------------------------------------- Tekrar: this referansını okunabilirliği bozmamak kaydıyla non-static metot çağrılarında kullanılmalıdır. Bu durumda okunabilirlik açısından hangi metodun static hangi metodun non-static olduğu çağrıda anlaşılabilir duruma gelir----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { } } classSample { privateintm_val; //...publicvoidfoo(intval) { m_val = val; this.bar(); tar(); } privatevoidbar() { //... } privatestaticvoidtar() { } }
Tekrar: Aşağıdaki durumda this referansı kullanımı zorunludur
/*---------------------------------------------------------------------------------------------------------------------- Tekrar: Aşağıdaki durumda this referansı kullanımı zorunludur----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importorg.csystem.util.Console; classApp { publicstaticvoidmain(String[] args) { Pointp = newPoint(100, 100); Console.writeLine("(%d, %d)", p.x, p.y); } } classPoint { publicintx, y; publicPoint(intx, inty) { this.x = x; this.y = y; } }
Aşağıdaki örnekte foo metodunun içerisinde this referansı B sınıfı türünden olduğundan error oluşur
/*---------------------------------------------------------------------------------------------------------------------- Aşağıdaki örnekte foo metodunun içerisinde this referansı B sınıfı türünden olduğundan error oluşur----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { } } classA { privateintm_x; publicvoidbar() { //.. } publicclassB { publicvoidfoo(intval) { this.m_x = val; //error:this.bar(); //error: } } }
Yukarıdaki durumdan dolayı aşağıdaki çağırmada exception oluşur (StackOverflowException)
/*---------------------------------------------------------------------------------------------------------------------- this expression'ın genel biçimi <sınıf ismi>.this şeklindedir. Bu durumda this expression ile kullanılan sınıf türünden referans elde edilmiş olur. Aşağıdaki kodda A.this diyerek B'nin içerisinde gizlice tutulan A referansına erişilmiş olur. Bu A referansı ilgili B nesnesinin yaratılmasında kullanılan A nesnesinin referansıdır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; importorg.csystem.util.Console; classApp { publicstaticvoidmain(String[] args) { Aa = newA(); A.Bb = a.newB(); b.foo(45); } } classA { privateintm_x; publicvoidfoo(intval) { Console.writeLine("A.foo"); } publicclassB { publicvoidfoo(intval) { m_x = val; Console.writeLine("B.foo"); A.this.foo(val); } } }
Aşağıdaki örnekte makeText metoduna foo içerisinde ilgili B nesnesinin yaratılmasında kullanılan A nesnesinin referansının geçirilmesi gerektiğinden this expression kullanılmalıdır
/*---------------------------------------------------------------------------------------------------------------------- Aşağıdaki örnekte makeText metoduna foo içerisinde ilgili B nesnesinin yaratılmasında kullanılan A nesnesinin referansının geçirilmesi gerektiğinden this expression kullanılmalıdır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { } } classToast { publicstaticvoidmakeText(Aa, Stringmessage) { //... } } classA { //...classB { publicvoidfoo(Stringmessage) { Toast.makeText(A.this, message); } } }
Aşağıdaki örnekte bellek sızıntısı (memory leak) oluşur.
/*---------------------------------------------------------------------------------------------------------------------- Aşağıdaki örnekte bellek sızıntısı (memory leak) oluşur. İleride böyle bir senaryoda bellek sızıntısı durumunun nasıl engelleneceği çeşitli yöntemlerle ele alınacaktır----------------------------------------------------------------------------------------------------------------------*/packageorg.csystem.app; classApp { publicstaticvoidmain(String[] args) { Sample.foo(); Sample.foo(); while (true) //Program devam ediyor ; } } classSample { publicstaticvoidfoo() { Aa = newA(); a.doWork("merhaba"); } } classA { privateBm_b; privateclassB { publicvoidfoo(Stringmessage) { } } //...publicvoiddoWork(Stringmessage) { m_b = this.newB(); m_b.foo(message); } } /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
