{"id":31916850,"url":"https://github.com/kalayciburak/java_mulakat_soru_cevap","last_synced_at":"2025-10-14T21:01:46.378Z","repository":{"id":318621594,"uuid":"1072054598","full_name":"kalayciburak/java_mulakat_soru_cevap","owner":"kalayciburak","description":"Java Mülakat Soru ve Cevapları","archived":false,"fork":false,"pushed_at":"2025-10-08T12:17:50.000Z","size":108,"stargazers_count":4,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"master","last_synced_at":"2025-10-08T14:27:36.100Z","etag":null,"topics":["backend","java","mulakat","spring-boot"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/kalayciburak.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-10-08T07:42:04.000Z","updated_at":"2025-10-08T12:18:31.000Z","dependencies_parsed_at":"2025-10-08T14:28:17.896Z","dependency_job_id":"f65f7af7-6913-4a5e-b859-daa3049f4337","html_url":"https://github.com/kalayciburak/java_mulakat_soru_cevap","commit_stats":null,"previous_names":["kalayciburak/240_temel_java_mulakat_soru_cevap","kalayciburak/java_mulakat_soru_cevap"],"tags_count":null,"template":false,"template_full_name":null,"purl":"pkg:github/kalayciburak/java_mulakat_soru_cevap","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kalayciburak%2Fjava_mulakat_soru_cevap","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kalayciburak%2Fjava_mulakat_soru_cevap/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kalayciburak%2Fjava_mulakat_soru_cevap/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kalayciburak%2Fjava_mulakat_soru_cevap/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/kalayciburak","download_url":"https://codeload.github.com/kalayciburak/java_mulakat_soru_cevap/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kalayciburak%2Fjava_mulakat_soru_cevap/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":279016939,"owners_count":26085906,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-13T02:00:06.723Z","response_time":61,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["backend","java","mulakat","spring-boot"],"created_at":"2025-10-13T20:14:32.474Z","updated_at":"2025-10-13T20:14:35.128Z","avatar_url":"https://github.com/kalayciburak.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"### 1) Java’da `static block` ve `static initializer` nedir?\n\nBir sınıf JVM tarafından **ilk kez yüklendiğinde** çalıştırılan özel bloklardır.  \n`static` alanları (sınıfa ait değişkenleri) başlatmak için kullanılırlar.  \nBir sınıf için **sadece bir kez** çalışırlar ve **constructor’lardan önce** yürütülürler.\n\n```java\nclass Demo {\n    static int count;\n    static {\n        count = 10;\n        System.out.println(\"Static block çalıştı\");\n    }\n}\n```\n\n---\n\n### 2) Bir constructor’dan başka bir constructor nasıl çağrılır?\n\nAynı sınıf içindeki başka bir constructor’ı çağırmak için `this()` kullanılır.\n\nKurallar:\n\n- `this()` **ilk satırda** olmalı.\n    \n- Bir constructor içinde **yalnızca bir tane** `this()` çağrısı olabilir.\n    \n\n```java\nclass Car {\n    Car() { this(\"Default\"); }\n    Car(String name) { System.out.println(name); }\n}\n```\n\n---\n\n### 3) Method Overriding nedir?\n\nBir **alt sınıf**, üst sınıfta tanımlanmış bir metodu **aynı imza** (isim + parametre tipi + dönüş tipi) ile yeniden tanımlarsa buna **overriding** denir.  \nAmaç, **farklı davranış** kazandırmaktır.  \nÇağrı **runtime**’da (çalışma zamanında) hangi nesne tipine aitse o versiyon çalışır.\n\n---\n\n### 4) `super` anahtar kelimesi nedir?\n\n`super`, alt sınıftan üst sınıfın **değişkenlerine, metotlarına veya constructor’ına** erişmek için kullanılır.  \nİki biçimde kullanılır:\n\n- `super()` → üst sınıfın constructor’ını çağırır (ilk satırda olmalı).\n    \n- `super.variable` veya `super.method()` → üst sınıfın üyesine erişir.\n    \n\n---\n\n### 5) Overloading vs Overriding farkı nedir?\n\n|Özellik|Overloading|Overriding|\n|---|---|---|\n|Tanım|Aynı sınıfta, aynı isimli ama **farklı parametreli** metotlar|Üst ve alt sınıflarda, **aynı imzalı** metotlar|\n|İlişki|Aynı sınıf içinde|İki sınıf (inheritance) arasında|\n|Dönüş tipi|Farklı olabilir|Aynı olmalı (ya da covariant)|\n|Zaman|Compile-time (statik polimorfizm)|Runtime (dinamik polimorfizm)|\n\n---\n\n### 6) Abstract class ve Interface farkı nedir?\n\n|Özellik|Interface|Abstract Class|\n|---|---|---|\n|Metotlar|Tümü abstract (Java 8+ ile default/static de olabilir)|Abstract ve concrete metotlar olabilir|\n|Değişkenler|`public static final` zorunlu|Her erişim düzeyi olabilir|\n|Miras|Çoklu kalıtım sağlanabilir|Tekli kalıtım|\n|Kullanım|“Ne yapılacağını” tanımlar|“Nasıl yapılacağını” kısmen tanımlar|\n\n---\n\n### 7) Java neden platform bağımsızdır?\n\nÇünkü derleme sonrası oluşan `.class` dosyası **bytecode** içerir.  \nBytecode’u çalıştıran **JVM (Java Virtual Machine)**, her platformda farklıdır ama bytecode sabittir.  \nBu nedenle “**Write Once, Run Anywhere**” prensibi geçerlidir.\n\n---\n\n### 8) Method Overloading nedir?\n\nAynı sınıfta aynı isimli ama **farklı parametre listelerine** sahip metotlar tanımlamaktır.  \nDerleme zamanında hangi versiyonun çağrılacağı **parametre tipi/sayısına göre** belirlenir.\n\n```java\nvoid add(int a, int b);\nvoid add(double a, double b);\n```\n\n---\n\n### 9) C++ ve Java farkları nelerdir?\n\n|Özellik|Java|C++|\n|---|---|---|\n|Platform|Bağımsız (JVM sayesinde)|Platforma bağımlı|\n|Pointer|Yok (güvenlik için)|Var|\n|Operator overloading|Desteklenmez|Desteklenir|\n|Garbage collection|Otomatik|Manuel|\n|Multithreading|Dahili destek var|Yok|\n|Global değişken|Yok|Var|\n\n---\n\n### 10) JIT Compiler nedir?\n\n**Just-In-Time Compiler**, JVM’in bir parçasıdır.  \nBytecode’u yürütülmeden hemen önce **makine koduna** çevirir.  \nYani program tamamen derlenmez; sadece **ihtiyaç duyulan kısımlar** çalıştırma anında derlenir → performansı artırır.\n\n---\n\n### 11) Bytecode nedir?\n\n`javac` derleyicisi bir `.java` dosyasını derlediğinde, ortaya `.class` uzantılı bir **bytecode** dosyası çıkar.  \nBu dosya, **makineye özel değil**, JVM’in anlayacağı bir **ara kod** (intermediate code)’dur.  \nYani bytecode = “Java’nın evrensel dili”.  \nJVM bu bytecode’u her platformda makine koduna çevirerek çalıştırır.\n\n---\n\n### 12) `this()` ve `super()` farkı nedir?\n\n- `this()` → **Aynı sınıf** içindeki başka bir constructor’ı çağırır.\n    \n- `super()` → **Üst sınıfın constructor’ını** çağırır.\n    \n\nHer ikisi de constructor’ın **ilk satırında** olmalıdır; aksi halde derleme hatası alınır.\n\n---\n\n### 13) Class (sınıf) nedir?\n\nSınıf, Java’daki **nesne yönelimli programlamanın temelidir**.  \nBir sınıf, bir nesnenin **özelliklerini (fields)** ve **davranışlarını (methods)** tanımlar.  \nBir tür “şablon” veya “plan” gibi düşün.\n\n```java\npublic class Araba {\n    String marka;\n    void calistir() { System.out.println(\"Motor çalıştı\"); }\n}\n```\n\n---\n\n### 14) Object (nesne) nedir?\n\nNesne, bir sınıfın **örneğidir (instance)**.  \nBellekte gerçek bir varlık oluşturur.  \nHer nesnenin **durumu (state)** ve **davranışı (behavior)** vardır.\n\n```java\nAraba a = new Araba(); // 'a' bir Araba nesnesi\na.calistir(); // Nesne davranışını çağırır\n```\n\n---\n\n### 15) Method nedir?\n\nBir metot, belirli bir işi yapan kod bloğudur.  \nSınıf içinde tanımlanır.  \nİsmi, dönüş tipi, parametre listesi ve gövdesi vardır.\n\n```java\nint topla(int a, int b) {\n    return a + b;\n}\n```\n\n---\n\n### 16) Encapsulation (kapsülleme) nedir?\n\nVeriyi (**fields**) ve bu veriyle ilgili işlemleri (**methods**) tek bir sınıfta toplamak, ve dışarıdan doğrudan erişimi **kontrol altına almak**.  \nYani “veriyi gizle, sadece kontrollü erişim sağla.”\n\n```java\nclass Ogrenci {\n    private String isim; // gizli veri\n    public void setIsim(String isim) { this.isim = isim; }\n    public String getIsim() { return isim; }\n}\n```\n\nBu yapı, hem **güvenliği artırır** hem de **bakımı kolaylaştırır**.\n\n---\n\n### 17) `main()` metodu neden `public static void` olarak tanımlanır?\n\n- `public` → JVM, sınıf dışından bu metodu çağırabilsin diye.\n    \n- `static` → JVM’in sınıfı başlatmak için **nesne oluşturmadan** çağırabilmesi için.\n    \n- `void` → `main()` metodu herhangi bir değer döndürmez.\n    \n\nYani JVM, `public static void main(String[] args)` imzasını **otomatik olarak arar**.\n\n---\n\n### 18) `main()` metodunun önemi nedir?\n\nJava uygulamasında **çalışma başlangıç noktasıdır**.  \nProgramın yürütmesi `main()` içinde başlar.  \nParametre olarak `String[] args` alır; bu, **komut satırından** gelen argümanları taşır.\n\n---\n\n### 19) Constructor (yapıcı metod) nedir?\n\nBir sınıftan nesne oluşturulduğunda **otomatik olarak çağrılan özel metot**tur.  \nNesnenin ilk değerlerini ayarlamak için kullanılır.  \nConstructor’ın ismi **sınıf adıyla aynı olmalıdır** ve dönüş tipi **olmaz**.\n\n```java\nclass Araba {\n    Araba() { System.out.println(\"Araba oluşturuldu\"); }\n}\n```\n\n- **Default constructor**: Parametresiz.\n    \n- **Parameterized constructor**: Parametre alır.\n    \n\n---\n\n### 20) `length` ve `length()` farkı nedir?\n\n- `length()` → **String** sınıfında bir metottur.  \n    Karakter sayısını döndürür.\n    \n    ```java\n    String s = \"Hello\";\n    s.length(); // 5\n    ```\n    \n- `length` → **Array (dizi)** için bir **özelliktir (field)**.  \n    Dizinin eleman sayısını verir.\n    \n    ```java\n    int[] sayilar = {1,2,3};\n    sayilar.length; // 3\n    ```\n    \n\n---\n\n### 21) ASCII kodu nedir?\n\n**ASCII (American Standard Code for Information Interchange)**, bilgisayarlarda karakterleri sayısal olarak temsil etmek için geliştirilmiş 7-bitlik bir karakter kümesidir.  \nKarakter aralığı: **0 – 255**  \nÖrnek:\n\n- `'A'` → 65\n    \n- `'a'` → 97\n    \n\nASCII sadece **İngilizce karakterleri** destekler. Türkçe, Çince gibi dillerdeki özel karakterleri kapsamaz.\n\n---\n\n### 22) Unicode nedir?\n\n**Unicode**, tüm dillerin karakterlerini kapsamak için geliştirilmiş evrensel bir karakter kodlamasıdır.  \nJava, tüm karakterleri **Unicode (UTF-16)** biçiminde temsil eder.  \nKarakter aralığı: **0 – 65,535 (2^16 - 1)**\n\nBu yüzden Java’da `'ç'`, `'ü'`, `'你'` gibi karakterler de rahatlıkla kullanılabilir.  \nÖrneğin:\n\n```java\nchar c = '\\u00E7'; // ç karakteri\n```\n\n---\n\n### 23) Character Constant ve String Constant farkı nedir?\n\n**Character Constant (karakter sabiti):**\n\n- Tek tırnak içinde tanımlanır: `'A'`, `'7'`, `'\\n'`\n    \n- Türü: `char`\n    \n- Tek bir karakteri temsil eder.\n    \n\n**String Constant (dizge sabiti):**\n\n- Çift tırnak içinde tanımlanır: `\"A\"`, `\"Hello\"`\n    \n- Türü: `String`\n    \n- Birden fazla karakteri (dizi) temsil eder.\n    \n\n---\n\n### 24) Constant (sabit) nedir, nasıl oluşturulur?\n\nSabitler, program boyunca **değeri değiştirilemeyen değişkenlerdir**.  \nJava’da sabitler `final` anahtar kelimesiyle tanımlanır.\n\n```java\nfinal int MAX_SPEED = 120;\nfinal String APP_NAME = \"MyApp\";\n```\n\nBir kez atanırlar, sonrasında değiştirilemezler.\n\n---\n\n### 25) `\u003e\u003e` ve `\u003e\u003e\u003e` operatörleri arasındaki fark nedir?\n\nHer ikisi de **bit kaydırma operatörüdür**, ama fark şudur:\n\n- `\u003e\u003e` → **Signed Right Shift**  \n    Negatif sayılarda sol taraftaki boşlukları **işaret bitiyle (1)** doldurur.  \n    Yani işaret korunur.\n    \n- `\u003e\u003e\u003e` → **Unsigned Right Shift**  \n    Sol taraftaki boşlukları **0** ile doldurur.  \n    Negatiflik bilgisi korunmaz.\n    \n\nÖrnek:\n\n```java\nint x = -8;\nSystem.out.println(x \u003e\u003e 2);   // -2\nSystem.out.println(x \u003e\u003e\u003e 2);  // 1073741822\n```\n\n---\n\n### 26) Java’da sınıflar için kodlama standartları nelerdir?\n\nOracle’ın önerdiği **Java Coding Conventions**’a göre:\n\n- Sınıf isimleri **büyük harfle** başlar.\n    \n- Her kelimenin ilk harfi büyük olmalıdır (PascalCase).\n    \n- İsimler genelde **isim (noun)** olmalıdır.\n    \n\nÖrnek:  \n`Employee`, `CarDetails`, `StringBuilder`\n\n---\n\n### 27) Interface’ler için kodlama standartları nelerdir?\n\n- Interface isimleri de **büyük harfle** başlar.\n    \n- Genellikle **sıfat (adjective)** veya **yetenek belirtici** isimlerdir.\n    \n\nÖrnek:  \n`Runnable`, `Serializable`, `Cloneable`, `Comparable`\n\n---\n\n### 28) Metotlar için kodlama standartları nelerdir?\n\n- Küçük harfle başlar.\n    \n- İçinde birden fazla kelime varsa, ikinci kelimeden itibaren büyük harf kullanılır (**camelCase**).\n    \n- Genellikle **fiil (verb)** ile başlar.\n    \n\nÖrnek:  \n`getName()`, `calculateSalary()`, `toString()`\n\n---\n\n### 29) Değişkenler için kodlama standartları nelerdir?\n\n- Küçük harfle başlar.\n    \n- Anlamlı, kısa ve okunabilir olmalıdır.\n    \n- Birden fazla kelimeli isimlerde camelCase kullanılır.\n    \n\nÖrnek:  \n`count`, `totalAmount`, `employeeName`\n\n---\n\n### 30) Sabitler (constants) için kodlama standartları nelerdir?\n\n- Genellikle `public static final` olarak tanımlanır.\n    \n- Tüm harfler **büyük** yazılır.\n    \n- Kelimeler **alt çizgi (`_`)** ile ayrılır.\n    \n\nÖrnek:  \n`MAX_VALUE`, `PI`, `DEFAULT_PORT`\n\n---\n\n### 31) Overriding ve Overloading farkı nedir?\n\n|Özellik|**Overriding**|**Overloading**|\n|---|---|---|\n|Tanım|Üst sınıfta tanımlı bir metodu, alt sınıfta **aynı imzayla yeniden tanımlamak**|Aynı isimli metodu **farklı parametrelerle** tanımlamak|\n|İlişki|İki sınıf (inheritance ilişkisi) arasında olur|Aynı sınıf içinde olur|\n|Dönüş tipi|Aynı olmalı veya **covariant** olabilir|Farklı olabilir|\n|Polimorfizm tipi|**Runtime (dinamik)**|**Compile-time (statik)**|\n|Exception kuralları|Checked exception seviyesi artırılamaz|Herhangi bir exception atanabilir|\n|Erişim|Üst sınıftakinden daha kısıtlı olamaz|Fark etmez|\n\nKısaca:  \n**Overriding** davranışı değiştirir,  \n**Overloading** aynı davranışı farklı girdilerle genişletir.\n\n---\n\n### 32) “IS-A” ilişkisi nedir?\n\n“IS-A” ilişkisi, **inheritance (kalıtım)** demektir.  \nBir sınıf, başka bir sınıfın alt türü ise, “X is a Y” şeklinde ifade edilir.\n\nÖrnek:\n\n```java\nclass Vehicle {}\nclass Car extends Vehicle {}\n```\n\nBurada **Car IS-A Vehicle** — yani “Araba bir Taşıttır”.  \nAvantajı: Kodun **yeniden kullanılabilirliği (reusability)** artar.\n\n---\n\n### 33) “HAS-A” ilişkisi nedir?\n\n“HAS-A” ilişkisi, **composition (bileşim)** veya **aggregation (ilişki)** demektir.  \nBir sınıf, başka bir sınıfı **üye değişken olarak içeriyorsa**, bu ilişki vardır.\n\nÖrnek:\n\n```java\nclass Engine {}\nclass Car {\n    Engine engine = new Engine(); // Car HAS-A Engine\n}\n```\n\nBurada “Araba bir motora sahiptir” deriz.  \nAvantajı yine kodun **yeniden kullanılabilirliğidir**, ama miras yerine **iç içe nesneler** kullanılır.\n\n---\n\n### 34) IS-A ve HAS-A farkı nedir?\n\n|Özellik|IS-A|HAS-A|\n|---|---|---|\n|Tür|Kalıtım (extends)|Kompozisyon / Agregasyon|\n|Anahtar kelime|`extends`|`new` (veya dependency injection)|\n|Örnek|`Car extends Vehicle`|`Car has an Engine`|\n|Odak|“Bir türüdür”|“Bir parçasıdır”|\n|Avantaj|Kodun yeniden kullanımı (davranış mirası)|Esneklik, bileşen tabanlı yapı|\n\n---\n\n### 35) `instanceof` operatörü nedir?\n\nBir nesnenin hangi sınıfa ait olduğunu kontrol eder.  \nSonuç **boolean** döner.  \nSözdizimi:\n\n```java\nobj instanceof ClassName\n```\n\nÖrnek:\n\n```java\nString s = \"Hello\";\nSystem.out.println(s instanceof String); // true\n```\n\nEğer referans `null` ise sonuç her zaman `false` döner.  \nDerleme zamanında tip kontrolü yapılır, yanlış türler hata verir.\n\n---\n\n### 36) `null` ne anlama gelir?\n\nBir referansın **hiçbir nesneyi göstermediğini** ifade eder.  \nYani “boş” değil, “hiç yok”.\n\n```java\nString name = null;\nSystem.out.println(name.length()); // NullPointerException\n```\n\n`null`, yalnızca **referans türleri** için geçerlidir (primitive’ler için değil).\n\n---\n\n### 37) Bir dosyada birden fazla sınıf olabilir mi?\n\nEvet, bir `.java` dosyasında **birden fazla sınıf** tanımlanabilir, ama:\n\n- Yalnızca **bir tanesi public** olabilir.\n    \n- Public sınıfın adı **dosya adıyla aynı** olmalıdır.\n    \n\n```java\nclass A {}\nclass B {}\npublic class Main {} // Dosya adı: Main.java\n```\n\n---\n\n### 38) Üst seviye (top-level) sınıflar için hangi access modifier’lar kullanılabilir?\n\nSadece iki tanesi geçerlidir:\n\n- **public** → Her yerden erişilebilir.\n    \n- **default (hiçbiri yazılmaz)** → Sadece **aynı paket** içinden erişilir.\n    \n\n`private` veya `protected` olarak tanımlarsan derleme hatası alırsın.  \nHata: _“Illegal modifier for the class”_\n\n---\n\n### 39) Package (paket) nedir?\n\n**Paket**, ilişkili sınıf, interface ve enum’ları bir araya getiren **mantıksal grup** yapısıdır.  \nKodun düzenli ve modüler olmasını sağlar.\n\nSözdizimi:\n\n```java\npackage com.company.project;\n```\n\nAmaçlar:\n\n1. İsim çakışmalarını önlemek (namespace kontrolü)\n    \n2. Erişim kontrolü (visibility)\n    \n3. Kodun organize edilmesi\n    \n\n---\n\n### 40) Bir dosyada birden fazla `package` tanımlanabilir mi?\n\nHayır.  \nBir `.java` dosyasında **sadece bir tane package bildirimi** bulunabilir.  \nBu ifade her zaman **ilk satırda** olmalıdır.  \nAksi takdirde derleyici hata verir.\n\n---\n\n### 41) `package` ifadesi `import` ifadesinden sonra tanımlanabilir mi?\n\nHayır.  \n`package` bildirimi bir `.java` dosyasının **ilk satırında** olmalıdır.  \nYalnızca **yorum satırları** ondan önce gelebilir.  \n`import` ifadesi her zaman **`package`’den sonra** gelir.\n\nÖrnek:\n\n```java\n// doğru\npackage com.example;\nimport java.util.List;\n```\n\nAksi halde derleyici hatası alınır:\n\n\u003e “Package declaration must be the first statement in the source file.”\n\n---\n\n### 42) Java’da identifier (tanımlayıcı) nedir?\n\nBir değişkenin, metodun, sınıfın veya paketin adıdır.  \nKısaca — kod içindeki “isimler”dir.\n\nKurallar:\n\n- Harf, `_` veya `$` ile başlayabilir.\n    \n- Sayı ile **başlayamaz**.\n    \n- Büyük/küçük harf duyarlıdır. (`Name` ≠ `name`)\n    \n- Java anahtar kelimeleri (`class`, `public` vb.) kullanılamaz.\n    \n\nÖrnekler:  \n✅ `userName`, `_temp`, `$data`  \n❌ `2value`, `public`, `#age`\n\n---\n\n### 43) Access modifier (erişim belirleyici) nedir?\n\nJava’da erişim belirleyiciler (access modifiers), **sınıf, metot ve değişkenlerin** görünürlüğünü belirler.\n\nDört tür vardır:\n\n- `public` → Her yerden erişilebilir.\n    \n- `private` → Sadece aynı sınıf içinden erişilebilir.\n    \n- `protected` → Aynı paket içinden ve alt sınıflardan erişilebilir.\n    \n- (hiçbiri yazılmazsa) → **default erişim**: sadece aynı paket içinden erişilebilir.\n    \n\nBu yapı Java’nın **encapsulation (kapsülleme)** modelini sağlar.\n\n---\n\n### 44) Access specifier ile access modifier farkı nedir?\n\nC++’ta bunlar ayrı kavramlardır, fakat Java’da **ayrım yoktur**.  \nJava’da “access modifier” terimi hem erişim seviyesini hem de bazı davranışsal nitelikleri kapsar.\n\n- **Access modifiers:** `public`, `private`, `protected`, _(default)_\n    \n- **Non-access modifiers:** `final`, `abstract`, `static`, `strictfp` vb.\n    \n\n---\n\n### 45) Sınıflarda hangi access modifier’lar kullanılabilir?\n\nYalnızca iki tanesi geçerlidir:\n\n1. `public` → Her yerden erişilebilir.\n    \n2. (hiçbiri yazılmaz) → **default**, sadece aynı paket içinden erişilebilir.\n    \n\nSınıflar için `private` veya `protected` **kullanılamaz.**\n\n---\n\n### 46) Metotlar için hangi access modifier’lar kullanılabilir?\n\nTümü (`public`, `private`, `protected`, `default`) kullanılabilir.\n\n- `public` → Her yerden erişim.\n    \n- `protected` → Aynı paket veya alt sınıf erişimi.\n    \n- `default` → Aynı paket içinden erişim.\n    \n- `private` → Sadece tanımlandığı sınıf içinden erişim.\n    \n\nBu kurallar, miras (inheritance) sırasında erişilebilirliği belirler.\n\n---\n\n### 47) Değişkenler için hangi access modifier’lar kullanılabilir?\n\nYine dört erişim seviyesi mümkündür (`public`, `private`, `protected`, `default`).\n\n- **public:** Her yerden erişilebilir.\n    \n- **protected:** Aynı paket + alt sınıflar.\n    \n- **default:** Aynı paket.\n    \n- **private:** Sadece aynı sınıf.\n    \n\nDeğişkenlerde `private` en çok tercih edilen düzeydir, çünkü veriyi dışarıdan korur.\n\n---\n\n### 48) `final` access modifier nedir?\n\n`final`, “değiştirilemez” anlamındadır. Üç yerde kullanılabilir:\n\n1. **final class** → Kalıtılamaz (örneğin `String` sınıfı).\n    \n2. **final method** → Override edilemez.\n    \n3. **final variable** → Değeri değiştirilemez (sabit olur).\n    \n\nÖrnek:\n\n```java\nfinal int MAX_SPEED = 180;\nfinal void start() {}\nfinal class Vehicle {}\n```\n\nAvantaj: Güvenlik  \nDezavantaj: Esneklik azalır (polimorfizm kısıtlanır).\n\n---\n\n### 49) `abstract` class nedir?\n\nBazı metotların gövdesi olmadan tanımlandığı, **soyut** bir sınıftır.  \nAmaç: Alt sınıfların kendi implementasyonlarını zorunlu kılmaktır.\n\nÖzellikleri:\n\n- **Abstract metot** içerebilir.\n    \n- **Concrete (normal)** metotlar da içerebilir.\n    \n- **Nesnesi oluşturulamaz**.\n    \n- Alt sınıflar, abstract metotları **override etmek zorundadır.**\n    \n\nÖrnek:\n\n```java\nabstract class Vehicle {\n    abstract void start();\n    void stop() { System.out.println(\"Stop\"); }\n}\n```\n\n---\n\n### 50) `abstract` sınıfta constructor tanımlanabilir mi?\n\nEvet, tanımlanabilir.  \nAncak doğrudan **nesne oluşturulamadığı** için constructor sadece **alt sınıflar tarafından çağrılabilir.**\n\n```java\nabstract class Animal {\n    Animal() { System.out.println(\"Animal constructor\"); }\n}\n\nclass Dog extends Animal {\n    Dog() { super(); }\n}\n```\n\nYani, abstract sınıfın constructor’ı **kalıtım sırasında** çalışır ama **doğrudan** çağrılamaz.\n\n---\n\n### 51) Abstract method (soyut metot) nedir?\n\n**Abstract method**, yalnızca bildirimi olan ama **gövdesi (body)** bulunmayan metottur.  \nBu metodun **gerçek davranışı**, alt sınıfta tanımlanmak zorundadır.\n\nSözdizimi:\n\n```java\npublic abstract void draw();\n```\n\nÖzellikler:\n\n- Sadece **abstract class** veya **interface** içinde tanımlanabilir.\n    \n- Gövdesiz olduğu için **`;`** ile biter.\n    \n- Abstract sınıflar içinde **0 veya daha fazla** abstract metot bulunabilir.\n    \n\nAmaç: Alt sınıfları **belirli davranışları zorunlu kılmaya** yönlendirmek.\n\n---\n\n### 52) Java’da exception (istisna) nedir?\n\nBir program çalışırken **beklenmedik bir durum oluştuğunda** JVM tarafından atılan veya programcı tarafından fırlatılan **nesnedir**.  \nTüm exception sınıfları `java.lang.Exception` sınıfından türemiştir.\n\nÖrnek durumlar:\n\n- 0’a bölme → `ArithmeticException`\n    \n- Dizi sınırı aşımı → `ArrayIndexOutOfBoundsException`\n    \n- Dosya bulunamadı → `FileNotFoundException`\n    \n\nKısaca: Exception = “Çalışma zamanında meydana gelen anormal durum”.\n\n---\n\n### 53) Exception hangi durumlarda oluşabilir?\n\nBazı tipik örnekler:\n\n1. Dizi elemanına geçersiz indeksle erişim\n    \n2. String → int dönüşüm hatası (`NumberFormatException`)\n    \n3. Geçersiz tür dönüşümü (`ClassCastException`)\n    \n4. Interface veya abstract class’tan nesne oluşturmaya çalışma (`InstantiationException`)\n    \n\n---\n\n### 54) Exception handling nedir?\n\nBir hata meydana geldiğinde programın **durmaması**, bunun yerine uygun biçimde yönetilmesidir.  \nAmaç: Programın **normal akışını korumak.**\n\n`try-catch-finally` yapısı ile yapılır.\n\n```java\ntry {\n    int x = 10 / 0;\n} catch (ArithmeticException e) {\n    System.out.println(\"Sıfıra bölünemez!\");\n} finally {\n    System.out.println(\"Temizlik yapıldı.\");\n}\n```\n\n---\n\n### 55) Java’da “error” nedir?\n\n**Error**, `Throwable` sınıfının `Exception` dışındaki alt sınıfıdır.  \nProgramcı tarafından **yakalanması amaçlanmaz**, çünkü sistem seviyesidir.\n\nÖrnek:\n\n- `OutOfMemoryError`\n    \n- `StackOverflowError`\n    \n\nKısaca:\n\n- **Exception** → Program hatası (yönetilebilir)\n    \n- **Error** → Sistem hatası (kritik, toparlanamaz)\n    \n\n---\n\n### 56) Exception handling’in avantajları nelerdir?\n\n1. Hataları kodun geri kalanından **ayırır**, temiz kontrol sağlar.\n    \n2. Farklı türde hataları ayrı ayrı ele alabilmeyi sağlar.\n    \n3. Hataların **çağrı zinciri boyunca aktarılmasına (propagation)** izin verir.\n    \n4. Programın **çökmek yerine kontrollü devam etmesini** sağlar.\n    \n\n---\n\n### 57) Java’da exception handling kaç şekilde yapılabilir?\n\nİki temel yöntem vardır:\n\n1. **try-catch-finally** kullanmak  \n    → Exception’ı orada yakalayıp işlem yapmak.\n    \n2. **throws** anahtar kelimesiyle atmak  \n    → Exception’ı bir üst metoda fırlatmak (sorumluluğu devretmek).\n    \n\n---\n\n### 58) Exception handling ile ilgili beş anahtar kelime nedir?\n\nJava’nın exception mekanizması beş temel keyword’e dayanır:\n\n- `try` → Riskli kod bloğu\n    \n- `catch` → Hata yakalama bloğu\n    \n- `throw` → Manuel exception fırlatma\n    \n- `throws` → Exception’ı üst metoda devretme\n    \n- `finally` → Her durumda çalışan temizlik bloğu\n    \n\n---\n\n### 59) `try` ve `catch` blokları nasıl çalışır?\n\n`try` bloğunda hataya yol açabilecek kodlar yer alır.  \nEğer hata oluşursa, JVM uygun `catch` bloğuna yönlendirir.\n\nÖrnek:\n\n```java\ntry {\n    int[] arr = {1, 2};\n    System.out.println(arr[3]);\n} catch (ArrayIndexOutOfBoundsException e) {\n    System.out.println(\"Dizi sınırı aşıldı!\");\n}\n```\n\n- Eğer exception oluşmazsa `catch` atlanır.\n    \n- Eğer oluşursa `catch` bloğu çalışır ve program devam eder.\n    \n\n---\n\n### 60) `try` bloğu `catch` olmadan kullanılabilir mi?\n\nEvet, ama **yalnızca `finally`** varsa.  \nYani `try` bloğu tek başına olamaz, en az bir **catch** veya **finally** içermelidir.\n\nGeçerli:\n\n```java\ntry {\n    System.out.println(\"Deneme\");\n} finally {\n    System.out.println(\"Her durumda çalışır\");\n}\n```\n\nGeçersiz:\n\n```java\ntry {\n    System.out.println(\"Olmaz\");\n}\n// Derleme hatası: “try without catch or finally”\n```\n\n---\n\n### 61) Tek bir `try` bloğu için birden fazla `catch` bloğu olabilir mi?\n\nEvet.  \nBir `try` bloğu, farklı türdeki hataları **farklı `catch` bloklarında** yakalayabilir.  \nJava, hatanın türüne göre **uygun olan ilk `catch` bloğunu** çalıştırır.\n\n```java\ntry {\n    int[] arr = new int[2];\n    arr[3] = 10;\n} catch (ArrayIndexOutOfBoundsException e) {\n    System.out.println(\"Dizi sınırı aşıldı\");\n} catch (Exception e) {\n    System.out.println(\"Genel hata\");\n}\n```\n\n**Dikkat:**  \n`catch` blokları **alt sınıftan üst sınıfa doğru** sıralanmalıdır.  \nAksi halde derleme hatası olur (“Exception has already been caught”).\n\n---\n\n### 62) `finally` bloğunun önemi nedir?\n\n`finally` bloğu, **istisna oluşsa da oluşmasa da** her zaman çalışır.  \nGenellikle şu işler için kullanılır:\n\n- Kaynakların kapatılması (`close()` çağrıları)\n    \n- Bağlantıların serbest bırakılması (dosya, socket, DB)\n    \n- Temizlik işlemleri\n    \n\n```java\ntry {\n    System.out.println(10 / 0);\n} catch (Exception e) {\n    System.out.println(\"Hata!\");\n} finally {\n    System.out.println(\"Finally her zaman çalışır.\");\n}\n```\n\n---\n\n### 63) `try` ve `catch` blokları arasında kod yazılabilir mi?\n\nHayır, yazılamaz.  \n`catch` bloğu **hemen `try` bloğunun ardından** gelmelidir.  \nAksi halde derleyici hata verir.\n\nGeçersiz örnek:\n\n```java\ntry {\n    System.out.println(\"Deneme\");\n}\nSystem.out.println(\"Bu satır hata verir\");\ncatch (Exception e) {\n    System.out.println(\"Hata!\");\n}\n```\n\n---\n\n### 64) `try` ve `finally` blokları arasında kod yazılabilir mi?\n\nHayır, yazılamaz.  \n`finally` bloğu da `try` (veya `catch`) bloğundan **hemen sonra** gelmelidir.\n\nGeçerli:\n\n```java\ntry {\n    System.out.println(\"İşlem\");\n} finally {\n    System.out.println(\"Temizlik\");\n}\n```\n\nGeçersiz:\n\n```java\ntry {\n    System.out.println(\"İşlem\");\n}\nSystem.out.println(\"Araya kod yazmak yasak\"); // Hata!\nfinally {\n    System.out.println(\"Temizlik\");\n}\n```\n\n---\n\n### 65) Tek bir `catch` bloğunda birden fazla exception yakalanabilir mi?\n\nEvet, **Java 7** ile birlikte bu özellik geldi.  \nAynı işlemle yönetilecek birden fazla istisna türünü tek bir `catch`’te birleştirebilirsin.\n\n```java\ntry {\n    int x = Integer.parseInt(\"abc\");\n} catch (NumberFormatException | NullPointerException e) {\n    System.out.println(\"Birden fazla hata türü yakalandı.\");\n}\n```\n\nNot:\n\n- `catch` parametresi **otomatik olarak `final`** olur; yeniden atanamaz.\n    \n\n---\n\n### 66) Checked exception nedir?\n\n**Derleme zamanında kontrol edilen** istisnalardır.  \nProgramcı, bu tür istisnaları **ya yakalamak (`try-catch`)** ya da **fırlatmak (`throws`)** zorundadır.\n\nÖrnekler:\n\n- `IOException`\n    \n- `SQLException`\n    \n- `FileNotFoundException`\n    \n- `ClassNotFoundException`\n    \n\nEğer bu tür bir istisna yakalanmaz veya `throws` edilmezse → **compile-time error** oluşur.\n\n---\n\n### 67) Unchecked exception nedir?\n\n**Derleme zamanında kontrol edilmeyen**, sadece çalışma zamanında ortaya çıkan istisnalardır.  \nBunlar `RuntimeException` sınıfından türeyen hatalardır.\n\nÖrnekler:\n\n- `NullPointerException`\n    \n- `ArrayIndexOutOfBoundsException`\n    \n- `ArithmeticException`\n    \n- `NumberFormatException`\n    \n\nBu tür istisnaları yakalamak **zorunlu değildir** — ama yakalamak programın sağlamlığını artırır.\n\n---\n\n### 68) Checked ve Unchecked exception farkı nedir?\n\n|Özellik|Checked|Unchecked|\n|---|---|---|\n|Kontrol zamanı|Derleme zamanında|Çalışma zamanında|\n|Zorunlu yakalama|Evet (`try-catch` veya `throws`)|Hayır|\n|Sınıf kökeni|`Exception` (ama `RuntimeException` hariç)|`RuntimeException` ve alt sınıfları|\n|Örnekler|`IOException`, `SQLException`|`NullPointerException`, `ArithmeticException`|\n\n---\n\n### 69) Default exception handling nedir?\n\nBir istisna yakalanmadığında **JVM’in kendisinin devreye girip** olayı yönetmesidir.  \nJVM şunları yapar:\n\n1. İstisna nesnesini oluşturur.\n    \n2. Türünü, açıklamasını ve oluştuğu satırı yazar.\n    \n3. Stack trace’i ekrana basar.\n    \n4. Programı **sonlandırır**.\n    \n\nDezavantaj:  \nProgram **ani şekilde durur**, bu yüzden kendi `try-catch` mekanizmamızı kurmamız önerilir.\n\n---\n\n### 70) `throw` anahtar kelimesi nedir?\n\nKendin manuel olarak bir exception **fırlatmak** için kullanılır.  \nYani JVM’in otomatik fırlatmasına gerek kalmadan, sen kendi istisnanı oluşturabilirsin.\n\nSözdizimi:\n\n```java\nthrow new Exception(\"Kullanıcı tanımlı hata\");\n```\n\nKurallar:\n\n- Sadece **bir exception nesnesi** fırlatılabilir.\n    \n- `throw` kullanıldıktan sonra, o satırdan sonraki kod **çalışmaz**.\n    \n- Eğer `checked exception` fırlatıyorsan, metot imzasına `throws` eklenmelidir.\n    \n\n---\n\n### 71) `throw` ifadesinden sonra kod yazılabilir mi?\n\nHayır, yazılamaz.\n\nBir `throw` ifadesi çalıştığında, JVM akışı **hemen sonlandırır** ve exception fırlatılır.  \nSonraki hiçbir satır yürütülmez.\n\nÖrnek:\n\n```java\nthrow new ArithmeticException(\"Hata!\");\nSystem.out.println(\"Bu satır asla çalışmaz.\"); // Derleme hatası: unreachable code\n```\n\nDerleyici bunu fark eder ve “unreachable code” hatası verir.\n\n---\n\n### 72) `throws` anahtar kelimesinin önemi nedir?\n\n`throws`, bir metodun **hangi istisnaları fırlatabileceğini** belirtir.  \nYani: “Ben bu hatayı burada yakalamıyorum, çağıran kod ilgilensin” demektir.\n\nSözdizimi:\n\n```java\nvoid okuDosya() throws IOException {\n    FileReader f = new FileReader(\"data.txt\");\n}\n```\n\nKullanım amacı:\n\n- Checked exception’ları üst metoda devretmek.\n    \n- Metodun exception politikalarını açıkça belirtmek.\n    \n\n`throws` yalnızca **`Throwable` türünden** sınıflarla kullanılabilir (`Exception`, `Error` veya alt sınıfları).\n\n---\n\n### 73) `finally` ve `return` çatışırsa ne olur?\n\n`finally` **her zaman çalışır**, `return` ifadesinden bile önce.  \nYani hem `try` hem `catch` içinde `return` olsa bile, JVM önce `finally` bloğunu yürütür.\n\nÖrnek:\n\n```java\nint test() {\n    try {\n        return 1;\n    } finally {\n        System.out.println(\"Finally çalıştı\");\n    }\n}\n```\n\nKonsol çıktısı:\n\n```\nFinally çalıştı\n```\n\nVe metot `1` döner.  \nYani `finally`, `return`’dan **önceliklidir.**\n\n---\n\n### 74) `finally` bloğunun çalışmayacağı bir durum var mı?\n\nEvet, yalnızca JVM kapatılırsa.  \nÖrneğin `System.exit(0)` çağrıldığında, JVM tamamen kapanır ve `finally` **çalışmaz.**\n\n```java\ntry {\n    System.exit(0);\n} finally {\n    System.out.println(\"Bu yazı asla görünmez!\");\n}\n```\n\nNormal durumlarda (exception oluşsa bile) `finally` bloğu her zaman yürür.\n\n---\n\n### 75) Checked exception’lar için `catch` bloğu kullanılabilir mi?\n\nEvet, ama yalnızca o exception’ın **oluşma ihtimali** varsa.  \nEğer bir checked exception’ın oluşma olasılığı **yoksa**, onu `catch`’le yakalamaya çalışmak **derleme hatası** verir.\n\nÖrnek:\n\n```java\ntry {\n    int x = 10 / 2;\n} catch (IOException e) { } // HATA: IOException asla oluşmaz\n```\n\n---\n\n### 76) User-defined (kullanıcı tanımlı) exception nedir?\n\nJava’da kendi özel hata türlerini oluşturabilirsin.  \nBu, genellikle **iş mantığına özgü hataları** belirtmek için yapılır.\n\nBir user-defined exception oluşturmak için:\n\n1. `Exception` (checked) veya `RuntimeException` (unchecked) sınıfını genişlet.\n    \n2. İsteğe bağlı olarak constructor tanımla.\n    \n\nÖrnek:\n\n```java\nclass AgeException extends Exception {\n    AgeException(String msg) {\n        super(msg);\n    }\n}\n```\n\nKullanım:\n\n```java\nif (age \u003c 18) {\n    throw new AgeException(\"Yaş 18'den küçük olamaz!\");\n}\n```\n\nTavsiyem:  \nKritik olmayan durumlarda `RuntimeException`’dan türetmek daha uygundur.\n\n---\n\n### 77) Bir `catch` bloğunda yakalanan exception yeniden fırlatılabilir mi?\n\nEvet.  \n`catch` içinde yakalanan istisna, aynı ya da farklı türde bir istisna olarak yeniden `throw` edilebilir.  \nBu işleme **rethrowing** denir.\n\n```java\ntry {\n    int x = 10 / 0;\n} catch (ArithmeticException e) {\n    throw e; // aynı istisnayı yeniden fırlat\n}\n```\n\nEğer checked exception yeniden fırlatılıyorsa, metot imzasına `throws` eklenmelidir.\n\n---\n\n### 78) Nested (iç içe) `try` blokları kullanılabilir mi?\n\nEvet, `try` blokları **birbirinin içinde** tanımlanabilir.  \nBu, farklı hata seviyelerini yönetmek için kullanılır.\n\n```java\ntry {\n    try {\n        int x = 10 / 0;\n    } catch (ArithmeticException e) {\n        System.out.println(\"İç try-catch\");\n    }\n} catch (Exception e) {\n    System.out.println(\"Dış try-catch\");\n}\n```\n\nİçteki `catch` exception’ı yakalayamazsa, dış `catch` devreye girer.  \nYani exception’lar **katmanlı olarak yukarı doğru** taşınır (propagation).\n\n---\n\n### 79) `Throwable` sınıfının önemi nedir?\n\n`Throwable`, Java’daki **tüm hataların (Error ve Exception)** üst sınıfıdır.  \nYani her istisna türü (`IOException`, `RuntimeException`, `OutOfMemoryError` vb.) bundan türetilir.\n\nÖnemli metotlar:\n\n- `printStackTrace()` → hatanın türü, mesajı ve oluştuğu satırları yazdırır.\n    \n- `getMessage()` → sadece hata mesajını döndürür.\n    \n- `toString()` → hata türü + mesaj döndürür.\n    \n\nKısaca: Exception hiyerarşisinin köküdür.\n\n---\n\n### 80) `ClassNotFoundException` ne zaman oluşur?\n\nBu exception, JVM bir sınıfı **adıyla yüklemeye çalıştığında** ama o sınıf **bulunamadığında** fırlatılır.  \nGenellikle `Class.forName(\"com.example.MyClass\")` gibi refleksiyon işlemlerinde görülür.\n\nÖrnek:\n\n```java\ntry {\n    Class.forName(\"com.fake.Class\");\n} catch (ClassNotFoundException e) {\n    System.out.println(\"Sınıf bulunamadı!\");\n}\n```\n\nBu, checked exception’dır — yani `try-catch` veya `throws` zorunludur.\n\n---\n\n### 81) Process (süreç) ve Thread (iş parçacığı) arasındaki fark nedir?\n\n**Process (süreç):**\n\n- Kendi **bellek alanına** sahiptir.\n    \n- Her process birbirinden bağımsızdır.\n    \n- Process’ler arası iletişim zordur (IPC gerekir).\n    \n- Örneğin: Her açtığın Java programı ayrı bir process’tir.\n    \n\n**Thread (iş parçacığı):**\n\n- Aynı process içinde **bellek paylaşır**.\n    \n- Daha hafif ve hızlıdır.\n    \n- Aynı anda birden fazla işi yapabilir.\n    \n\nBir process içinde birden fazla thread çalışabilir — bunlara **çoklu iş parçacığı** denir.\n\n---\n\n### 82) Thread nedir?\n\nThread, programın içinde **bağımsız yürüyen küçük bir alt akıştır**.  \nHer Java uygulaması en az bir thread ile başlar: **main thread**.\n\nMultithreading sayesinde:\n\n- CPU zamanı daha verimli kullanılır.\n    \n- Aynı anda birden fazla işlem yapılabilir.\n    \n\nJava, thread desteğini `java.lang.Thread` sınıfı ve `Runnable` arabirimi üzerinden sağlar.\n\n---\n\n### 83) Thread nasıl oluşturulur?\n\nJava’da iki yöntem vardır:\n\n1. **Thread sınıfını genişleterek:**\n    \n    ```java\n    class MyThread extends Thread {\n        public void run() {\n            System.out.println(\"Thread çalışıyor\");\n        }\n    }\n    \n    new MyThread().start();\n    ```\n    \n2. **Runnable arayüzünü implemente ederek:**\n    \n    ```java\n    class MyRunnable implements Runnable {\n        public void run() {\n            System.out.println(\"Runnable çalışıyor\");\n        }\n    }\n    \n    new Thread(new MyRunnable()).start();\n    ```\n    \n\nİkinci yöntem tercih edilir, çünkü **çoklu miras (multiple inheritance)** sorununu önler.\n\n---\n\n### 84) Thread nasıl başlatılır?\n\nBir thread’i başlatmak için `start()` metodu kullanılır.  \nBu metot JVM’e yeni bir yürütme hattı oluşturmasını söyler.\n\n```java\nMyThread t = new MyThread();\nt.start(); // yeni thread başlar\n```\n\n**Dikkat:**  \n`run()` metodunu doğrudan çağırmak yeni thread oluşturmaz — sadece normal bir metod çağrısı olur.\n\n---\n\n### 85) `start()` ve `run()` farkı nedir?\n\n|Özellik|`start()`|`run()`|\n|---|---|---|\n|Amacı|Yeni thread başlatır|Thread’in çalıştırılacak kodunu tanımlar|\n|Çağıran|JVM|Kullanıcı|\n|Thread oluşur mu?|Evet|Hayır|\n|Davranış|Paralel çalışır|Aynı thread’de çalışır|\n\nYani:\n\n```java\nt.start(); // Yeni thread\nt.run();   // Aynı thread (main)\n```\n\n---\n\n### 86) Thread yaşam döngüsü (lifecycle) nasıldır?\n\nBir thread şu beş temel durumda bulunabilir:\n\n1. **New (Yeni)** → Henüz başlatılmadı (`new Thread()` oluşturuldu).\n    \n2. **Runnable** → `start()` çağrıldı, çalışmaya hazır.\n    \n3. **Running** → CPU tarafından yürütülüyor.\n    \n4. **Blocked / Waiting** → Uyku veya kilit bekliyor.\n    \n5. **Terminated (Ölü)** → `run()` tamamlandı.\n    \n\nBasit görsel:\n\n```\nNew → Runnable → Running → (Waiting/Blocked) → Terminated\n```\n\n---\n\n### 87) `sleep()` metodu nedir?\n\nBir thread’in yürütmesini belirli süre **askıya alır (bekletir)**.  \nSözdizimi:\n\n```java\nThread.sleep(1000); // 1 saniye bekle\n```\n\n- Parametre: milisaniye (1000 = 1 saniye)\n    \n- Checked exception: `InterruptedException` atabilir, bu yüzden `try-catch` gerekir.\n    \n- Uyuyan thread, zamanı dolunca **Runnable** durumuna döner.\n    \n\n---\n\n### 88) `yield()` metodu nedir?\n\n`yield()`, bir thread’in geçici olarak CPU kullanım hakkını **diğer thread’lere bırakmasını** sağlar.\n\n```java\nThread.yield();\n```\n\nAma bu **sadece bir öneridir**, JVM bunu dikkate alıp almayacağına kendisi karar verir.  \nYani deterministik değildir — sistemin planlayıcısına (scheduler) bağlıdır.\n\n---\n\n### 89) `join()` metodu nedir?\n\nBir thread’in, başka bir thread’in bitmesini **beklemesini** sağlar.\n\nÖrnek:\n\n```java\nThread t = new Thread(() -\u003e System.out.println(\"İşlem...\"));\nt.start();\nt.join(); // t bitmeden sonraki kod çalışmaz\nSystem.out.println(\"Bitti!\");\n```\n\nBu, thread’ler arasında **senkronizasyon (sıra bekleme)** sağlar.  \nChecked exception olarak `InterruptedException` fırlatabilir.\n\n---\n\n### 90) `isAlive()` metodu nedir?\n\nBir thread’in hâlâ çalışıp çalışmadığını kontrol eder.  \nSonuç **true** veya **false** döner.\n\n```java\nThread t = new Thread(() -\u003e {});\nt.start();\nSystem.out.println(t.isAlive()); // true (hala çalışıyor olabilir)\n```\n\nThread tamamlandığında (`run()` bittiğinde) `isAlive()` artık `false` döner.\n\n---\n\n### 91) `synchronized` anahtar kelimesi nedir?\n\n`synchronized`, birden fazla thread’in **aynı anda aynı kaynağa erişmesini engelleyen** kilitleme (locking) mekanizmasıdır.\n\nBir metot ya da kod bloğu `synchronized` olarak tanımlanırsa, o bölgeye aynı anda sadece **bir thread** girebilir.\n\n```java\nsynchronized void print() {\n    System.out.println(\"Tek thread girebilir\");\n}\n```\n\nAmaç: **race condition (yarış durumu)** denilen hatalı eşzamanlı erişimi önlemek.\n\n---\n\n### 92) `synchronized` nerelerde kullanılabilir?\n\nÜç yerde kullanılabilir:\n\n1. **Instance method** — o nesne için kilit oluşturur.\n    \n2. **Static method** — sınıf düzeyinde kilit oluşturur (class-level lock).\n    \n3. **Code block** — yalnızca belirli bir nesneye kilit uygular.\n    \n\n```java\nsynchronized (this) {\n    // synchronized block\n}\n```\n\nBu, kilit kapsamını sınırlayarak **performans artırmak** için kullanılır.\n\n---\n\n### 93) Thread senkronizasyonuna neden ihtiyaç duyarız?\n\nÇünkü aynı anda birden fazla thread aynı veriyi değiştirirse, **tutarsız sonuçlar (inconsistent state)** oluşabilir.\n\nÖrneğin:\n\n```java\ncount++; // atomik değildir\n```\n\nBu ifade üç ayrı adım içerir (okuma, artırma, yazma).  \nEğer iki thread aynı anda çalışırsa, bir artış kaybolabilir.  \n`synchronized` bunu önler ve veri bütünlüğünü korur.\n\n---\n\n### 94) Deadlock (kilitlenme) nedir?\n\nDeadlock, iki veya daha fazla thread’in **birbirlerinin kilidini beklerken** sonsuza kadar beklemesi durumudur.\n\nKlasik örnek:\n\n```java\nThread 1: lock(A) -\u003e lock(B)\nThread 2: lock(B) -\u003e lock(A)\n```\n\nİkisi de birbirinin kilidini bekler ve asla devam edemez.\n\nÇözüm:\n\n- Kilit alma sırasını belirli tutmak.\n    \n- `tryLock()` gibi zaman sınırlı mekanizmalar kullanmak (Java 5’ten itibaren `ReentrantLock`).\n    \n\n---\n\n### 95) Deadlock nasıl önlenir?\n\n1. **Kilit sırasını tutarlı yap:** Tüm thread’ler aynı kaynak sırasını izlesin.\n    \n2. **Zaman aşımı kullan:** `tryLock(long timeout)` ile beklemeyi sınırla.\n    \n3. **Kaynakları küçült:** Daha az paylaşılan veri, daha az kilit ihtiyacı.\n    \n4. **Synchronized bloklarını kısa tut:** Uzun süreli kilitler risklidir.\n    \n\nDeadlock önlenemezse, program **donmuş gibi görünür**.\n\n---\n\n### 96) Inter-thread communication (iş parçacıkları arası iletişim) nedir?\n\nThread’lerin birbiriyle **koordineli çalışabilmesi** anlamına gelir.  \nJava’da bu iletişim `wait()`, `notify()` ve `notifyAll()` metotlarıyla sağlanır.\n\nAmaç: Thread’ler arasında **dönüşümlü işlem** yapılmasını sağlamak.  \nÖrneğin, biri veri üretsin (`Producer`), diğeri tüketsin (`Consumer`).\n\n---\n\n### 97) `wait()`, `notify()` ve `notifyAll()` metotları nedir?\n\nBu metotlar **Object** sınıfına aittir (Thread değil).  \nYani Java’daki her nesne, doğal olarak bu üç metodu taşır.\n\n- `wait()` → Thread kilidi bırakır ve bekleme moduna geçer.\n    \n- `notify()` → Bekleyen **bir thread’i** uyandırır.\n    \n- `notifyAll()` → Bekleyen **tüm thread’leri** uyandırır.\n    \n\nKurallar:\n\n- Bu metotlar **yalnızca synchronized blok içinde** çağrılabilir.\n    \n- Aksi halde `IllegalMonitorStateException` fırlatılır.\n    \n\n---\n\n### 98) `wait()` ve `sleep()` farkı nedir?\n\n|Özellik|`wait()`|`sleep()`|\n|---|---|---|\n|Tanımlı olduğu sınıf|`Object`|`Thread`|\n|Kilit bırakır mı?|Evet|Hayır|\n|Kullanım amacı|Thread iletişimi|Thread bekletme|\n|Çağrıldığı yer|Synchronized blok içinde|Her yerde olabilir|\n|Uyandırılma şekli|`notify()` veya `notifyAll()`|Süre dolunca veya interrupt|\n\nKısaca: `sleep()` sadece zaman kazandırır, `wait()` koordinasyon sağlar.\n\n---\n\n### 99) Thread priority (öncelik) nedir?\n\nHer thread’in JVM tarafından atanan bir **öncelik değeri** vardır (`1` ile `10` arasında).  \nBu değer, CPU planlayıcısına hangi thread’in **önce çalıştırılacağı** hakkında ipucu verir.\n\n```java\nt1.setPriority(Thread.MAX_PRIORITY);\nt2.setPriority(Thread.MIN_PRIORITY);\n```\n\nAma bu **garanti değildir**; JVM veya işletim sistemi farklı davranabilir.  \nYani thread’lerin sırası tahmin edilemez — concurrency’de deterministik davranış bekleme.\n\n---\n\n### 100) `Thread` ve `Runnable` farkı nedir?\n\n|Özellik|`Thread`|`Runnable`|\n|---|---|---|\n|Tür|Sınıf (extends)|Arayüz (implements)|\n|Çoklu miras|Mümkün değil (Java tek miras destekler)|Mümkün (interface olduğundan)|\n|Kullanım şekli|`class MyT extends Thread`|`class MyR implements Runnable`|\n|Önerilen kullanım|Basit senaryolar|Profesyonel, ölçeklenebilir yapı|\n|Avantaj|Daha kısa yazılır|Nesne tabanlı, bağımsız, esnek|\n\n**Özet:**  \n`Runnable`, modern ve doğru yaklaşımdır.  \n`Thread` sınıfını doğrudan genişletmek, sadece `run()` metodu dışında miras almak için anlamlı değildir.\n\n---\n\n### 101) Java’da garbage collection (çöp toplama) nedir?\n\nGarbage Collection (GC), artık kullanılmayan nesnelerin bellekte kapladığı alanı **otomatik olarak geri kazanan mekanizmadır**.  \nJava’da belleği manuel olarak serbest bırakmak gerekmez; JVM bunu yapar.\n\nBir nesneye **hiçbir referans kalmadığında**, garbage collector onu temizler.\n\n```java\nEmployee e = new Employee();\ne = null; // artık erişilemez -\u003e GC adayı\n```\n\nAvantaj: Bellek yönetimi kolaylaşır.  \nDezavantaj: GC’nin **ne zaman çalışacağı garanti edilmez.**\n\n---\n\n### 102) Garbage Collector ne zaman çalışır?\n\nKesin bir zaman yoktur. JVM, **bellek yetersizliği** durumunda veya uygun gördüğü anda çalıştırır.\n\nElle tetikleme mümkündür:\n\n```java\nSystem.gc();\n```\n\nAma bu sadece bir **istektir**, JVM kabul etmeyebilir.\n\nGerçek çalışma anı **JVM iç planlayıcısına bağlıdır.**\n\n---\n\n### 103) Garbage Collector hangi nesneleri temizler?\n\nGC, **hiçbir canlı referansı kalmamış** nesneleri temizler.  \nYani program tarafından artık ulaşılmayan (unreachable) nesneler.\n\nÖrnek:\n\n```java\nCar c1 = new Car();\nCar c2 = new Car();\nc1 = c2; // ilk Car nesnesi artık erişilemez\n```\n\nİlk oluşturulan nesne artık referanssız kaldı, GC onu temizler.\n\n---\n\n### 104) `finalize()` metodu nedir?\n\n`finalize()` metodu, bir nesne garbage collector tarafından silinmeden **hemen önce** çağrılır.\n\nSözdizimi:\n\n```java\nprotected void finalize() {\n    System.out.println(\"Nesne toplanıyor...\");\n}\n```\n\nAma dikkat:\n\n- GC’nin **finalize()’ı ne zaman çağıracağı** garanti edilmez.\n    \n- Java 9 itibariyle **deprecated (kullanımı önerilmez)** hale geldi.\n    \n\nModern Java’da bunun yerine `AutoCloseable` veya `try-with-resources` kullanılmalıdır.\n\n---\n\n### 105) `System.gc()` ve `Runtime.getRuntime().gc()` farkı nedir?\n\nİkisi de aynı şeyi yapar — garbage collector’a çağrı isteği gönderir.\n\n```java\nSystem.gc();                 // statik yöntem\nRuntime.getRuntime().gc();   // nesne üzerinden\n```\n\nHer ikisi de JVM’e “çöp toplayabilirsin” der ama **anında çalıştırmaz.**  \nJVM isterse çağrıyı yok sayabilir.\n\n---\n\n### 106) Java’da bellek kaçağı (memory leak) olur mu?\n\nEvet, olur.  \nGarbage collector, **referans varsa** nesneyi silmez — referans gereksiz bile olsa.\n\nÖrnek:\n\n```java\nList\u003cObject\u003e list = new ArrayList\u003c\u003e();\nwhile (true) {\n    list.add(new Object()); // asla serbest bırakılmaz\n}\n```\n\nListe büyümeye devam eder → **OutOfMemoryError**.\n\nKısaca:  \nGC sadece **referanssız** nesneleri temizler; referansı “unutulmamış” nesneleri temizlemez.\n\n---\n\n### 107) Stack ve Heap farkı nedir?\n\n|Özellik|Stack|Heap|\n|---|---|---|\n|Kullanım|Yerel değişkenler ve metod çağrıları|Nesneler ve sınıf örnekleri|\n|Bellek yönetimi|Otomatik|Garbage Collector tarafından|\n|Erişim hızı|Çok hızlı|Daha yavaş|\n|Yaşam süresi|Metot tamamlanana kadar|Nesne referansı kalana kadar|\n|Hata türü|StackOverflowError|OutOfMemoryError|\n\nKısaca:\n\n- Stack → kısa ömürlü veriler\n    \n- Heap → uzun ömürlü nesneler\n    \n\n---\n\n### 108) `OutOfMemoryError` nedir?\n\nJVM’in heap belleği dolduğunda ve yeni nesne oluşturulamadığında oluşan hatadır.\n\nÖrnek:\n\n```java\nList\u003cint[]\u003e list = new ArrayList\u003c\u003e();\nwhile (true) {\n    list.add(new int[1000000]);\n}\n```\n\nBu hata, garbage collector’ın **artık alan bulamaması** durumunda fırlatılır.  \nÇözüm:\n\n- Belleği optimize et.\n    \n- Gereksiz referansları kaldır.\n    \n- JVM heap boyutunu artır (`-Xmx1024m` gibi).\n    \n\n---\n\n### 109) `StackOverflowError` nedir?\n\nBir metod çağrısı **sonsuz döngü** oluşturduğunda, çağrı yığını (stack) taşar.\n\nÖrnek:\n\n```java\nvoid recursive() {\n    recursive(); // durmaz, stack dolar\n}\n```\n\nSonuç:\n\n```\nException in thread \"main\" java.lang.StackOverflowError\n```\n\nBu bir **Error**’dır, **Exception** değildir.  \nGenelde sonsuz özyineleme (recursion) veya çok derin çağrılar sebebiyle oluşur.\n\n---\n\n### 110) WeakReference nedir?\n\n`WeakReference`, garbage collector’a “bu nesne kullanılmıyorsa temizleyebilirsin” mesajını verir.  \nYani zayıf referans, nesneyi **GC’den korumaz**.\n\nÖrnek:\n\n```java\nWeakReference\u003cCar\u003e weakCar = new WeakReference\u003c\u003e(new Car());\nSystem.gc();\nif (weakCar.get() == null)\n    System.out.println(\"Nesne temizlendi!\");\n```\n\nKullanım amacı:\n\n- **Cache** yapıları veya **zamanla silinebilir nesneler**.\n    \n- Bellek optimizasyonu yapmak.\n    \n\n---\n\n### 111) `String` nedir, immutable olmasının anlamı\n\n- `String`, karakter dizilerini temsil eden bir sınıftır.\n    \n- **Immutable** olması demek: Bir `String` oluşturulduktan sonra içeriği **değiştirilemez**.  \n    Örneğin: `\"Hello\"`’nun karakterleri doğrudan değiştirilemez.\n    \n- Değişim gerekiyorsa, aslında **yeni bir String** oluşturulur.\n    \n\nBu immutability avantaj sağlar:\n\n- Thread-safe olurlar (çoklu iş parçacığında güvenlidir).\n    \n- String pool mekanizması ile bellekte paylaşım sağlanır.\n    \n\n---\n\n### 112) `StringBuilder` ve `StringBuffer` farkı nedir?\n\nHer ikisi de **değiştirilebilir (mutable)** karakter dizisi sınıfıdır, yani içeriğini doğrudan değiştirebilirsin.  \nAma aralarında temel farklar:\n\n- `StringBuffer` — **synchronized (eşzamanlı erişime güvenli)**\n    \n- `StringBuilder` — **synchronized değil**, dolayısıyla **daha hızlı**\n    \n\nGenelde tek thread ortamında `StringBuilder` tercih edilir, çoklu thread’li durumda `StringBuffer`.\n\n---\n\n### 113) `String` + operatörü arka planda ne yapar?\n\n`String`leri `+` ile birleştirdiğinde, JVM arka planda **StringBuilder** (veya StringBuffer) kullanır:\n\n```java\nString s = \"Hello\" + \" \" + \"World\";\n```\n\nDerleyici bunu:\n\n```java\nStringBuilder sb = new StringBuilder();\nsb.append(\"Hello\");\nsb.append(\" \");\nsb.append(\"World\");\ns = sb.toString();\n```\n\nşeklinde çevirir.  \nYani + operatörü performans açısından büyük bir dizi birleştirme için doğrudan kullanılmaz; `StringBuilder` iyidir.\n\n---\n\n### 114) `equals()` ve `==` arasındaki fark nedir?\n\n- `==` → Referans karşılaştırması yapar. (İki referans aynı nesneyi mi gösteriyor?)\n    \n- `equals()` → İçerik karşılaştırması yapar (String’te karakter karakter eşit mi?).\n    \n\nÖrnek:\n\n```java\nString a = new String(\"test\");\nString b = new String(\"test\");\nSystem.out.println(a == b);       // false\nSystem.out.println(a.equals(b));  // true\n```\n\n---\n\n### 115) `compareTo()` metodu nedir?\n\n`Comparable` arayüzünden gelir.  \nİki nesnenin **sıralama açısından** karşılaştırmasını yapar.  \nString’te, sözlük sırasına göre karşılaştırır:\n\n- Pozitif değer → `this` \u003e parametre\n    \n- Negatif değer → `this` \u003c parametre\n    \n- 0 → eşit\n    \n\nÖrnek:\n\n```java\n\"apple\".compareTo(\"banana\") // negatif değer\n```\n\n---\n\n### 116) `String.intern()` metodu nedir?\n\nBu metot, String pool’da mevcut olan aynı literali döndürür ya da yoksa ekler ve onu döner.  \nAmaç: Aynı içerikli String’ler bellekte tek bir nesne ile temsil edilsin.\n\n```java\nString s1 = new String(\"cat\");\nString s2 = s1.intern();\nString s3 = \"cat\";\nSystem.out.println(s2 == s3); // true\n```\n\n---\n\n### 117) `String.substring()` ile memory leak olabilir mi?\n\nJava’nın eski sürümlerinde (Java 6 öncesi) `substring()` arka planda orijinal char dizisini referans alırdı, bu da büyük orijinal String’in tamamının bellekte kalmasına yol açabilirdi.  \nYeni sürümlerde bu sorun çözülmüştür: `substring` artık yeni bir karakter dizi oluşturur, orijinal büyük diziyi referanslamaz.\n\n---\n\n### 118) `String` ile `StringBuilder`/`StringBuffer` karşılaştırması\n\n- `String` immutable: değişmez, her değişim yeni nesne yaratır — performans düşer.\n    \n- `StringBuilder` / `StringBuffer` mutable: içeriği değiştirilebilir, değişimlerde yeni nesne yaratılmaz.\n    \n- `StringBuffer` güvenlidir (synchronized).\n    \n- `StringBuilder` tek thread ortamında daha hızlıdır.\n    \n\n---\n\n### 119) `toString()` metodu neden override edilir?\n\nHer sınıfın varsayılan `toString()` metodu, sınıf ismi + hash kodu verir.  \nAma okunabilir çıktı almak için çoğu sınıf bu metodu override eder:\n\n```java\n@Override\npublic String toString() {\n    return \"Person{name='\" + name + \"', age=\" + age + \"}\";\n}\n```\n\nBöylece `System.out.println(obj)` çağrıldığında anlamlı bilgi gösterilir.\n\n---\n\n### 120) `String` vs `char[]` avantajları\n\n- `String`: Immutable, güvenli, kolay kullanım, string havuzu avantajı.\n    \n- `char[]`: Değiştirilebilir, hassas veriler (şifre gibi) için daha güvenli (çünkü içeriği sıfırlanabilir).\n    \n\nÖrneğin, şifre dizisini `char[]` olarak saklayıp işlemden sonra silmek mümkündür, `String` ile bu öyle kolay değildir.\n\n---\n\n### 121) Wrapper class (sarmalayıcı sınıf) nedir?\n\nWrapper sınıflar, **primitive (ilkel)** veri tiplerini **nesne (object)** olarak temsil eder.  \nHer primitive tipin bir wrapper sınıfı vardır:\n\n|Primitive|Wrapper Class|\n|---|---|\n|`byte`|`Byte`|\n|`short`|`Short`|\n|`int`|`Integer`|\n|`long`|`Long`|\n|`float`|`Float`|\n|`double`|`Double`|\n|`char`|`Character`|\n|`boolean`|`Boolean`|\n\nKullanım amacı:\n\n- Koleksiyonlarda (`List`, `Map` vb.) primitive değerleri tutmak.\n    \n- Nesne tabanlı işlemler yapmak (örneğin `toString()`, `equals()` gibi metotları çağırmak).\n    \n\n---\n\n### 122) Autoboxing nedir?\n\n**Autoboxing**, primitive tiplerin otomatik olarak **wrapper sınıfına dönüştürülmesidir.**\n\n```java\nint x = 10;\nInteger y = x; // autoboxing\n```\n\nJVM arka planda şunu yapar:\n\n```java\nInteger y = Integer.valueOf(x);\n```\n\nBu özellik Java 5’te (JDK 1.5) eklendi.\n\n---\n\n### 123) Unboxing nedir?\n\n**Unboxing**, wrapper nesnesinin primitive tipe otomatik dönüştürülmesidir.\n\n```java\nInteger i = 20;\nint x = i; // unboxing\n```\n\nDerleyici arka planda:\n\n```java\nint x = i.intValue();\n```\n\nAutoboxing ve unboxing birlikte kullanıldığında, kod daha sade olur ama **performans kaybı** yaratabilir (özellikle döngülerde).\n\n---\n\n### 124) `Integer` ve `int` farkı nedir?\n\n- `int`: primitive tip — stack üzerinde tutulur, hızlıdır.\n    \n- `Integer`: bir nesnedir (wrapper class) — heap üzerinde tutulur, metotlara sahiptir.\n    \n\n```java\nint a = 5;\nInteger b = 5;\nSystem.out.println(a == b); // true (unboxing)\n```\n\nAma dikkat:  \n`Integer` objeleri `==` ile karşılaştırıldığında referans kontrolü yapılır.\n\n---\n\n### 125) Wrapper sınıflar immutable mı?\n\nEvet, tüm wrapper sınıflar **immutable**’dır.  \nBir `Integer`, `Double` veya `Boolean` oluşturulduktan sonra değeri değiştirilemez.  \nDeğişim gibi görünen işlemler aslında **yeni nesne** oluşturur.\n\n---\n\n### 126) Type casting (tip dönüşümü) nedir?\n\nBir değişkeni başka bir tipe dönüştürmektir.  \nİki tür vardır:\n\n1. **Implicit (otomatik) casting:**  \n    Küçük tip → büyük tipe (data loss yok)\n    \n    ```java\n    int x = 10;\n    double y = x; // otomatik\n    ```\n    \n2. **Explicit (manuel) casting:**  \n    Büyük tip → küçük tipe (veri kaybı olabilir)\n    \n    ```java\n    double a = 9.7;\n    int b = (int) a; // 9\n    ```\n    \n\n---\n\n### 127) Upcasting ve Downcasting nedir?\n\n**Upcasting:** Alt sınıf nesnesini üst sınıf referansına atamaktır.  \nHer zaman güvenlidir.\n\n```java\nAnimal a = new Dog(); // upcasting\n```\n\n**Downcasting:** Üst sınıf referansını alt sınıfa dönüştürmektir.  \nRisklidir — derleme geçer ama çalışma zamanında hata olabilir.\n\n```java\nAnimal a = new Dog();\nDog d = (Dog) a; // güvenli\n```\n\nAma:\n\n```java\nAnimal a = new Cat();\nDog d = (Dog) a; // ClassCastException!\n```\n\n---\n\n### 128) Boxing/unboxing işlemleri performansı etkiler mi?\n\nEvet.  \nAutoboxing/unboxing işlemleri **arka planda ek nesne oluşturduğu için** performansı düşürür.  \nÖzellikle milyonlarca sayı içeren döngülerde fark belirgindir.\n\nÖneri:  \nPerformans kritik kodlarda primitive tipleri kullan.\n\n---\n\n### 129) `parseInt()` ve `valueOf()` farkı nedir?\n\nHer ikisi de `String`’i sayıya dönüştürür ama fark vardır:\n\n- `parseInt(String)` → primitive `int` döner.\n    \n- `valueOf(String)` → `Integer` nesnesi döner.\n    \n\n```java\nint a = Integer.parseInt(\"10\");     // primitive\nInteger b = Integer.valueOf(\"10\");  // nesne\n```\n\n---\n\n### 130) `NumberFormatException` nedir?\n\nBir `String`, sayıya dönüştürülürken geçersiz formatta ise oluşur.\n\n```java\nint x = Integer.parseInt(\"abc\"); // hata!\n```\n\nÇıktı:\n\n```\njava.lang.NumberFormatException: For input string: \"abc\"\n```\n\nBu **unchecked exception**’dır (`RuntimeException` alt sınıfı).  \nYani `try-catch` zorunlu değildir ama önerilir.\n\n---\n\n### 131) `Object` sınıfı nedir?\n\nJava’daki **tüm sınıfların atasıdır**.  \nHer sınıf doğrudan ya da dolaylı olarak `Object` sınıfından türetilir.\n\nÖrnek:\n\n```java\nclass Car {}\nSystem.out.println(new Car() instanceof Object); // true\n```\n\n`Object` sınıfı, Java’da **her nesnenin ortak davranışlarını** tanımlar: `equals()`, `hashCode()`, `toString()`, `clone()`, `wait()`, `notify()`, `notifyAll()`…\n\n---\n\n### 132) `equals()` metodu neden override edilir?\n\nVarsayılan `equals()` metodu, **referans karşılaştırması** yapar.  \nAma genelde biz **nesne içeriğini** karşılaştırmak isteriz.\n\nÖrneğin:\n\n```java\nclass Person {\n    String name;\n    Person(String name) { this.name = name; }\n\n    @Override\n    public boolean equals(Object obj) {\n        if (this == obj) return true;\n        if (obj == null || getClass() != obj.getClass()) return false;\n        Person p = (Person) obj;\n        return name.equals(p.name);\n    }\n}\n```\n\nArtık `new Person(\"Ali\")` ile `new Person(\"Ali\")` **eşit** kabul edilir.\n\n---\n\n### 133) `hashCode()` neden override edilir?\n\nJava’daki **hash tabanlı koleksiyonlar** (`HashMap`, `HashSet`, `Hashtable`) hem `equals()` hem `hashCode()` metodunu kullanır.\n\nKural:\n\n- Eğer iki nesne `equals()` açısından eşitse → `hashCode()` değerleri de **aynı olmalı**.\n    \n- Tersi gerekmez.\n    \n\nAksi durumda `HashSet`’e aynı nesneyi iki kere ekleyebilirsin — yanlış davranış olur.\n\n---\n\n### 134) `equals()` ve `hashCode()` ilişkisi\n\nJava standardına göre:\n\n1. `x.equals(y)` → `true` ise, `x.hashCode() == y.hashCode()` olmalı.\n    \n2. `x.equals(y)` → `false` olsa bile, hash’leri **aynı olabilir** (çakışma).\n    \n3. Hash kodu değişmemelidir (immutable veriye dayanmalı).\n    \n\nBu kurallar `HashMap` ve `HashSet`’in doğru çalışması için zorunludur.\n\n---\n\n### 135) `toString()` metodu nedir?\n\nBir nesnenin **okunabilir temsilini** döndürür.  \nVarsayılan hali:\n\n```java\nclassName@hexHashCode\n```\n\nÖrnek:\n\n```java\nPerson p = new Person(\"Ali\");\nSystem.out.println(p.toString());\n```\n\nÇıktı: `Person@5ca881b5`\n\nGenelde override edilir:\n\n```java\n@Override\npublic String toString() {\n    return \"Person{name='\" + name + \"'}\";\n}\n```\n\n---\n\n### 136) `getClass()` metodu nedir?\n\nBir nesnenin **runtime sınıf bilgisini** döndürür.  \nBu, **reflection (yansıma)** mekanizmasının temelidir.\n\n```java\nCar c = new Car();\nSystem.out.println(c.getClass().getName()); // Car\n```\n\nDönüş tipi: `Class\u003c?\u003e`  \nBu bilgi, dinamik nesne oluşturma (`Class.forName()`, `newInstance()`) gibi işlemlerde kullanılır.\n\n---\n\n### 137) `clone()` metodu nedir?\n\nBir nesnenin **kopyasını oluşturur**.  \n`Object.clone()` **shallow copy (yüzeysel kopya)** yapar.\n\nKullanmak için:\n\n1. Sınıf `Cloneable` arayüzünü implemente etmeli.\n    \n2. `clone()` metodunu override etmelisin.\n    \n\n```java\nclass Person implements Cloneable {\n    int age;\n    public Person clone() throws CloneNotSupportedException {\n        return (Person) super.clone();\n    }\n}\n```\n\nAksi halde `CloneNotSupportedException` fırlatılır.\n\n---\n\n### 138) Shallow copy ve Deep copy farkı nedir?\n\n**Shallow copy:**\n\n- Sadece nesnenin **referanslarını** kopyalar.\n    \n- Alt nesneler **aynı referansı** paylaşır.\n    \n\n**Deep copy:**\n\n- Alt nesneler dahil **tam bir kopya** oluşturur.\n    \n- Her şey bağımsız olur.\n    \n\n```java\nPerson p1 = new Person(new Address(\"İzmir\"));\nPerson p2 = (Person) p1.clone(); // shallow copy\n```\n\n`p1.address` ve `p2.address` aynı nesneyi gösterir.  \nDeep copy yaparsan, `Address` de klonlanır.\n\n---\n\n### 139) `finalize()` metodu `Object` sınıfında mı tanımlıdır?\n\nEvet.  \n`Object` içinde `protected void finalize()` olarak tanımlıdır.  \nGarbage collector bir nesneyi temizlemeden önce çağırır.\n\nAncak Java 9’dan itibaren **kullanımı yasaklanmıştır** (`deprecated`).  \nYerine `AutoCloseable` veya `Cleaner` sınıfları kullanılmalı.\n\n---\n\n### 140) `wait()`, `notify()`, `notifyAll()` metotları `Object`’te neden tanımlıdır?\n\nÇünkü her nesne bir **monitor lock** (kilit mekanizması) taşır.  \nBu metotlar, thread’lerin o kilit üzerinden haberleşmesini sağlar.\n\nYani yalnızca thread değil, **her nesne** senkronizasyon noktasına dönüşebilir.  \nBu yüzden `Thread` sınıfında değil, `Object`’te tanımlıdır.\n\n---\n\n### 141) Java Collections Framework nedir?\n\nJava Collections Framework (JCF), **veri kümelerini (collections)** depolamak, erişmek ve yönetmek için oluşturulmuş sınıflar ve arayüzler setidir.\n\nTemel arayüzler:\n\n- `Collection`\n    \n    - `List`\n        \n    - `Set`\n        \n    - `Queue`\n        \n- `Map` (Collection’ın parçası değildir ama benzer davranır)\n    \n\nAvantajları:\n\n- Kod tekrarını azaltır.\n    \n- Veri yapılarının (list, set, map) ortak davranışlarını standartlaştırır.\n    \n- Algoritma sınıfları (`Collections`, `Arrays`) ile kolay manipülasyon sağlar.\n    \n\n---\n\n### 142) `List`, `Set` ve `Map` farkı nedir?\n\n|Özellik|`List`|`Set`|`Map`|\n|---|---|---|---|\n|Eleman sırası|Korumalıdır|Rastgele veya sıralı|Anahtar-değer çifti|\n|Tekrarlayan eleman|Olabilir|Olamaz|Anahtarlar benzersiz|\n|Erişim yöntemi|Index|Eleman|Key|\n|Örnek sınıflar|`ArrayList`, `LinkedList`|`HashSet`, `TreeSet`|`HashMap`, `TreeMap`|\n\n---\n\n### 143) `ArrayList` ve `LinkedList` farkı nedir?\n\n|Özellik|`ArrayList`|`LinkedList`|\n|---|---|---|\n|Yapı|Dinamik dizi|Çift bağlı liste|\n|Erişim süresi|O(1) (index ile hızlı)|O(n)|\n|Ekleme/silme|Yavaş (veri kaydırma gerekir)|Hızlı (referans güncellenir)|\n|Bellek kullanımı|Daha az|Daha fazla (referanslar tutulur)|\n|Kullanım|Sık erişim|Sık ekleme/silme|\n\nYani:\n\n- **Okuma ağırlıklı** → `ArrayList`\n    \n- **Yazma ağırlıklı** → `LinkedList`\n    \n\n---\n\n### 144) `HashSet` ve `TreeSet` farkı nedir?\n\n|Özellik|`HashSet`|`TreeSet`|\n|---|---|---|\n|Sıra|Rastgele|Artan sırada|\n|Performans|Daha hızlı (O(1))|Daha yavaş (O(log n))|\n|Null|1 tane olabilir|Null kabul etmez|\n|Uygulama|HashMap tabanlı|TreeMap tabanlı|\n\n`HashSet` hız için, `TreeSet` sıralı veri için kullanılır.\n\n---\n\n### 145) `HashMap` ve `Hashtable` farkı nedir?\n\n|Özellik|`HashMap`|`Hashtable`|\n|---|---|---|\n|Senkronizasyon|Hayır (thread-safe değil)|Evet (synchronized)|\n|Null key/value|Evet (1 key, birçok value)|Hayır|\n|Performans|Daha hızlı|Daha yavaş|\n|Tanıtıldığı sürüm|Java 1.2|Java 1.0|\n\nModern uygulamalarda `HashMap` tercih edilir.  \nÇoklu thread ortamında `ConcurrentHashMap` kullanmak daha doğrudur.\n\n---\n\n### 146) `HashMap`’te anahtarlar (keys) nasıl saklanır?\n\n`HashMap` anahtarları **hashing algoritması** kullanarak saklar.  \nHer key için `hashCode()` çağrılır, sonra bu değer tablo boyutuna göre bir **index’e** dönüştürülür.  \nÇakışma olursa (`hash collision`), aynı “bucket” içinde **linked list** (Java 8’den itibaren gerekirse tree) olarak tutulur.\n\nYani:  \n`hash(key)` → `index` → `bucket` → `entry(key, value)`\n\n---\n\n### 147) `fail-fast` iterator nedir?\n\nBir koleksiyon üzerinde `Iterator` ile dolaşırken, koleksiyon **yapısal olarak değiştirilirse**, iterator `ConcurrentModificationException` fırlatır.\n\nÖrnek:\n\n```java\nList\u003cInteger\u003e list = new ArrayList\u003c\u003e();\nlist.add(1);\nIterator\u003cInteger\u003e it = list.iterator();\nlist.add(2); // değişiklik\nit.next();   // hata!\n```\n\nBu davranışa **fail-fast** denir.  \nÇözüm: `Iterator.remove()` kullanmak veya `CopyOnWriteArrayList` gibi eşzamanlı koleksiyonlar.\n\n---\n\n### 148) `Iterator` ve `ListIterator` farkı nedir?\n\n|Özellik|`Iterator`|`ListIterator`|\n|---|---|---|\n|Erişim yönü|Tek yönlü|Çift yönlü|\n|Koleksiyon türü|Tüm koleksiyonlar|Sadece `List`|\n|Eleman ekleme|Hayır|`add()` ile evet|\n|Başlangıç pozisyonu|0’dan başlar|Belirli index’ten başlayabilir|\n\n`ListIterator` ile `previous()` kullanarak geriye doğru da gezebilirsin.\n\n---\n\n### 149) `Comparable` ve `Comparator` farkı nedir?\n\n|Özellik|`Comparable`|`Comparator`|\n|---|---|---|\n|Arayüzün metodu|`compareTo(Object o)`|`compare(Object o1, Object o2)`|\n|Nerede uygulanır|Doğrudan sınıfın içinde|Ayrı bir sınıfta|\n|Sıralama türü|Doğal (natural) sıralama|Özel sıralama|\n|Örnek|`String`, `Integer` (default)|Özel kriterle (`Comparator.comparing()`)|\n\n**Kural:**\n\n- `Comparable` → tek standart sıralama\n    \n- `Comparator` → alternatif sıralama\n    \n\n---\n\n### 150) `Collections` sınıfı nedir?\n\n`java.util.Collections`, koleksiyonlar üzerinde **yardımcı metotlar (utility methods)** sağlayan **final** bir sınıftır.\n\nÖrnek metotlar:\n\n```java\nCollections.sort(list);\nCollections.reverse(list);\nCollections.shuffle(list);\nCollections.max(list);\nCollections.synchronizedList(list);\n```\n\nYani “koleksiyonlar için statik yardımcı metotlar kütüphanesi”dir.\n\n---\n\n### 151) `Map.Entry` nedir?\n\n`Map.Entry` bir **iç arayüz (inner interface)** olup, bir `Map` içindeki **key–value (anahtar-değer)** çiftini temsil eder.\n\nÖrnek kullanım:\n\n```java\nMap\u003cString, Integer\u003e map = new HashMap\u003c\u003e();\nmap.put(\"Ali\", 30);\nmap.put(\"Ayşe\", 25);\n\nfor (Map.Entry\u003cString, Integer\u003e e : map.entrySet()) {\n    System.out.println(e.getKey() + \" -\u003e \" + e.getValue());\n}\n```\n\nAvantajı: Hem anahtara hem değere doğrudan erişim sağlar.\n\n---\n\n### 152) `Properties` sınıfı nedir?\n\n`Properties`, `Hashtable`’dan türetilmiş bir sınıftır ve **konfigürasyon verilerini** (anahtar–değer çiftlerini) tutmak için kullanılır.  \nAnahtar ve değerler **her zaman `String` tipindedir**.\n\nKullanımı:\n\n```java\nProperties p = new Properties();\np.setProperty(\"user\", \"burak\");\np.setProperty(\"language\", \"tr\");\n\nSystem.out.println(p.getProperty(\"user\"));\n```\n\nAyrıca `.properties` dosyalarından veri okumak/yazmak için kullanılır:\n\n```java\np.load(new FileReader(\"config.properties\"));\np.store(new FileWriter(\"config.properties\"), \"Config File\");\n```\n\n---\n\n### 153) `Enumeration` nedir?\n\n`Enumeration`, eski Java sürümlerinde (JDK 1.0) kullanılan **iterator’ın atasıdır**.  \nBugün hala bazı eski sınıflarda (`Vector`, `Hashtable`) kullanılır.\n\nÖrnek:\n\n```java\nVector\u003cString\u003e v = new Vector\u003c\u003e();\nv.add(\"A\"); v.add(\"B\");\nEnumeration\u003cString\u003e e = v.elements();\n\nwhile (e.hasMoreElements()) {\n    System.out.println(e.nextElement());\n}\n```\n\nModern alternatif: **`Iterator` veya `for-each`** kullanmak.\n\n---\n\n### 154) `Enum` nedir?\n\n`Enum`, sabit değerlerin **tür güvenli (type-safe)** biçimde tanımlanmasını sağlayan özel bir sınıf türüdür.  \nHer `enum` değeri aslında bir **nesnedir**.\n\n```java\nenum Gun {\n    PAZARTESI, SALI, CARSAMBA, PERSEMBE, CUMA, CUMARTESI, PAZAR\n}\nGun g = Gun.PAZARTESI;\n```\n\n`enum` içinde metot da tanımlanabilir.  \nÖrneğin:\n\n```java\nenum Seviye {\n    DUSUK(1), ORTA(2), YUKSEK(3);\n    int kod;\n    Seviye(int k) { this.kod = k; }\n}\n```\n\n---\n\n### 155) `EnumSet` nedir?\n\n`EnumSet`, sadece `enum` tipleriyle çalışan **yüksek performanslı bir Set** implementasyonudur.  \nNormal `HashSet`’ten çok daha hızlıdır çünkü bit tabanlı çalışır.\n\nÖrnek:\n\n```java\nEnumSet\u003cGun\u003e hafta = EnumSet.of(Gun.PAZARTESI, Gun.CUMA);\n```\n\nSıralama, `enum` tanımlama sırasına göredir.  \nThread-safe değildir, ama `Collections.synchronizedSet()` ile yapılabilir.\n\n---\n\n### 156) Generics (jenerikler) nedir?\n\nGenerics, Java’da sınıf ve metotların **tür bağımsız (type-safe)** yazılmasını sağlar.  \nYani “her türle çalışan ama tip güvenli” yapılar oluşturur.\n\n```java\nList\u003cString\u003e isimler = new ArrayList\u003c\u003e();\nisimler.add(\"Burak\");\nString ad = isimler.get(0); // cast gerekmez\n```\n\nAvantajları:\n\n- **Compile-time tip güvenliği**\n    \n- **Casting ihtiyacını ortadan kaldırır**\n    \n- **Kod tekrarını azaltır**\n    \n\n---\n\n### 157) Wildcard (`?`) nedir?\n\nWildcard (`?`), **bilinmeyen bir türü** temsil eder.  \nÜç türü vardır:\n\n1. `?` — herhangi bir tür\n    \n2. `? extends T` — T veya onun alt türleri\n    \n3. `? super T` — T veya onun üst türleri\n    \n\nÖrnek:\n\n```java\nList\u003c? extends Number\u003e sayilar = new ArrayList\u003cInteger\u003e();\nList\u003c? super Integer\u003e tamSayilar = new ArrayList\u003cNumber\u003e();\n```\n\nKural hatırlatması:\n\n\u003e **“extends → okuma, super → yazma”**  \n\u003e Yani `extends` ile listeye ekleyemezsin, ama `super` ile ekleyebilirsin.\n\n---\n\n### 158) Bounded type parameters nedir?\n\nBir generic parametreye sınır koymak demektir.  \nYani sadece belirli türlerin kabul edilmesini sağlar.\n\n```java\nclass Kutu\u003cT extends Number\u003e {\n    T deger;\n}\n```\n\nBu sınıf sadece `Integer`, `Float`, `Double` gibi `Number` alt sınıflarıyla çalışır.  \nBu sayede generic kod içinde `Number` metotları (örneğin `doubleValue()`) kullanılabilir.\n\n---\n\n### 159) Generic method nedir?\n\nBir metodun kendi tür parametresine sahip olmasıdır.  \nSınıf generic olmasa bile metot olabilir.\n\n```java\npublic \u003cT\u003e void yazdir(T veri) {\n    System.out.println(veri);\n}\n```\n\nÇağrıldığında tip otomatik belirlenir:\n\n```java\nyazdir(\"Merhaba\");\nyazdir(42);\n```\n\nBu sayede aynı metod, farklı türlerle çalışabilir.\n\n---\n\n### 160) `Comparable` ve `Comparator` arasındaki ilişki nedir?\n\n- `Comparable`, bir sınıfın **kendi doğal sıralama mantığını** belirtir.\n    \n- `Comparator`, **harici (external)** bir sıralama mantığı tanımlar.\n    \n\nBir sınıf aynı anda `Comparable`’ı implemente edip, alternatif sıralama için `Comparator` nesneleriyle de kullanılabilir.\n\nÖrnek:\n\n```java\nclass Kisi implements Comparable\u003cKisi\u003e {\n    int yas;\n    public int compareTo(Kisi k) {\n        return this.yas - k.yas;\n    }\n}\n```\n\nAlternatif sıralama:\n\n```java\nComparator\u003cKisi\u003e isimSirasi = (a, b) -\u003e a.isim.compareTo(b.isim);\n```\n\n---\n\n### 161) Java I/O (Input/Output) nedir?\n\nJava I/O, **veri giriş/çıkışı (input/output)** işlemlerini yapan sınıflar bütünüdür.  \nDosya okuma, yazma, ağdan veri alma veya terminale çıktı verme bu sistemle yapılır.\n\nI/O yapısı iki temel hiyerarşiye ayrılır:\n\n- **Byte stream** (bayt bazlı): `InputStream`, `OutputStream`\n    \n- **Character stream** (karakter bazlı): `Reader`, `Writer`\n    \n\n---\n\n### 162) Byte stream ve Character stream farkı nedir?\n\n|Özellik|Byte Stream|Character Stream|\n|---|---|---|\n|Temel sınıf|`InputStream`, `OutputStream`|`Reader`, `Writer`|\n|Veri tipi|8-bit byte|16-bit Unicode karakter|\n|Kullanım|Görsel, ses, PDF gibi binary dosyalar|Metin dosyaları|\n|Örnek|`FileInputStream`, `BufferedOutputStream`|`FileReader`, `BufferedWriter`|\n\n**Özet:**  \nBinary dosya → byte stream  \nText dosya → character stream\n\n---\n\n### 163) `File` sınıfı nedir?\n\n`java.io.File`, dosya veya dizinleri temsil eden bir sınıftır.  \nDosyanın **var olup olmadığını, boyutunu, adını** kontrol edebilirsin ama içeriğini **okumaz/yazmaz**.\n\nÖrnek:\n\n```java\nFile f = new File(\"data.txt\");\nif (f.exists()) {\n    System.out.println(\"Boyut: \" + f.length());\n}\n```\n\n`File` sadece **dosya sistemini temsil eder**, I/O akışı sağlamaz.\n\n---\n\n### 164) `FileReader` ve `FileWriter` nedir?\n\nBunlar **character stream** sınıflarıdır.\n\n- `FileReader` → dosyadan karakter okur.\n    \n- `FileWriter` → dosyaya karakter yazar.\n    \n\nÖrnek:\n\n```java\nFileWriter fw = new FileWriter(\"dosya.txt\");\nfw.write(\"Merhaba Java\");\nfw.close();\n```\n\nBüyük dosyalarda `BufferedReader` / `BufferedWriter` ile birlikte kullanmak performansı artırır.\n\n---\n\n### 165) `FileInputStream` ve `FileOutputStream` farkı nedir?\n\nBunlar **byte stream** sınıflarıdır.  \nYani veriyi byte byte okur/yazar (metin değil, binary düzeyde).\n\n```java\nFileInputStream in = new FileInputStream(\"image.jpg\");\nFileOutputStream out = new FileOutputStream(\"copy.jpg\");\n\nint i;\nwhile ((i = in.read()) != -1)\n    out.write(i);\n\nin.close();\nout.close();\n```\n\nGörsel, ses, PDF gibi binary dosyalar için kullanılır.\n\n---\n\n### 166) `BufferedReader` nedir?\n\n`BufferedReader`, karakterleri **bellekte tamponlayarak (buffer)** okur.  \nBu sayede okuma işlemleri çok daha hızlı olur.\n\n```java\nBufferedReader br = new BufferedReader(new FileReader(\"metin.txt\"));\nString satir;\nwhile ((satir = br.readLine()) != null) {\n    System.out.println(satir);\n}\nbr.close();\n```\n\nAvantajı: Satır satır okuma (`readLine()`) sağlar ve I/O işlemini minimize eder.\n\n---\n\n### 167) Serialization (serileştirme) nedir?\n\nBir nesnenin durumunu (state) **bayt dizisine dönüştürüp** diske yazmak veya ağdan göndermek işlemidir.\n\nJava’da bunun için `Serializable` arayüzü kullanılır:\n\n```java\nclass Person implements Serializable {\n    String name;\n    int age;\n}\n```\n\nYazmak:\n\n```java\nObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(\"p.ser\"));\noos.writeObject(new Person(\"Burak\", 30));\noos.close();\n```\n\nOkumak:\n\n```java\nObjectInputStream ois = new ObjectInputStream(new FileInputStream(\"p.ser\"));\nPerson p = (Person) ois.readObject();\n```\n\n---\n\n### 168) Deserialization (ters serileştirme) nedir?\n\nSerileştirilmiş bir nesnenin, **bayt dizisinden tekrar nesneye dönüştürülmesidir**.  \nYani `ObjectInputStream` kullanarak okunan veri, yeniden Java nesnesine çevrilir.\n\n```java\nObjectInputStream in = new ObjectInputStream(new FileInputStream(\"data.ser\"));\nPerson p = (Person) in.readObject();\n```\n\nSerialization ve deserialization **aynı `serialVersionUID`** değeriyle çalışmalıdır.\n\n---\n\n### 169) `transient` anahtar kelimesi nedir?\n\nBir sınıf serileştirilirken, **bazı alanların kaydedilmemesini** sağlar.  \nYani `transient` olarak işaretlenen alanlar **serialization sırasında yok sayılır.**\n\n```java\nclass User implements Serializable {\n    String username;\n    transient String password;\n}\n```\n\n`password` diske yazılmaz — güvenlik için kullanılır.\n\n---\n\n### 170) `serialVersionUID` nedir?\n\nSerileştirilen sınıflar için **benzersiz bir kimlik numarasıdır.**  \nSerialization sırasında, okunan nesne ile sınıfın sürümü uyuşmazsa hata alınır.\n\n```java\nprivate static final long serialVersionUID = 1L;\n```\n\nEğer bunu elle belirtmezsen, JVM otomatik oluşturur — ama sınıfta bir değişiklik yaparsan **uyumsuzluk (InvalidClassException)** oluşabilir.  \nBu yüzden, `serialVersionUID` **manuel tanımlanmalıdır.**\n\n---\n\n### 171) Lambda expression nedir?\n\nLambda, Java 8 ile gelen **anonim fonksiyon** yazma biçimidir.  \nYani “ismi olmayan metot”.  \nDaha kısa, fonksiyonel kod yazmayı sağlar.\n\nÖrnek:\n\n```java\n// klasik\nRunnable r = new Runnable() {\n    public void run() { System.out.println(\"Çalıştı!\"); }\n};\n\n// lambda ile\nRunnable r2 = () -\u003e System.out.println(\"Çalıştı!\");\n```\n\nKural: Lambda sadece **functional interface**’lerle (tek metot içeren arayüzler) kullanılabilir.  \nÖrnek: `Runnable`, `Comparator`, `Predicate`, `Function`, `Consumer`.\n\n---\n\n### 172) Functional Interface nedir?\n\nFunctional interface, yalnızca **bir tane abstract metodu** olan arayüzdür.  \nJava 8’de bu tür arayüzler `@FunctionalInterface` anotasyonu ile işaretlenir.\n\n```java\n@FunctionalInterface\ninterface Hesaplama {\n    int topla(int a, int b);\n}\n```\n\nKullanımı:\n\n```java\nHesaplama h = (x, y) -\u003e x + y;\nSystem.out.println(h.topla(3, 5));\n```\n\nBunlar **Spring’in @FunctionalBean**, **Reactor’ın Mono/Flux map/filter** fonksiyonlarının arkasındaki temel yapıdır.\n\n---\n\n### 173) Java’nın built-in functional interface’leri nelerdir?\n\n|Interface|Metot|Açıklama|Örnek|\n|---|---|---|---|\n|`Predicate\u003cT\u003e`|`boolean test(T t)`|Koşul kontrolü|`x -\u003e x \u003e 10`|\n|`Function\u003cT,R\u003e`|`R apply(T t)`|Dönüşüm|`x -\u003e x * 2`|\n|`Consumer\u003cT\u003e`|`void accept(T t)`|İşlem yapar|`System.out::println`|\n|`Supplier\u003cT\u003e`|`T get()`|Değer üretir|`() -\u003e Math.random()`|\n|`BiFunction\u003cT,U,R\u003e`|`R apply(T,U)`|2 parametreli fonksiyon|`(a,b)-\u003ea+b`|\n\nSpring Stream, Reactor, Optional API’lerinde hepsi bolca geçer.\n\n---\n\n### 174) Method Reference nedir?\n\nLambda ifadelerinin sadeleştirilmiş halidir.  \nYani “hazır metodu lambda yerine geçir”.\n\nÖrnek:\n\n```java\nlist.forEach(System.out::println);\n```\n\nAynısı:\n\n```java\nlist.forEach(x -\u003e System.out.println(x));\n```\n\nKullanım tipleri:\n\n- `Class::staticMethod`\n    \n- `instance::instanceMethod`\n    \n- `Class::new` (constructor reference)\n    \n\nBu özellikle `Collectors`, `map`, `filter` gibi Stream çağrılarında çok sık görülür.\n\n---\n\n### 175) Stream API nedir?\n\nStream, koleksiyonlar üzerinde **veri işleme boru hattıdır (data pipeline)**.  \nJava 8’de geldi, functional yaklaşımı destekler.\n\nÖrnek:\n\n```java\nList\u003cInteger\u003e sayilar = Arrays.asList(1,2,3,4,5);\nsayilar.stream()\n       .filter(x -\u003e x % 2 == 0)\n       .map(x -\u003e x * 2)\n       .forEach(System.out::println);\n```\n\nStream = **kaynak → ara işlemler → terminal işlem.**\n\n---\n\n### 176) Intermediate (ara) ve Terminal işlemler farkı nedir?\n\n**Intermediate (ara işlemler):**  \nVeriyi dönüştürür, stream döndürür. Lazy evaluation (tembel hesaplama).  \nÖrnek: `filter()`, `map()`, `sorted()`, `distinct()`.\n\n**Terminal işlemler:**  \nStream’i bitirir, sonuç döndürür.  \nÖrnek: `forEach()`, `collect()`, `reduce()`, `count()`.\n\nStream zinciri, terminal işlem çağrılmadan **hiç çalışmaz**.\n\n---\n\n### 177) `map()` ve `flatMap()` farkı nedir?\n\n- `map()` → her elemanı **tek değer**e dönüştürür.\n    \n- `flatMap()` → her elemanı **birden fazla değeri içeren stream**’e dönüştürür, sonra düzleştirir.\n    \n\n```java\nList\u003cList\u003cInteger\u003e\u003e sayilar = Arrays.asList(Arrays.asList(1,2), Arrays.asList(3,4));\nsayilar.stream()\n       .flatMap(List::stream)\n       .forEach(System.out::println);\n```\n\nÇıktı: `1 2 3 4`  \nYani nested (iç içe) yapı → düzleştirilmiş liste.\n\n---\n\n### 178) Optional nedir?\n\n`Optional\u003cT\u003e` null kontrollerini güvenli hale getiren bir kapsayıcı sınıftır.  \nNullPointerException düşürmeden veriyle çalışmamızı sağlar.\n\n```java\nOptional\u003cString\u003e isim = Optional.ofNullable(getName());\nisim.ifPresent(System.out::println);\n```\n\nAna metotlar:\n\n- `of()`, `ofNullable()`\n    \n- `isPresent()`, `ifPresent()`\n    \n- `orElse()`, `orElseGet()`\n    \n- `map()`, `flatMap()`\n    \n\nSpring Data metot dönüşlerinde (`findById()`, `findFirstBy...`) sıklıkla kullanılır.\n\n---\n\n### 179) Parallel Stream nedir?\n\nStream işlemlerini **çok çekirdekli CPU**’larda paralel çalıştırır.  \nYani her işlem farklı thread üzerinde yürütülür.\n\n```java\nlist.parallelStream().forEach(System.out::println);\n```\n\nAvantaj: Büyük veri setlerinde hız.  \nDezavantaj: Sıralama garantisi yok, thread overhead’i olabilir.  \nDikkat: Stateless (yan etkisiz) fonksiyonlarla kullanılmalı.\n\n---\n\n### 180) Collectors API nedir?\n\nStream sonuçlarını koleksiyonlara, istatistiklere veya özel yapılara dönüştürür.\n\nÖrnekler:\n\n```java\n// Listeye dönüştürme\nList\u003cInteger\u003e ciftler = sayilar.stream()\n    .filter(x -\u003e x % 2 == 0)\n    .collect(Collectors.toList());\n\n// Gruplama\nMap\u003cString, List\u003cEmployee\u003e\u003e byDept =\n    employees.stream().collect(Collectors.groupingBy(Employee::getDepartment));\n```\n\nSpring Boot projelerinde `Collectors.groupingBy`, `mapping`, `joining` gibi işlemler genellikle DTO dönüştürürken veya raporlama için çok kullanılır.\n\n---\n\n### 181) `ExecutorService` nedir?\n\n`ExecutorService`, thread oluşturma işini manuel yapmadan yönetmek için kullanılan bir **thread pool yöneticisidir.**  \nHer `new Thread()` açmak pahalıdır, o yüzden havuz mantığı kullanılır.\n\nÖrnek:\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(4);\nexecutor.submit(() -\u003e System.out.println(\"İş çalıştı\"));\nexecutor.shutdown();\n```\n\nAvantaj:\n\n- Thread havuzunu otomatik yönetir.\n    \n- Paralel görevleri sıraya alır.\n    \n- Spring’in `@Async`, `TaskExecutor` ve `ThreadPoolTaskExecutor`’larının temeli budur.\n    \n\n---\n\n### 182) `Callable` ve `Runnable` farkı nedir?\n\n|Özellik|Runnable|Callable|\n|---|---|---|\n|Dönüş değeri|Yok (`void`)|Var (`T`)|\n|Exception fırlatabilir mi|Hayır|Evet (`throws Exception`)|\n|Metot adı|`run()`|`call()`|\n|Kullanıldığı yer|`Thread`, `ExecutorService`|`ExecutorService`|\n\nÖrnek:\n\n```java\nCallable\u003cInteger\u003e task = () -\u003e 5 + 10;\nFuture\u003cInteger\u003e f = executor.submit(task);\nSystem.out.println(f.get());\n```\n\n`Callable` → thread sonuç döndüren versiyon.\n\n---\n\n### 183) `Future` nedir?\n\n`Future`, bir asenkron görevin sonucunu **ileride** almayı sağlar.\n\n```java\nFuture\u003cInteger\u003e future = executor.submit(() -\u003e 42);\nSystem.out.println(future.get()); // bloklar\n```\n\nYani `get()` çağrılana kadar thread devam eder, `get()` sonucu bekler.\n\nDezavantaj: `Future` sonuç hazır değilse **bloklar** → bu yüzden `CompletableFuture` geldi.\n\n---\n\n### 184) `CompletableFuture` nedir?\n\n`CompletableFuture`, asenkron işlemleri **non-blocking** (beklemeden) şekilde zincirlemeni sağlar.  \nYani “promise/future chaining”.\n\n```java\nCompletableFuture.supplyAsync(() -\u003e getUser())\n    .thenApply(user -\u003e enrich(user))\n    .thenAccept(System.out::println);\n```\n\nArtık `get()` ile beklemek zorunda değilsin, callback zinciriyle ilerlersin.  \nSpring WebFlux, Reactor, Project Loom bu yapının üstüne inşa edilmiştir.\n\n---\n\n### 185) `CompletableFuture` ile exception handling nasıl yapılır?\n\nHer zincir `exceptionally()` veya `handle()` metodu ile hataları yönetebilir.\n\n```java\nCompletableFuture.supplyAsync(() -\u003e riskyCall())\n    .exceptionally(ex -\u003e {\n        System.out.println(\"Hata: \" + ex.getMessage());\n        return \"varsayılan\";\n    })\n    .thenAccept(System.out::println);\n```\n\nBöylece try-catch yerine fonksiyonel hata yönetimi yapılır.\n\n---\n\n### 186) `synchronized` blok yerine hangi modern yapılar kullanılır?\n\nManuel `synchronized` yerine **java.util.concurrent.locks** paketindeki araçlar tercih edilir:\n\n- `ReentrantLock` → kilit üzerinde daha fazla kontrol sağlar.\n    \n- `ReadWriteLock` → okuma/yazma ayrı kilitlenir.\n    \n- `Semaphore` → kaynak sayısını kontrol eder.\n    \n- `CountDownLatch`, `CyclicBarrier` → thread senkronizasyonu sağlar.\n    \n- `AtomicInteger`, `ConcurrentHashMap` → lock-free concurrency.\n    \n\nSpring Boot’un `@Scheduled`, `@Async` görevleri bu yapıların üst düzey soyutlamasıdır.\n\n---\n\n### 187) `CountDownLatch` nedir?\n\nBir grup thread’in **belirli bir koşulu beklemesini** sağlar.  \nYani bir sayaç sıfıra inene kadar diğer thread’ler bekler.\n\n```java\nCountDownLatch latch = new CountDownLatch(3);\nfor (int i = 0; i \u003c 3; i++) {\n    new Thread(() -\u003e { task(); latch.countDown(); }).start();\n}\nlatch.await(); // hepsi bitene kadar bekler\nSystem.out.println(\"Tüm işler tamam!\");\n```\n\nKullanım yeri: test senkronizasyonu, batch işlemleri.\n\n---\n\n### 188) `CyclicBarrier` nedir?\n\n`CountDownLatch`’e benzer ama **tekrarlanabilir** (barrier yeniden kullanılabilir).  \nTüm thread’ler bariyere ulaştığında aynı anda devam ederler.\n\n```java\nCyclicBarrier barrier = new CyclicBarrier(3, () -\u003e System.out.println(\"Bariyer aşıldı!\"));\nfor (int i = 0; i \u003c 3; i++) {\n    new Thread(() -\u003e {\n        awaitTask();\n        barrier.await();\n    }).start();\n}\n```\n\nKullanım: Aynı anda başlayacak paralel hesaplamalar.\n\n---\n\n### 189) `Semaphore` nedir?\n\nBelirli sayıda thread’in aynı anda bir kaynağa erişmesini sağlar.  \nYani “izin sistemi”.\n\n```java\nSemaphore sem = new Semaphore(2); // aynı anda 2 izin\nfor (int i = 0; i \u003c 5; i++) {\n    new Thread(() -\u003e {\n        try {\n            sem.acquire();\n            System.out.println(Thread.currentThread().getName() + \" çalışıyor\");\n            Thread.sleep(1000);\n            sem.release();\n        } catch (Exception ignored) {}\n    }).start();\n}\n```\n\nBu sistem thread sayısını veya eşzamanlı kaynak erişimini kontrol eder.\n\n---\n\n### 190) `ConcurrentHashMap` nedir?\n\n`HashMap`’in thread-safe (çoklu erişim güvenli) versiyonudur.  \nKlasik `HashMap` eşzamanlı kullanıldığında `ConcurrentModificationException` fırlatır.  \n`ConcurrentHashMap` bunu **segment-based locking** (bölgesel kilitleme) ile çözer.\n\n```java\nConcurrentHashMap\u003cString, Integer\u003e map = new ConcurrentHashMap\u003c\u003e();\nmap.put(\"A\", 1);\nmap.computeIfAbsent(\"B\", k -\u003e 2);\n```\n\nSpring Cache, Spring Security Session Store ve hatta bazı Redis client’ları bu yapıyı içeride kullanır.\n\n---\n\n### 191) `map()` ve `filter()` zincirinde `Optional` nasıl kullanılır?\n\n`Optional` içinde fonksiyonel işlemler yapılabilir, null kontrolü gerekmez.\n\n```java\nOptional\u003cString\u003e isim = Optional.of(\"burak\");\n\nisim.filter(s -\u003e s.length() \u003e 3)\n    .map(String::toUpperCase)\n    .ifPresent(System.out::println);\n```\n\nBurada `filter` koşul tutmazsa zincir durur, `map` çağrılmaz.  \nBu `Optional`’ı mini bir Stream gibi kullanmamızı sağlar.  \nSpring Data’da `findById()` dönen `Optional` için çok kullanılır.\n\n---\n\n### 192) `Collectors.groupingBy()` nedir?\n\nStream sonuçlarını bir özelliğe göre **gruplar**.  \nSQL’deki `GROUP BY` gibidir.\n\n```java\nMap\u003cString, List\u003cEmployee\u003e\u003e byDept = employees.stream()\n    .collect(Collectors.groupingBy(Employee::getDepartment));\n```\n\nİkinci argümanla alt işlemler de eklenebilir:\n\n```java\nMap\u003cString, Long\u003e sayi = employees.stream()\n    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));\n```\n\nSpring Boot servis katmanında DTO istatistikleri oluşturmakta sık kullanılır.\n\n---\n\n### 193) `partitioningBy()` nedir?\n\n`groupingBy`’un boolean versiyonudur.  \nStream’i ikiye ayırır: koşulu sağlayanlar ve sağlamayanlar.\n\n```java\nMap\u003cBoolean, List\u003cInteger\u003e\u003e sonuc =\n    sayilar.stream().collect(Collectors.partitioningBy(x -\u003e x % 2 == 0));\n```\n\nÇıktı:\n\n```\ntrue -\u003e [2,4,6]\nfalse -\u003e [1,3,5]\n```\n\nBöylece filter yerine iki yönlü ayrım yapılır.\n\n---\n\n### 194) `joining()` nedir?\n\nString stream’lerini tek bir String’e birleştirir.\n\n```java\nString adlar = employees.stream()\n    .map(Employee::getName)\n    .collect(Collectors.joining(\", \"));\nSystem.out.println(adlar); // \"Ali, Ayşe, Burak\"\n```\n\nDTO’ları loglama, e-posta listesi veya CSV üretimi için mükemmeldir.\n\n---\n\n### 195) `reduce()` nedir?\n\nTüm elemanları **tek bir sonuca indirger.**  \nToplama, çarpma, maksimum/minimum bulma gibi işlemlerde kullanılır.\n\n```java\nint toplam = sayilar.stream().reduce(0, Integer::sum);\n```\n\n`reduce` → bir Stream’de “aggregate” işlemi yapar.  \nSpring Data Projection’lar veya custom query sonuçlarında çok kullanışlı.\n\n---\n\n### 196) `record` nedir? _(Java 16+)_\n\n`record`, veri taşıyan sınıflar (DTO’lar) için **otomatik getter, equals, hashCode, toString** üreten yeni bir sınıf tipidir.\n\n```java\npublic record UserDto(String name, int age) {}\n```\n\nOtomatik olarak immutable’dır.  \nSpring Boot’ta request/response DTO’larında mükemmel:\n\n```java\nrecord LoginRequest(String username, String password) {}\n```\n\nYani “Lombok’suz data class”.\n\n---\n\n### 197) `sealed class` nedir? _(Java 17+)_\n\nSınıfın hangi alt sınıflar tarafından genişletilebileceğini **kısıtlar.**\n\n```java\npublic sealed class Payment permits CreditCard, Cash {}\npublic final class CreditCard extends Payment {}\npublic final class Cash extends Payment {}\n```\n\nBu yapı `enum` kadar katı değildir ama miras zincirini kontrol eder.  \nSpring Security ve domain model’lerde type-safety için çok işe yarar.\n\n---\n\n### 198) Pattern Matching for `instanceof` nedir? _(Java 14+)_\n\nEskiden:\n\n```java\nif (obj instanceof String) {\n    String s = (String) obj;\n    System.out.println(s.toUpperCase());\n}\n```\n\nArtık:\n\n```java\nif (obj instanceof String s) {\n    System.out.println(s.toUpperCase());\n}\n```\n\nTip dönüşümü otomatik olur, kod sadeleşir.  \nSpring AOP veya Reflection tabanlı kodlarda tip kontrolü için kullanışlı.\n\n---\n\n### 199) Switch Expressions _(Java 14+)_\n\nYeni switch ifadesi artık **değer döndürür** ve ok syntax’ı kullanır.\n\n```java\nString gunTipi = switch (gun) {\n    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -\u003e \"Hafta içi\";\n    case SATURDAY, SUNDAY -\u003e \"Hafta sonu\";\n};\n```\n\nYani `switch` artık expression gibi davranıyor.  \nSpring Enum mapping veya status handling için çok uygun.\n\n---\n\n### 200) `var` anahtar kelimesi nedir? _(Java 10+)_\n\n`var`, derleyicinin değişken tipini **otomatik çıkarmasını** sağlar.  \nType inference (tür çıkarımı) yapar.\n\n```java\nvar list = new ArrayList\u003cString\u003e(); // tür: ArrayList\u003cString\u003e\nvar sayi = 10;                      // tür: int\n```\n\nAvantaj: gereksiz tekrar azalır, kod sadeleşir.  \nDezavantaj: tip belirsizse okunabilirlik düşer.  \nSpring Boot config’lerde, builder pattern’lerde sıkça tercih edilir.\n\n---\n\n### 201) `java.time` API’si nedir?\n\nJava 8 ile gelen **modern tarih ve zaman API’si**’dir.  \nEski `Date` ve `Calendar` sınıflarının tüm saçmalıklarını çözer.  \nImmutable’dır, thread-safe’tir, ve `java.time` paketindedir.\n\nTemel sınıflar:\n\n- `LocalDate` → sadece tarih (2025-10-08)\n    \n- `LocalTime` → sadece saat (14:32:10)\n    \n- `LocalDateTime` → tarih + saat\n    \n- `Instant` → UTC tabanlı zaman damgası\n    \n- `ZonedDateTime` → timezone içeren tarih-saat\n    \n\nBu API, Spring Boot’un `@DateTimeFormat`, Jackson `@JsonFormat` anotasyonlarının dayandığı altyapıdır.\n\n---\n\n### 202) `LocalDate`, `LocalTime`, `LocalDateTime` farkı nedir?\n\n|Sınıf|Ne içerir|Örnek|\n|---|---|---|\n|`LocalDate`|Yıl, ay, gün|`2025-10-08`|\n|`LocalTime`|Saat, dakika, saniye|`14:35:42`|\n|`LocalDateTime`|Tarih + saat|`2025-10-08T14:35:42`|\n\nKullanım:\n\n```java\nLocalDate d = LocalDate.now();\nLocalDateTime dt = LocalDateTime.of(2025, 10, 8, 14, 35);\n```\n\nHepsi immutable’dır. `plusDays()`, `minusHours()` gibi metotlarla manipüle edilir.\n\n---\n\n### 203) `Instant` nedir?\n\n`Instant`, zamanın **UTC (epoch)** bazlı temsili.  \nYani “1970-01-01T00:00:00Z”’dan itibaren geçen saniye/nano sayısı.\n\n```java\nInstant now = Instant.now();\nSystem.out.println(now); // 2025-10-08T11:37:00Z\n```\n\n`Instant` → **timestamp (UTC)**  \n`LocalDateTime` → **bölgesel zaman**  \nSpring log’larında, JWT expiration’larda, veritabanı timestamp kolonlarında genelde `Instant` kullanılır.\n\n---\n\n### 204) `ZoneId` ve `ZonedDateTime` nedir?\n\nZaman dilimi yönetimini sağlar.  \n`ZoneId` → zaman dilimini belirtir (`Europe/Istanbul`, `UTC`, `America/New_York`).  \n`ZonedDateTime` → `LocalDateTime` + `ZoneId`.\n\n```java\nZonedDateTime zdt = ZonedDateTime.now(ZoneId.of(\"Europe/Istanbul\"));\nSystem.out.println(zdt);\n```\n\nZaman dilimi dönüşümü:\n\n```java\nZonedDateTime utc = zdt.withZoneSameInstant(ZoneId.of(\"UTC\"));\n```\n\nBu, Spring Boot’ta `@JsonFormat(timezone=\"UTC\")` ayarının teknik karşılığıdır.\n\n---\n\n### 205) `Duration` ve `Period` farkı nedir?\n\n|Sınıf|Birimi|Kullanım amacı|\n|---|---|---|\n|`Duration`|Saat, dakika, saniye|Zaman farkı (Time-based)|\n|`Period`|Gün, ay, yıl|Tarih farkı (Date-based)|\n\n```java\nDuration d = Duration.between(LocalTime.NOON, LocalTime.now());\nPeriod p = Period.between(LocalDate.of(2024,1,1), LocalDate.now());\n```\n\n`Duration` genelde performans ölçümü için;  \n`Period` yaş, vade, abonelik süresi hesaplamalarında kullanılır.\n\n---\n\n### 206) `Date` → `LocalDate` dönüşümü nasıl yapılır?\n\nLegacy (`java.util.Date`) API ile modern `java.time` API birlikte kullanılabiliyor.  \nDönüştürme örnekleri:\n\n```java\nDate date = new Date();\nInstant instant = date.toInstant();\nLocalDateTime ldt = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();\n```\n\nTersine:\n\n```java\nDate fromLdt = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());\n```\n\nSpring Boot’ta genelde Jackson otomatik dönüştürür ama mapper (MapStruct, ModelMapper) yazarken bu bilmek şart.\n\n---\n\n### 207) `DateTimeFormatter` nedir?\n\nTarih/saat biçimlendirmesini sağlar.  \n`SimpleDateFormat`’in modern ve thread-safe versiyonudur.\n\n```java\nDateTimeFormatter fmt = DateTimeFormatter.ofPattern(\"dd-MM-yyyy HH:mm\");\nString formatted = LocalDateTime.now().format(fmt);\n```\n\nAyrıca parse işlemi de yapar:\n\n```java\nLocalDate parsed = LocalDate.parse(\"08-10-2025\", fmt);\n```\n\nBu, Spring Boot’ta `@DateTimeFormat(pattern=\"yyyy-MM-dd\")`’in arka plan mekanizmasıdır.\n\n---\n\n### 208) `parallelStream()` performans kazandırır mı?\n\nCevap: “Bazen evet, bazen hayır.”  \n`parallelStream()` Stream’i **çok çekirdekli CPU’larda paralel yürütür**, ama:\n\n- Küçük listelerde overhead zarar verir.\n    \n- I/O bound işlerde (DB, HTTP) etkisizdir.\n    \n- CPU-bound işler (matematik, dönüşüm) için faydalıdır.\n    \n\nKural:\n\n\u003e Sadece **stateless** ve **yan etkisiz (pure function)** işlemlerle kullan.\n\nSpring Boot servis katmanında genelde `CompletableFuture` tercih edilir, `parallelStream` değil.\n\n---\n\n### 209) Custom Collector nedir?\n\nKendi `Collector`’ını yazabilirsin — özel toplama davranışları tanımlamak için.  \nÖrneğin, Stream sonucu `TreeSet` olarak döndürmek:\n\n```java\nCollector\u003cString, ?, TreeSet\u003cString\u003e\u003e toTreeSet =\n    Collector.of(TreeSet::new, TreeSet::add, (a,b)-\u003e{a.addAll(b); return a;});\n\nTreeSet\u003cString\u003e result = names.stream().collect(toTreeSet);\n```\n\nBu yaklaşım `Collectors.toMap()`’ın davranışını özelleştirmek veya özel DTO gruplama yapmakta çok işe yarar.\n\n---\n\n### 210) `peek()` nedir, ne işe yarar?\n\n`peek()` debugging amaçlı kullanılır — Stream zincirinde ara değerleri görmeni sağlar.\n\n```java\nList\u003cInteger\u003e sonuc = sayilar.stream()\n    .filter(x -\u003e x \u003e 2)\n    .peek(x -\u003e System.out.println(\"Filtre sonrası: \" + x))\n    .map(x -\u003e x * 2)\n    .toList();\n```\n\n`peek()` genellikle loglama/debug içindir, **yan etki yaratmak için değil**.  \nSpring Data Stream’lerinde log debug’ı yaparken çok işine yarar.\n\n---\n\n### 211) Reflection API nedir?\n\nReflection, Java programının **çalışma zamanında (runtime)** kendi sınıflarını, metotlarını, alanlarını incelemesini ve değiştirmesini sağlar.\n\nKısaca: “Kodun kendini sorgulaması.”\n\nÖrnek:\n\n```java\nClass\u003c?\u003e clazz = Class.forName(\"com.example.User\");\nfor (Method m : clazz.getDeclaredMethods()) {\n    System.out.println(m.getName());\n}\n```\n\nReflection sayesinde Spring:\n\n- Bean’leri bulur (`@Component`, `@Service`)\n    \n- Anotasyonları okur (`@Autowired`, `@RequestMapping`)\n    \n- Proxy objeler oluşturur (AOP, Transactional)\n    \n\nAma dikkat: Reflection yavaş ve pahalı bir işlemdir; framework’ler bunu optimize eder.\n\n---\n\n### 212) `Class` nesnesi nedir?\n\nHer Java sınıfının JVM’de bir `Class` nesnesi vardır.  \nBu nesne, sınıfın yapısını temsil eder.\n\nElde etmenin üç yolu:\n\n```java\nClass\u003c?\u003e c1 = String.class;\nClass\u003c?\u003e c2 = \"test\".getClass();\nClass\u003c?\u003e c3 = Class.forName(\"java.lang.String\");\n```\n\n`Class` nesnesiyle:\n\n- Alanlara (`getDeclaredFields`)\n    \n- Metotlara (`getDeclaredMethods`)\n    \n- Constructor’lara (`getDeclaredConstructors`)  \n    erişebilirsin.  \n    Spring Bean taraması da bu nesneyle yapılır.\n    \n\n---\n\n### 213) Reflection ile nesne nasıl oluşturulur?\n\nReflection kullanarak **new** operatörü olmadan da nesne yaratabilirsin.\n\n```java\nClass\u003c?\u003e c = Class.forName(\"com.example.User\");\nObject obj = c.getDeclaredConstructor().newInstance();\n```\n\nBu mekanizma Spring’in **Bean instantiation** sürecinin tam kalbidir.  \nSpring Container, `@Component` veya `@Bean` tanımlı sınıfları böyle üretir.\n\n---\n\n### 214) Field ve Method erişimi nasıl yapılır?\n\nReflection ile private alan ve metotlara bile erişebilirsin.\n\n```java\nField f = User.class.getDeclaredField(\"username\");\nf.setAccessible(true);\nf.set(userObj, \"burak\");\n\nMethod m = User.class.getDeclaredMethod(\"login\");\nm.setAccessible(true);\nm.invoke(userObj);\n```\n\nSpring’in `@Autowired` ile private field’lara bağımlılık enjekte etmesi de tam olarak bu yöntemle yapılır.\n\n---\n\n### 215) Annotation nedir?\n\nAnnotation, derleyiciye veya runtime sistemine **meta bilgi** sağlayan özel yapıdır.  \nYani “koda etiket ekleme” yöntemi.\n\nÖrnek:\n\n```java\n@Service\npublic class UserService { ... }\n```\n\nAnnotation’lar:\n\n- Compile-time’da (`@Override`)\n    \n- Runtime’da (`@Transactional`, `@RestController`)  \n    etkili olabilir.\n    \n\nSpring Boot’un büyük kısmı annotation temellidir — dependency injection, mapping, AOP vs.\n\n---\n\n### 216) Custom Annotation nasıl oluşturulur?\n\nKendi annotation’ını tanımlayabilirsin.\n\n```java\n@Retention(RetentionPolicy.RUNTIME)\n@Target(ElementType.METHOD)\npublic @interface Loggable {\n    String value() default \"DEBUG\";\n}\n```\n\nKullanımı:\n\n```java\n@Loggable(\"INFO\")\npublic void saveUser() { ... }\n```\n\n`RetentionPolicy.RUNTIME` → Reflection ile erişilebilir hale getirir.  \nSpring AOP veya custom logging interceptor’ları tam olarak bu prensiple çalışır.\n\n---\n\n### 217) Meta-annotation’lar nedir?\n\nAnnotation’ları tanımlayan annotation’lardır (evet, meta seviye).\n\nÖrnekler:\n\n- `@Retention` → yaşam süresini belirler (SOURCE, CLASS, RUNTIME)\n    \n- `@Target` → nerede kullanılabileceğini belirler (FIELD, METHOD, TYPE)\n    \n- `@Inherited` → alt sınıfların annotation’ı devralmasını sağlar\n    \n- `@Documented` → javadoc’a eklenmesini sağlar\n    \n\nSpring’in `@Service` ve `@RestController`’ı bile meta-annotated yapılardır (örneğin `@Controller` + `@ResponseBody`).\n\n---\n\n### 218) Spring Framework annotation’ları Reflection ile nasıl işler?\n\nSpring, runtime sırasında:\n\n1. Classpath’i tarar (`ClassLoader` + `Reflection`).\n    \n2. Annotation’ları bulur (`@Component`, `@Configuration`, `@Bean` vs).\n    \n3. Bu bilgilere göre Bean nesneleri oluşturur ve yönetir.\n    \n\nBasitleştirilmiş hali:\n\n```java\nfor (Class\u003c?\u003e cls : scannedClasses) {\n    if (cls.isAnnotationPresent(Component.class)) {\n        context.registerBean(cls);\n    }\n}\n```\n\nYani Spring “büyü” değil, Reflection + Annotation kombinasyonudur.\n\n---\n\n### 219) `@Retention` türleri nelerdir?\n\n|Tür|Açıklama|Kullanım|\n|---|---|---|\n|`SOURCE`|Sadece derleme sırasında kullanılır|`@Override`, `@SuppressWarnings`|\n|`CLASS`|Bytecode’a eklenir ama runtime’da okunmaz|Varsayılan|\n|`RUNTIME`|Runtime’da Reflection ile erişilir|`@Autowired`, `@Service`|\n\nSpring Boot’ta neredeyse tüm annotation’lar `RUNTIME` seviyesindedir, çünkü container onları runtime’da işler.\n\n---\n\n### 220) Dependency Injection (DI) nasıl çalışır?\n\nSpring’in DI sistemi tamamen Reflection’a dayanır:\n\n1. Context sınıfları tarar.\n    \n2. `@Component`, `@Service`, `@Repository` gibi bean’leri bulur.\n    \n3. Constructor, field veya setter üzerindeki `@Autowired`’ı bulur.\n    \n4. Reflection ile o alana bean’i **enjekte eder**.\n    \n\nBasitleştirilmiş örnek:\n\n```java\nfor (Field f : beanClass.getDeclaredFields()) {\n    if (f.isAnnotationPresent(Autowired.class)) {\n        Object dependency = context.getBean(f.getType());\n        f.setAccessible(true);\n        f.set(beanInstance, dependency);\n    }\n}\n```\n\nYani DI sihri = Reflection + Annotation + Bean container.\n\n---\n\n### 221) Proxy nedir?\n\nProxy, bir sınıfın veya nesnenin **araya girilmiş taklididir**.  \nAmaç: Gerçek nesneye erişmeden önce/sonra bir davranış eklemektir.\n\nKısaca:\n\n\u003e “Kodu değiştirmeden davranışını sarmalamak.”\n\nÖrnek:\n\n```java\ninterface Service { void doWork(); }\n\nclass ServiceImpl implements Service {\n    public void doWork() { System.out.println(\"Gerçek iş\"); }\n}\n\nclass ServiceProxy implements Service {\n    private final Service target;\n    ServiceProxy(Service target) { this.target = target; }\n\n    public void doWork() {\n        System.out.println(\"Önce log\");\n        target.doWork();\n        System.out.println(\"Sonra cleanup\");\n    }\n}\n```\n\nSpring AOP tam olarak bunu yapar — ama manuel değil, Reflection ve D","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkalayciburak%2Fjava_mulakat_soru_cevap","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkalayciburak%2Fjava_mulakat_soru_cevap","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkalayciburak%2Fjava_mulakat_soru_cevap/lists"}