<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Özgür Altuğ on Medium]]></title>
        <description><![CDATA[Stories by Özgür Altuğ on Medium]]></description>
        <link>https://medium.com/@ozguraltug06?source=rss-6391bbd52a20------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*iQy_I_5B-QF-rxLa</url>
            <title>Stories by Özgür Altuğ on Medium</title>
            <link>https://medium.com/@ozguraltug06?source=rss-6391bbd52a20------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:48:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ozguraltug06/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Java Mülakat Hazırlık Soruları 4]]></title>
            <link>https://medium.com/@ozguraltug06/java-m%C3%BClakat-haz%C4%B1rl%C4%B1k-sorular%C4%B1-4-26175283fd71?source=rss-6391bbd52a20------2</link>
            <guid isPermaLink="false">https://medium.com/p/26175283fd71</guid>
            <category><![CDATA[mülakat-soruları]]></category>
            <category><![CDATA[java-mülakat-soruları]]></category>
            <category><![CDATA[java-interview-questions]]></category>
            <category><![CDATA[java-mülakat]]></category>
            <category><![CDATA[interview]]></category>
            <dc:creator><![CDATA[Özgür Altuğ]]></dc:creator>
            <pubDate>Tue, 06 Feb 2024 19:21:46 GMT</pubDate>
            <atom:updated>2024-02-06T19:21:46.807Z</atom:updated>
            <content:encoded><![CDATA[<p>Hazırlık aşamasında bilgilerinizi tazeleyecek 20 soruyu da okumalarınıza sunuyorum…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iyxIdSONY4Gq48IZ6qbPyQ.png" /></figure><p><strong>Java Mülakatlara Hazırlık Soruları 4</strong></p><h3>1. Java’da kilit (lock) veya kilitlerin amacı nedir?</h3><p>Kilit (lock), Java’da paylaşılan bir kaynağa birden fazla iş parçacığının erişmesini önlemek için kullanılır. Bir kilidin amacı, paylaşılan bir kaynağa erişmek isteyen bir iş parçacığının, öncelikle o kaynağın kilidini alması ve bu kaynağa erişmek için izin almasıdır. Eğer başka bir iş parçacığı tarafından zaten kilit alınmışsa, o zaman diğer iş parçacığı, bu kaynağa erişmek için beklemek zorunda kalır ve kilidin serbest bırakılmasını bekler.</p><p>Java’da kilit, synchronized anahtar kelimesi veya Lock arabirimini kullanarak elde edilir. Bir nesneyi kilitlemek için synchronized anahtar kelimesi kullanılır ve bu, ilgili kod bloğunun sadece bir iş parçacığı tarafından aynı anda yürütülmesine izin verir.</p><p>Kilitler, kodun belirli bölümlerini koruyarak, sadece bir iş parçacığının aynı anda yürütebileceği şekilde düzenlenir.</p><p>Örneğin:</p><pre>public class SharedResource {<br>private int count = 0;<br>public synchronized void increment() {<br>count++;<br>}<br>public synchronized int getCount() {<br>return count;<br>}<br>}</pre><p>Yukarıdaki örnekte, increment ve getCount metodlarına synchronized anahtar kelimesi uygulanmıştır. Bu, bu metotların aynı anda yalnızca bir iş parçacığı tarafından erişilmesini sağlar ve böylece count değişkenine güvenli bir şekilde erişilir.</p><h3>2. Java’da senkronizasyon (synchronization) yapmanın kaç yolu vardır?</h3><p>Java’da senkronizasyon yapmanın iki temel yolu vardır:</p><p>1. Senkronize metotlar (Synchronized methods)</p><p>2. Senkronize bloklar (Synchronized blocks)</p><p>Senkronizasyon, aynı anda birden fazla iş parçacığının aynı kod bloğuna veya metoda erişmesini engellemek için kullanılır. Senkronizasyon, paylaşılan kaynaklara güvenli bir şekilde erişimi sağlar ve veri bütünlüğünü korur.</p><h3>3. Java’da Senkronize metotlar (synchronized methods) nedir?</h3><p>Senkronize metotlar, Java’da bir nesnenin yönteminin aynı anda yalnızca bir iş parçacığı tarafından erişilmesini sağlamak için kullanılır. Bu, paylaşılan kaynaklara güvenli ve koordineli erişim sağlamak için kullanılır. Senkronize bir metot tanımlamak için synchronized anahtar kelimesi kullanılır.</p><p>Senkronize bir metot tanımlamak için kullanılan imza şu şekildedir:</p><pre>public synchronized void methodName() {<br>// Metot içeriği<br>}</pre><p>Senkronize bir metot çağrıldığında, ilgili nesnenin üzerinde otomatik olarak bir kilidin alınması gerekir. Başka bir deyişle, senkronize bir metot çağrıldığında, o metot üzerindeki kilidin otomatik olarak alınması ve metotun yalnızca tek bir iş parçacığı tarafından aynı anda yürütülmesi sağlanır.</p><p>Senkronize bir metot, yalnızca o metoda ilişkin kilidin serbest olduğu durumda çalışabilir. Eğer bir başka iş parçacığı tarafından o metoda ilişkin kilidin alındığı durumda, diğer iş parçacığı o metoda erişmek için beklemek zorunda kalır. Böylece, senkronize metotlar paylaşılan kaynaklara güvenli bir şekilde erişim sağlar ve veri bütünlüğünü korur.</p><h3>4. Java’da Senkronize metotları ne zaman kullanırız?</h3><p>Java’da senkronize metotlar, birden fazla iş parçacığının aynı nesnenin yöntemine erişmeye çalıştığı durumlarda kullanılır. Özellikle, bir yöntem nesnenin durumunu değiştirebiliyorsa ve bu durumun tutarlılığının korunması gerekiyorsa senkronizasyon kullanılır.</p><p>Örneğin, bir nesnenin belirli bir yöntemi, nesnenin iç durumunu değiştiriyorsa ve birden fazla iş parçacığı bu yönteme aynı anda erişmeye çalışıyorsa, bu durumda senkronize metotlar kullanılabilir. Senkronize bir metot, sadece bir iş parçacığının aynı anda o metoda erişmesine izin verir, böylece nesnenin durumu tutarlı kalır ve beklenmeyen sonuçlar oluşmaz.</p><p>Özetle, senkronize metotlar, bir nesnenin iç durumunu güvenli bir şekilde değiştirmek ve veri bütünlüğünü korumak için kullanılır. Eğer birden fazla iş parçacığı aynı anda bu yönteme erişmeye çalışıyorsa, senkronize bir metot kullanarak bu durumu güvenli bir şekilde ele alabiliriz.</p><h3>5. Java’da bir thread senkronize yöntemleri yürütürken, diğerlerini yürütmek mümkün müdür?</h3><p>Bir thread bir senkronize metodu çalıştırırken, o metot içindeyken diğer threadlerin aynı nesnenin başka senkronize metotlarını aynı anda çalıştırması mümkün değildir. Bu durumda, bir threadin senkronize bir metodu çalıştırması, o nesnenin üzerinde kilidi alır ve bu nesnenin başka senkronize metotlarına diğer threadlerin erişimini engeller.</p><p>Senkronize metotlar, bir nesnenin belirli bir kısmını tek bir thread tarafından aynı anda işlenmesini sağlamak için kullanılır. Dolayısıyla, bir threadin bir senkronize metodu çalıştırırken, o nesnenin diğer senkronize metotlarını başka threadlerin aynı anda çalıştırmasına izin verilmez.</p><p>Bu mekanizma, veri bütünlüğünü sağlamak ve senkronizasyonu yönetmek için kullanılır. Eğer birden fazla thread aynı nesneyi değiştirmeye çalışıyorsa, senkronizasyon olmadan beklenmedik sonuçlar oluşabilir. Bu nedenle, senkronize metotlar ve diğer senkronizasyon mekanizmaları, paylaşılan kaynaklara güvenli bir şekilde erişmek için önemlidir.</p><h3>6. Java’da senkronize bloklar nelerdir?</h3><p>Java’da senkronize bloklar, sadece belirli kod satırlarını veya kod bloklarını senkronize etmek için kullanılır. Bununla birlikte, tüm bir metodu senkronize etmek yerine, yalnızca belirli bir kod parçasını senkronize etmek istediğimiz durumlarda kullanılırlar.</p><p>Senkronize bir blok tanımlamak için synchronized anahtar kelimesi kullanılır. Senkronize blokun içine girildiğinde, belirtilen nesnenin kilidi alınır ve bu nesne üzerindeki diğer senkronize bloklara ve senkronize metotlara erişim engellenir. Senkronize bloklar, aynı anda yalnızca bir iş parçacığının belirli kod bloğuna erişmesini sağlar.</p><p>Senkronize bir bloğun imzası şu şekildedir:</p><pre>synchronized (objectReference) {<br>// Senkronize edilecek kod bloğu<br>}</pre><p>objectReference, senkronize bloğun kilidini alacak nesneyi belirtir. Bu nesne, senkronize edilen kod bloğuna aynı anda erişmeye çalışan tüm iş parçacıkları için bir referans noktası sağlar. Genellikle, bu nesne, paylaşılan bir kaynağı temsil eden bir nesnedir.</p><h3>7. Senkronize blokları ne zaman kullanırız ve senkronize blok kullanmanın avantajları nelerdir?</h3><p>Eğer çok az kod satırı senkronize edilmesi gerekiyorsa, o zaman senkronize blokların kullanılması önerilir. Senkronize blokların senkronize metotlara göre başlıca avantajı, bekleyen iş parçacıklarının bekleme süresini azaltması ve sistem performansını artırmasıdır.</p><p>Senkronize bloklar, yalnızca belirli bir kod bloğunu senkronize etmek için kullanılır. Bu, senkronizasyon gerektiren kodun sadece küçük bir kısmının senkronize edilmesine olanak tanır. Bu durum, senkronize blokların senkronize metotlara göre daha esnek olmasını sağlar.</p><p>Senkronize blokların avantajları şunlardır:</p><p>• Esneklik: Senkronize bloklar, sadece belirli kod parçalarını senkronize etmemize olanak tanır. Böylece, senkronizasyonu yalnızca ihtiyaç duyulan yerlerde uygulayabiliriz.</p><p>• Daha Az Bekleme Süresi: Senkronize bloklar, senkronize metotlara göre daha küçük kilitlenme alanlarına sahiptir. Bu, diğer iş parçacıklarının belirli bir bloğa erişimini beklerken daha az bekleme süresi geçirilmesini sağlar.</p><p>• Performans Artışı: Senkronize bloklar, senkronize edilmesi gereken kod bloğunun tamamını senkronize etmek yerine, yalnızca belirli bir bölümünü senkronize eder. Bu, iş parçacıklarının daha az kilitlenme durumu yaşamasını sağlar ve böylece genel performansı artırır.</p><p>Özet olarak, senkronize bloklar, senkronizasyon gereksinimlerini daha hassas bir şekilde kontrol etmek ve performansı artırmak için kullanılır. Bu nedenle, çok az kodun senkronize edilmesi gerektiğinde veya senkronizasyonun sadece belirli bir kod bloğunda uygulanması gerektiğinde senkronize bloklar tercih edilir.</p><h3>8. Java’da class düzeyi kilit nedir?</h3><p>Sınıf seviyesi kilidi (class level lock), bir sınıfın örneği yerine sınıfın kendisi üzerinde kilidi almayı ifade eder. Sınıf seviyesi kilidi, bir sınıfın tüm örneklerine uygulanır ve bu nedenle sınıfın tüm örneklerine erişen threadlerin senkronize edilmesini sağlar.</p><p>Sınıf seviyesi kilidi ile nesne seviyesi kilidi arasındaki fark şudur: Sınıf seviyesi kilidi, sınıfın kendisi üzerinde alınırken, nesne seviyesi kilidi, sınıfın belirli bir örneği üzerinde alınır.</p><p>Örneğin, bir sınıf seviyesi kilidi aşağıdaki gibi tanımlanabilir:</p><pre>public class MyClass {<br>public static synchronized void myStaticMethod() {<br>// Class level lock, sınıfın tüm örneklerine uygulanır<br>}<br>}</pre><p>Burada, myStaticMethod metodu static olarak tanımlanmış ve synchronized anahtar kelimesiyle işaretlenmiştir. Bu nedenle, bu metoda erişen tüm iş parçacıkları, sınıf seviyesi kilidi üzerinde senkronize edilirler.</p><p>Sınıf seviyesi kilidi, genellikle paylaşılan kaynaklara erişim sağlamak ve veri bütünlüğünü korumak için kullanılır. Bununla birlikte, sınıf seviyesi kilidinin kullanımı, gereksinimlere ve uygulamanın doğasına bağlı olarak değişir.</p><h3>9. Java’daki statik metodları senkronize edebilir miyiz?</h3><p>Java’da static metotları senkronize edebiliriz. Her sınıfın bir kilidi (lock) vardır ve bir thread, statik bir senkronize yöntemi çalıştırmak istiyorsa önce sınıf seviyesindeki kilidi elde etmelidir. Bir thread, statik bir senkronize yöntemini yürütürken, diğer bir thread aynı sınıfın statik senkronize yöntemini çalıştıramaz çünkü kilidin sınıf üzerinde alınmış olması gereklidir.</p><p>Ancak, aynı anda aşağıdaki yöntemlerin çalıştırılmasına izin verilir:</p><p>Normal static methods</p><p>Normal instance methods</p><p>Senkronize instance methods</p><p>Bir sınıf seviyesi kilidi almak için kullanılan imza şu şekildedir:</p><pre>synchronized(ClassAdı.class) {<br>// Kod bloğu<br>}</pre><p>Bu yapı, sınıfın kendisi üzerinde bir kilidin alınmasını sağlar. Bu, sınıfın tüm örneklerine aynı anda erişimi kontrol etmek için kullanılır ve sınıf seviyesinde senkronizasyon sağlar.</p><h3>10. Primitive için senkronize bloğu kullanabilir miyiz?</h3><p>Java’da senkronize bloklar yalnızca nesneler için geçerlidir. Senkronize bloklar, belirli bir nesne üzerinde senkronize edilir ve bu nesne, senkronizasyonun gerçekleştirildiği kilit mekanizmasını sağlar.</p><p>Eğer senkronize blokları ilkel veri türleri için kullanmaya çalışırsak, derleme zamanında hata alırız. Çünkü senkronize bloklar yalnızca nesneler üzerinde çalışır ve ilkel veri türleri nesne değildir.</p><p>Örneğin, aşağıdaki kod derleme zamanında hata verecektir:</p><pre>int counter = 0;<br>synchronized(counter) {<br>// Kod bloğu<br>}</pre><p>Çünkü counter bir ilkel veri türüdür (int) ve senkronize bloklar yalnızca nesneler üzerinde çalışır. Dolayısıyla, senkronize blokları ilkel veri türleriyle kullanmaya çalıştığımızda derleme zamanında hata alırız.</p><h3>11. Java’da threadlerin öncelikleri ve önceliklerinin önemi nelerdir?</h3><p>Thread prioriteleri, bekleyen birçok thread arasında hangi threadin çalıştırılacağını belirler. Java programlama dilinde her threadin bir önceliği vardır. Bir thread, ebeveyn threadin önceliğini miras alır. Varsayılan olarak, bir thread normal bir önceliğe sahiptir.</p><p>Thread planlayıcısı (thread scheduler), her threadin ne zaman çalıştırılacağına karar vermek için threadin önceliklerini kullanır. Thread planlayıcısı, daha yüksek öncelikli threadi önce çalıştırır.</p><p>Thread prioriteleri, sistemdeki threadlerin çalışma sırasını belirlemekte ve öncelikli threadlerin daha hızlı yanıt vermesini sağlamakta önemlidir. Ancak, thread prioritelerinin mutlak davranışları, Java’nın çalıştığı platforma ve JVM’in yapılandırmasına bağlı olabilir. Bu nedenle, thread prioritelerini kullanırken dikkatli olunmalı ve platform bağımlılıkları göz önünde bulundurulmalıdır.</p><h3>12. Farklı threadlerin öncelik türlerini açıklayın?</h3><p>Java’da her threadin öncelikleri 1 ile 10 arasındadır. Varsayılan olarak, bir threadin önceliği 5&#39;tir (Thread.NORM_PRIORITY olarak adlandırılır). Maksimum öncelik 10, minimum öncelik ise 1&#39;dir. Thread sınıfı aşağıdaki sabitleri (static final değişkenler) özelliklerini tanımlamak için tanımlar:</p><pre>Thread.MIN_PRIORITY = 1; En düşük öncelik değeri<br>Thread.NORM_PRIORITY = 5; Normal öncelik değeri (varsayılan)<br>Thread.MAX_PRIORITY = 10; En yüksek öncelik değeri</pre><p>Öncelik değerleri, threadlerin çalışma sırasını belirler. Öncelik daha yüksek olan threadleri, öncelikleri daha düşük olanlardan önce çalıştırılır. Ancak, işletim sistemi ve JVM’nin uygulama davranışını etkileyebilecek faktörler olduğunu unutmamak önemlidir. Bu nedenle, thread önceliklerini ayarlamak ve kullanmak programcıların dikkat etmesi gereken bir konudur.</p><h3>13. Threadin önceliği nasıl değiştirilir veya threadin önceliği nasıl ayarlanır?</h3><p>Thread sınıfı, threadin önceliğini ayarlamak için bir set metodu ve threadin önceliğini almak için bir get metodu içerir.</p><p>İşte öncelik ayarlamak için kullanılan setPriority metodunun imzası:</p><p>final void setPriority(int value);</p><p>setPriority() metodu, threadin önceliğini ayarlamak için JVM’e bir istek gönderir. Ancak, JVM bu isteği kabul edip etmeme konusunda serbesttir.</p><p>Ayrıca, mevcut threadin önceliğini almak için Thread sınıfının getPriority() metodunu kullanabiliriz:</p><p>final int getPriority();</p><p>Bu metodun çağrılması, mevcut threadin öncelik değerini döndürür.</p><p>Özetlemek gerekirse, setPriority() metoduyla bir threadin önceliğini ayarlayabilir ve getPriority() metoduyla mevcut threadin önceliğini alabiliriz. Ancak, threadin önceliğini ayarlamak, işletim sistemi ve JVM tarafından belirli koşullara bağlı olduğu için kesin bir sonuç garanti edilmez.</p><h3>14. İki threadin önceliği aynıysa hangi thread önce yürütülür?</h3><p>Eğer eşit önceliğe sahip iki thread varsa, hangi threadin önce çalıştırılacağı konusunda garanti verilemez. Bu durum, thread planlayıcısına, hangi threadin çalıştırılacağına karar verme yetkisi verir. Thread planlayıcısı şu işlemleri yapabilir:</p><p>Havuzdaki herhangi bir threadi seçip çalıştırabilir ve tamamlanana kadar onu çalıştırabilir.</p><p>Zaman dilimlemesi (time slicing) yöntemiyle tüm iş parçacıklarına eşit fırsatlar verebilir.</p><p>Yani, eğer eşit önceliğe sahip iki thread varsa, hangisinin önce çalıştırılacağı işletim sistemine ve thread planlayıcısının belirlediği faktörlere bağlıdır. Bu nedenle, öncelikler eşit olduğunda hangi threadin öncelikli olduğunu kesin olarak söylemek mümkün değildir.</p><h3>15. Threadin yürütülmesini önlemek, durdurmak için hangi yöntemler kullanılır?</h3><p>Thread’lerin çalışmasını durduran üç yöntem vardır:</p><p>1. yield(): Bir threadin çalışmasını durdurarak, thread planlayıcısına diğer threadlere öncelik vermesi için bir işarettir. Ancak, bu sadece bir öneridir ve thread planlayıcısı, threadnın çalışmasını durdurup durdurmayacağına karar verir.</p><p>2. join(): Bir threadin diğer bir threadi tamamlanmasını beklemesini sağlar. Örneğin, bir threadin diğer bir threadin tamamlanmasını beklemesi gereken senaryolarda kullanılır.</p><p>3. sleep(): Belirli bir süre boyunca bir threadi uyutur. Bu işlem, belirli bir süre boyunca threadin çalışmasını durdurur ve sonra tekrar devam eder.</p><p>Bu yöntemler, threadlerin kontrolünü sağlamak ve senkronizasyonu düzenlemek için kullanılır.</p><h3>16. Java’da thread sınıfında yield() metodunu açıklayınız?</h3><p>yield() yöntemi, mevcut çalışan threadi bekleyen durumundaki diğer eşit önceliğe sahip threadlere fırsat vermek için çalışma durumundan Runnable durumuna geçirir. yield(), mevcut threadi belirli bir süre için uyutmak için kullanılmaz. Mevcut çalışan threadin çalışma durumunu Runnable durumuna geçirir, böylece thread planlayıcısı diğer eşit önceliğe sahip threadleri çalıştırmak için seçenek sahibi olur.</p><p>Ancak, yield() yöntemini çağırmak, threadin bir kilitleme durumunda olduğunda herhangi bir etkiye sahip değildir. Eğer bir thread daha önce bir kilidi almışsa, yield() yöntemi threadin kilidini kaybetmesine neden olmaz.</p><p>Yani, yield() yöntemi, mevcut threadi diğer eşit önceliğe sahip threadlere fırsat vermek için Runnable durumuna geçirir. Ancak, bu durumun işleyişi, thread planlayıcısına bağlıdır ve kesinlikle garantilenmez.</p><h3>17. yield() yöntemi kullanılan threadin tekrar çalıştırılma şansını yakalaması mümkün mü?</h3><p>yield() metodu, mevcut threadi belirli bir süre için uyutmak ve eşit önceliğe sahip diğer iş parçacıklarının çalışmasına fırsat vermek için kullanılır. Ancak, yield() metodunun çağrılmasından sonra uyuyan threade tekrar çalışma fırsatı verilip verilmeyeceği, thread planlayıcısına bağlıdır.</p><p>Yani, yield() yöntemi çağrıldıktan sonra uyuyan threadin tekrar çalışma fırsatı alıp almayacağı tamamen thread planlayıcısının insafına bağlıdır. Thread planlayıcısı, uygun olduğunu düşündüğü zamanda uyuyan threadi tekrar çalıştırabilir veya başka bir threade öncelik verebilir. Dolayısıyla, yield() yöntemi çağrıldıktan sonra uyuyan threadin tekrar çalışma fırsatı alıp almayacağı, thread planlayıcısının takdirine bağlıdır.</p><h3>18. Java’da thread sınıfında join() yönteminin önemini açıklayınız?</h3><p>Thread sınıfındaki join() yönteminin önemi şudur:</p><p>Bir thread, diğer bir threadin tamamlanmasını beklemek için join() yöntemini çağırabilir. Örneğin, t1 ve t2 adında iki thread olduğunu varsayalım. Çalışan bir thread t1, join() yöntemini t2 thread üzerinde çağırırsa, t1 thread t2&#39;nin tamamlanmasını bekler ve bu süre boyunca bekleyen durumunda kalır. t2 thread tamamladığında, t1 thread çalışmasını sürdürür.</p><p>join() yöntemi, bir threadin başka bir threadi tamamlanmasını beklemesini sağlar. Ancak, join() yöntemi, Interrupted Exception (Kesinti İstisnası) fırlatabilir. Dolayısıyla, join() yöntemini kullanırken Interrupted Exception’ı yönetmek için try-catch bloğu veya throws kullanarak istisnai durumları ele almak önemlidir.</p><p>join() yönteminin imzaları şunlardır:</p><p>public final void join() throws InterruptedException {}</p><p>public final synchronized void join(long millis) throws InterruptedException {}</p><p>public final synchronized void join(long millis, int nanos) throws InterruptedException {}</p><p>Bu yöntemler, threadin belirli bir süre veya süre ve nanosaniye cinsinden beklemesini sağlar.</p><h3>19. Java’da thread sınıfında sleep() yönteminin amacını açıklayınız?</h3><p>sleep() yöntemi, mevcut çalışan threadi belirli bir süre için uyutmak için kullanılır. sleep() yöntemi, mevcut threadin çalışmasını belirtilen süre boyunca duraklatır. Ancak, sleep() yöntemi, mevcut threadin tam olarak belirtilen süre boyunca uyumasını garanti etmez. Belirtilen sürenin alt sınırıdır ve thread uyandırıldığında, belirtilen süreden önce uyanabilir.</p><p>sleep() yönteminin imzaları şunlardır:</p><p>public static native void sleep(long millis) throws InterruptedException {}</p><p>public static void sleep(long millis, int nanos) throws InterruptedException {}</p><p>İlk imzada, sadece millisaniye cinsinden bir süre belirtilir ve thread bu süre boyunca uyur. İkinci imzada, millisaniye ve nanosaniye cinsinden bir süre belirtilir. Bu yöntemler, mevcut threadi belirtilen süre boyunca uyutur ve belirli bir süre boyunca çalışmasını duraklatır.</p><h3>20. sleep() yöntemi başka bir threadin uyumasına neden olabilir mi?</h3><p>Hayır, sleep() yöntemi sadece mevcut threadi uyutmak için kullanılır, başka bir threadi uyutmaz. sleep() yöntemi, sadece çağrıldığı threadi belirli bir süre boyunca uyutmak için kullanılır. Diğer threadler üzerinde herhangi bir etkisi yoktur.</p><p>Bir işlem (process), bir programın yürütülen halidir. Yani, bir uygulama başlatıldığında, bu uygulama bir işlem olarak adlandırılır. Her işlem, kendi bellek alanına (adres alanına) sahiptir, bu nedenle bir işlem kendi veri, kod ve çalışma zamanı verilerini içerir.</p><p>İşlemler genellikle ağır işlemlerdir çünkü her biri kendi bellek alanını, kaynaklarını, ve diğer işletim sistemi kaynaklarını kullanır. İşlemler arasında izolasyon sağlamak için ayrı ayrı çalışırlar. Eğer bir işlem çökerse, diğer işlemler bundan etkilenmez.</p><p>İşlemler genellikle bir veya daha fazla “thread”(işlem parçacığı) içerir. Bir “thread”, bir işlem içindeki bir yürütme yolunu temsil eder. İşlemin içindeki thread’ler, aynı bellek alanını paylaşır, bu nedenle aynı işlem içindeki thread’ler birbirleriyle veri paylaşabilirler.</p><p>Bu nedenle, bir işlem, bir programın yürütülen hali olarak düşünülebilir ve bu işlem, kendi bellek alanına ve kaynaklara sahip, bağımsız bir yürütme birimidir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26175283fd71" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java Mülakat Hazırlık Soruları 3]]></title>
            <link>https://medium.com/@ozguraltug06/java-m%C3%BClakat-haz%C4%B1rl%C4%B1k-sorular%C4%B1-3-f1673b15e9ad?source=rss-6391bbd52a20------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1673b15e9ad</guid>
            <category><![CDATA[java-mülakat]]></category>
            <category><![CDATA[java-thread]]></category>
            <category><![CDATA[java-interview-questions]]></category>
            <category><![CDATA[java-sorular]]></category>
            <category><![CDATA[java-mülakat-soruları]]></category>
            <dc:creator><![CDATA[Özgür Altuğ]]></dc:creator>
            <pubDate>Sun, 24 Dec 2023 14:45:49 GMT</pubDate>
            <atom:updated>2023-12-24T14:49:34.137Z</atom:updated>
            <content:encoded><![CDATA[<p>Soruların 20 şerli olması okunmasını ve çalışılmasını kolaylaştırır düşüncesi ile yeni 20 soruluk bölümü paylaşıyorum…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QDS-JYntheaNoK9HyTz74w.png" /></figure><h3>1. Process (işlem) nedir?</h3><p>Bir işlem (process), bir programın yürütülen halidir. Yani, bir uygulama başlatıldığında, bu uygulama bir işlem olarak adlandırılır. Her işlem, kendi bellek alanına (adres alanına) sahiptir, bu nedenle bir işlem kendi veri, kod ve çalışma zamanı verilerini içerir.</p><p>İşlemler genellikle ağır işlemlerdir çünkü her biri kendi bellek alanını, kaynaklarını, ve diğer işletim sistemi kaynaklarını kullanır. İşlemler arasında izolasyon sağlamak için ayrı ayrı çalışırlar. Eğer bir işlem çökerse, diğer işlemler bundan etkilenmez.</p><p>İşlemler genellikle bir veya daha fazla “thread”(işlem parçacığı) içerir. Bir “thread”, bir işlem içindeki bir yürütme yolunu temsil eder. İşlemin içindeki thread’ler, aynı bellek alanını paylaşır, bu nedenle aynı işlem içindeki thread’ler birbirleriyle veri paylaşabilirler.</p><p>Bu nedenle, bir işlem, bir programın yürütülen hali olarak düşünülebilir ve bu işlem, kendi bellek alanına ve kaynaklara sahip, bağımsız bir yürütme birimidir.</p><h3>2. Java’da thread (iş parçacığı) nedir?</h3><p>Thread, bir programın içindeki ayrı bir yürütme yolu ya da işlevidir. Her thread, programın içinde bağımsız bir yürütme akışını temsil eder.</p><p>İş Parçacıkları Hafif (Lightweight) ve Aynı Adres Alanını Paylaşır:</p><p>Threadleri, hafif yani düşük kaynak tüketen yürütme birimleridir. Bir programın içindeki iş parçacıkları aynı adres alanını paylaşırlar, bu da demektir ki aynı bellek alanını kullanabilirler.</p><p>Thread Oluşturmak, İşlem Oluşturmaktan Daha Basittir:</p><p>Thread oluşturmak, işlemleri oluşturmaktan daha basittir çünkü iş parçacıkları daha az kaynak tüketirler. Bu nedenle, bir program içinde yeni bir thread oluşturmak daha hızlı ve daha etkili bir yöntemdir.</p><p>Threadler Bir İşlem İçinde Varlığını Sürdürür:</p><p>Bir işlem (process) en az bir thread içerir. Yani, bir program çalıştığında, en az bir thread bulunur. Threadleri, bir işlem içinde varlığını sürdürür ve bu işlemin içinde birbirleriyle etkileşimde bulunabilirler.</p><p>Threadleri, eş zamanlılık ve çok görev yetenekleri sağlayarak programların daha etkili ve hızlı çalışmasına katkıda bulunurlar. Bu nedenle, Java ve diğer çoklu görev destekleyen programlama dillerinde threadler önemli bir kavramdır.</p><h3>3. İşlem (Process) ve İş parçacığı (Thread) arasındaki farklar nelerdir?</h3><p>process</p><p>thread</p><p>Yürütülen bir programdır.</p><p>Program içinde ayrı bir yürütme yolunu temsil eder. Bir veya daha fazla threade sahip olabilir ve bu bir veya daha fazla thread bir işlemi oluşturur.</p><p>İşlemler daha ağırdır</p><p>Threadler daha hafiftir.</p><p>İşlemler, kendi bağımsız adres alanlarına sahiptir.</p><p>Threadler, aynı işlem içinde aynı adres alanını paylaşır.</p><p>İşlemler arasındaki iletişim genellikle maliyetlidir.</p><p>Threadler arasındaki iletişim, işlemlere göre daha az maliyetlidir.</p><p>İşlemler arasında bağlam değiştirmek maliyetlidir.</p><p>Threadler arasında bağlam değiştirmek daha düşük maliyetlidir.</p><h3>4. Çoklu görev (multitasking) nedir?</h3><p>Çoklu görev, bilgisayar kullanımında aynı anda birden fazla işlemi gerçekleştirme anlamına gelir. Örneğin, bir elektronik tablo programını kullanırken aynı anda bir hesap makinesi uygulamasını da kullanmak gibi. Bu, bilgisayarın kaynaklarını etkili bir şekilde kullanarak kullanıcılara farklı görevleri aynı anda yerine getirme yeteneği sağlar. Bu, iş verimliliğini artırabilir ve kullanıcıların daha efektif bir şekilde çalışmasına olanak tanır.</p><h3>5. Çoklu görev (multitasking) türleri nelerdir?</h3><p>Çoklu görevin farklı türleri şunlardır:</p><p><em>1.İşlem Tabanlı Çoklu Görev (Process Based Multitasking):</em></p><p>Bu tür çoklu görev, iki veya daha fazla programın aynı anda çalıştırılmasına olanak tanır.</p><p>İşlem tabanlı çoklu görevde, bir işlem, kodun en küçük parçasını temsil eder.</p><p>Örnek: Ms Word ve Ms PowerPoint programlarını aynı anda çalıştırmak.</p><p><em>2.Thread Tabanlı Çoklu Görev (Thread Based Multitasking):</em></p><p>Bu tür çoklu görev, bir programın farklı parçalarının aynı anda çalıştırılmasına olanak tanır.</p><p>Thread tabanlı çoklu görevde, bir programın farklı işlevsel parçaları olan iş parçacıkları aynı anda çalışabilir.</p><p>Örnek: Bir belgedeki metni biçimlendirirken aynı anda belgeyi yazıcıya göndermek.</p><p>Java, thread tabanlı çoklu görevi destekler ve çoklu threadlere dahili destek sağlar.</p><h3>6. Multithread(çoklu iş parçacıklı) programlamanın avantajları nelerdir?</h3><p>Çoklu iş parçacıklı programlama, CPU’nun boş zamanını başka bir thread kullanma imkanı sağlar ve bu da programın daha hızlı bir şekilde çalışmasına neden olur. Tek iş parçacıklı bir ortamda her görevin tamamlanması gerektiği için bir sonraki göreve geçilmeden önce CPU boşta bekler.</p><p>Örneğin, bir programda tek bir thread kullanılıyorsa, bir görevin tamamlanması beklenmeden bir sonraki görev başlatılamaz. Bu durumda CPU, bir görevin tamamlanmasını beklerken boşta durur ve bu süre içinde başka bir iş yapmaz. Ancak çoklu iş parçacıklı bir programda, bir thread bir görevle meşgulken diğer iş parçacıkları boşta kalan CPU zamanını değerlendirebilir ve başka görevleri gerçekleştirebilir. Bu, işlemcinin daha etkin bir şekilde kullanılmasına olanak tanır ve programın daha hızlı çalışmasını sağlar.</p><h3>7. Java’da thread (iş parçacığı) kavramını açıklayınız?</h3><p>Thread Nedir?</p><p>Bir program içinde bağımsız bir yürütme yolunu temsil eder. Yani, bir program içinde ayrı bir çalışma akışını ifade eder.</p><p>İş parçacıkları, programın içinde aynı anda birden fazla görevi yerine getirmesine olanak tanır.</p><p>Thread Yapısı:</p><p>Bir thread, üç ana bölümden oluşur: Sanal CPU (Virtual CPU), kod ve veri.</p><p>Sanal CPU, threadin yürütme sürecini kontrol eden sanal bir işlemciyi temsil eder.</p><p>Kod, threadin yürütülen programı ifade eder.</p><p>Veri, threadinn kullanımındaki bellek alanını temsil eder.</p><p>Çalışma Zamanında Paylaşım:</p><p>Çalışma zamanında, iş parçacıkları aynı kodu ve veriyi paylaşır; yani, aynı adres alanını kullanırlar.</p><p>Bu, iş parçacıklarının birbirleriyle iletişim kurmasını ve veri paylaşmasını sağlar.</p><p>Java’da Thread:</p><p>Java’da her thread, “java.lang.Thread” sınıfının bir nesnesidir.</p><p>Java, multi threade olanak tanıyan bir programlama dilidir ve thread oluşturmak ve yönetmek için Java’da özel destek sağlanmıştır.</p><h3>8. Java’da threadi destekleyen API lar nelerdir?</h3><p>java.lang.Thread:</p><p>Thread sınıfını kullanarak bir thread oluşturmanın bir yoludur. Thread sınıfını genişleterek ve run() metodunu override ederek bir thread oluşturulabilir.</p><p>java.lang.Runnable:</p><p>Java’da bir arayüz olan Runnable’ı uygulayarak ve run() metodunu override ederek bir thread oluşturmanın başka bir yoludur.</p><p>java.lang.Object:</p><p>Object sınıfı, tüm Java sınıflarının üst sınıfıdır. Bu sınıfta yer alan wait(), notify() ve notifyAll() gibi metodlar, iş parçacıkları arasında senkronizasyonu sağlamak için kullanılır.</p><p>java.util.concurrent:</p><p>Bu paket, eş zamanlı programlamayı destekleyen sınıf ve arabirimleri içerir.</p><p>Örneğin, Executor arabirimi ve FutureTask sınıfı gibi sınıflar, çoklu iş parçacıklarını daha etkili bir şekilde yönetmeye yardımcı olur.</p><p>Bu API’lar, Java dilinde çoklu thread programlamasını kolaylaştırmak ve yönetmek için kullanılır. “java.lang.Thread” ve “java.lang.Runnable” gibi temel sınıflar, iş parçacıkları oluşturmak ve yönetmek için kullanılan temel araçlardır. “java.util.concurrent” paketi ise daha gelişmiş çoklu thread programlama özelliklerini sunar.</p><h3>9. Java’da “main thread” (ana thread) kavramını açıklayınız?</h3><p>Main thread, bir program başlatıldıktan hemen sonra başlayan ilk threaddir(. Main thread’in önemli olmasının nedenleri şunlardır:</p><p>Tüm Alt Threadler Ana Threadden Oluşturulur:</p><p>Program başladığında, main thread otomatik olarak oluşur ve bu main threadden tüm diğer threadler türetilir.</p><p>Main Metodu, Yürütmenin Son Threadidir:</p><p>Java programları genellikle main metodunu içerir. Main metodunun tamamlanması, programın yürütmesinin sona ermesi anlamına gelir.</p><p>Diğer tüm iş parçacıkları main threadden türetildiği için, main thread tamamlandığında diğer threadler de sona erer.</p><p>JVM, main Metodunu Çağırarak Yeni Bir Thread Başlatır:</p><p>JVM (Java Virtual Machine), bir Java programını çalıştırdığında, main metodunu çağırarak yeni bir thread başlatır.</p><p>main() metodunun içindeki kodlar çalışmaya başlar, ancak bu sırada JVM, yeni bir thread oluşturur ve bu yeni thread üzerinden programın geri kalanını yürütür.</p><p>Bu nedenle, main() metodunun içindeki kodlar çalışırken, aslında ana thread geçici bir süre duraklar ve yeni thread çalışmaya başlar.</p><p>Java programları genellikle çoklu thread kullanımını destekler ve main thread, programın başladığı noktadır ve diğer iş parçacıklarının temelini oluşturur. Bu, programın eşzamanlı ve etkili bir şekilde çalışmasını sağlamak için kullanılır.</p><h3>10. Java’da iş parçacıkları (threads) oluşturmanın kaç yolu vardır?</h3><p>Java’da iş parçacıkları (threads) oluşturmanın iki temel yolu vardır.</p><p>1.Thread Sınıfını Extend etme:</p><p>Bir thread oluşturmanın bir yolu, Thread sınıfını extend ederek yeni bir sınıf oluşturmaktır.</p><p>Bu sınıf, Thread sınıfından türetilir ve run metodunu override ederek threadin ana mantığını tanımlar.</p><p>Örneğin:</p><pre>public void run() {<br>// Threadin ana mantığı burada tanımlanır.<br>}<br>}<br>// Threadi başlatmak için<br>MyThread myThread = new MyThread();<br>myThread.start();</pre><p>Runnable Arayüzünü Uygulayarak:</p><p>Başka bir yol, Runnable arayüzünü implemets ederek bir thread oluşturmaktır.</p><p>Runnable arayüzü, run metodunu içeren bir arayüzdür. Bu metod, threadin ana mantığını içerir.</p><p>Yeni bir sınıf oluşturulur ve bu sınıf Runnable arayüzünü implements eder. Ardından, bir örneği oluşturulan bu sınıf, bir Thread nesnesine parametre olarak verilerek çalıştırılır.</p><p>Örneğin:</p><pre>public class MyRunnable implements Runnable {<br>public void run() {<br>// Threadin ana mantığı burada tanımlanır.<br>}<br>}<br>// Threadi başlatmak için<br>Thread myThread = new Thread(new MyRunnable());<br>myThread.start();</pre><p>Bu iki yöntem de thread oluşturmanın yaygın ve temel yollarını temsil eder.</p><h3>11. Thread oluşturmanın en iyi yolu hangisidir?</h3><p>Java’da thread oluşturmanın en iyi yaklaşımı genellikle Runnable arabirimini uygulamaktır. Nedeni şu şekildedir:</p><p>Esneklik:</p><p>Runnable arabirimini uygulayarak thread oluşturmak, sınıfınızın başka bir sınıfı genişletmesine olanak tanır.</p><p>Java’da çoklu kalıtım desteklenmez, bu nedenle Thread sınıfını genişlettiğinizde başka bir sınıfı genişletemezsiniz. Bu durum, sınıfınızın özellikle başka bir sınıfı genişletmesi gerektiğinde sorun yaratabilir.</p><p>Arayüz Odaklı Programlama:</p><p>Runnable arabirimini uygulamak, arayüz odaklı programlamayı teşvik eder. Bu, sınıflar arasındaki bağımlılığı azaltır ve kodun daha modüler olmasını sağlar.</p><p>Thread Pool ve Executor Framework:</p><p>Java’da Runnable arayüzünü uygulayan sınıfları kullanarak, Executor framework ve thread pool gibi gelişmiş çoklu thread yönetim araçlarından daha iyi yararlanabilirsiniz.</p><p>Kodun Daha Okunabilir Olması:</p><p>Runnable arayüzünü uygulamak, kodun daha okunabilir ve bakımı daha kolay olmasını sağlar.</p><p>Örnek:</p><pre>public class MyRunnable implements Runnable {<br>@Override<br>public void run() {<br>// Threadin ana mantığı burada tanımlanır.<br>}<br>}<br>// Threadi başlatmak için<br>Thread myThread = new Thread(new MyRunnable());<br>myThread.start();</pre><p>Yukarıdaki örnekte, MyRunnable sınıfı, Runnable arabirimini uygular ve yeni bir thread başlatmak için Thread sınıfını kullanır. Bu, kodun daha esnek ve okunabilir olmasını sağlar.</p><h3>12. Java’da thread scheduler’ın önemini açıklayınız?</h3><p>Thread scheduler (thread planlayıcısı), JVM’in bir anda birden fazla thread olduğunda hangi threadin çalıştırılacağını belirlemek için kullandığı bir bölümdür. Sadece “runnable” (çalışabilir) durumdaki iş parçacıkları, thread scheduler tarafından seçilir.</p><p>Thread scheduler, öncelikli olan iş parçacıklarına önce mikroprosesör zamanı tahsis eder. Aynı önceliğe sahip iş parçacıkları arasında mikroprosesör zamanını tahsis etmek için ise thread scheduler round robin (dönüş sırası) yöntemini takip eder.</p><p>Önemli Noktalar:</p><p>Öncelikli İş Parçacıkları:</p><p>Thread scheduler, öncelikli iş parçacıklarına öncelik verir. Yüksek öncelikli iş parçacıkları, düşük öncelikli iş parçacıklarından önce mikroprosesör zamanı alır.</p><p>Round Robin Yöntemi:</p><p>Aynı önceliğe sahip iş parçacıkları arasında zaman paylaşımı yapmak için round robin yöntemini kullanır. Bu, iş parçacıkları arasında adil bir dağılım sağlar.</p><p>Runnable Durumdaki İş Parçacıkları:</p><p>Sadece “runnable” durumdaki iş parçacıkları, thread scheduler tarafından seçilir. Bu, iş parçacıklarının sadece çalışmaya hazır olduğu durumda mikroprosesör zamanı almalarını sağlar.</p><p>Java’da thread scheduler, çoklu iş parçacıklarının etkili bir şekilde çalışmasını sağlamak ve mikroprosesör kaynaklarını adil bir şekilde dağıtmak için kullanılır. Bu sayede öncelikli ve çalışabilir durumdaki iş parçacıkları, belirli bir düzen ve adil bir şekilde mikroprosesör zamanı alabilirler.</p><h3>13. Java’da thread life cycle ( yaşam döngüsünü) açıklayınız?</h3><p>Yeni (New) Durumu:</p><p>Bir thread örneği oluşturulduğunda, thread “New” durumundadır.</p><p>Örneğin:</p><pre>Thread t = new Thread();</pre><p>Yukarıdaki örnekte, t isimli thread “new” durumundadır. Thread oluşturulmuş, ancak henüz aktif durumda değildir. Aktif hale getirmek için start() metodunu çağırmamız gerekir.</p><p>Çalışabilir (Runnable) Durumu:</p><p>Thread, iki şekilde “runnable” durumuna geçebilir:</p><p>a) start metodu çağrıldığında.</p><p>b) Bir thread, bloke olmuş veya uyku durumundan döndükten sonra da “runnable” durumuna geçebilir.</p><p>Çalışan (Running) Durumu:</p><p>Thread, thread scheduler tarafından CPU zamanı tahsis edildiğinde “running” durumuna geçer.</p><p>Bekleme/Bloke/Uyku (Waiting/Blocking/Sleeping) Durumu:</p><p>Thread, kısa bir süre için pasif hale getirilebilir. Bu durumda thread, aşağıdaki durumlardan birinde “bekleme” durumuna geçer:</p><p>Thread, bir nesnenin kilidini almayı bekliyor.</p><p>Thread, başka bir threadin tamamlanmasını bekliyor.</p><p>Thread, diğer bir threadin bildirimini bekliyor.</p><p>Bitmiş (Dead) Durumu:</p><p>Thread, run metodunun çalışması tamamlandığında “dead” durumuna geçer.</p><p>Thread, run metodunun tamamlanmasıyla otomatik olarak sona erer ve thread nesnesi çöp toplayıcı tarafından yok edilir.</p><p>Java’daki thread yaşam döngüsü, iş parçacıklarının oluşturulması, çalıştırılması, bekletilmesi ve sonlandırılması gibi farklı durumları içerir. Bu durumlar, iş parçacıklarının etkileşimli ve efektif bir şekilde çalışmasını sağlar.</p><h3>14. Dead thread tekrar başlatılabilir mi?</h3><p>Eğer bir thread (thread) ölmüş (dead) durumdaysa ve start methodu kullanılarak tekrar başlatmaya çalışılırsa, bu durumda çalışma zamanı hatası alınır. Çünkü bir kez ölen bir thread, bir daha başlatılamaz.</p><p>Thread öldüğünde, run metodunun yürütülmesi tamamlanmış ve thread sona ermiştir. Bu durumda, aynı thread nesnesi üzerinde tekrar start metodunu çağırmak geçerli değildir ve bir IllegalThreadStateException hatası alınır.</p><pre>Thread myThread = new Thread(() -&gt; {<br>// Threadnın çalışma mantığı<br>System.out.println(&quot;Thread çalışıyor.&quot;);<br>});<br>myThread.start(); // Thread başlatıldı<br>// …<br>myThread.start(); // Hata! Thread öldüğü için tekrar başlatılamaz</pre><p>Yukarıdaki örnekte, myThread adlı thread başlatıldıktan sonra tekrar başlatılmaya çalışıldığında IllegalThreadStateException hatası alınacaktır. Thread bir kez çalışma sürecini tamamladığında, başka bir thread nesnesi oluşturup onu başlatmak gereklidir.</p><h3>15. Bir thread başka threadi bloke edebilir mi?</h3><p>Java’da bir thread (thread), başka bir threadi bloke edemez. Ancak, bir thread kendi yürütme akışını geçici olarak durdurabilir (bloke edebilir).</p><p>Java’da iş parçacıkları arasında koordinasyon ve senkronizasyon mekanizmaları kullanılarak iş parçacıkları arasında bir tür etkileşim sağlanabilir. Bu mekanizmalar şunları içerir:</p><p>Locks (Kilitler): İş parçacıkları arasında ortak bir kaynağa erişimi kontrol etmek için kilitler kullanılabilir. Ancak, bir thread bir kaynağa kilit koyduğunda, diğer iş parçacıkları bu kaynağa erişemez, ancak başka kaynaklara erişebilir.</p><p>Wait ve Notify: İş parçacıkları arasında iletişim sağlamak için wait ve notify metodları kullanılabilir. Bir thread, bir koşulu kontrol ederken wait metodunu kullanarak bekleyebilir ve diğer bir thread, bu koşulu sağladığında notify metodunu kullanarak diğer threadi uyandırabilir.</p><p>Thread.sleep: Bir thread, belirli bir süre boyunca uykuda kalabilir (Thread.sleep kullanarak). Bu, başka bir thread için kaynağa erişimi geçici olarak durdurabilir, ancak bu blokaj koordinasyon amacıyla değil, zamanlamayla ilgilidir.</p><p>Yani, bir thread doğrudan başka bir threadi bloke edemez, ancak senkronizasyon ve koordinasyon mekanizmaları kullanılarak iş parçacıkları arasında bir tür etkileşim sağlanabilir.</p><h3>16. Başlatılan bir thread tekrar başlatılabilir mi?</h3><p>Bir thread bir kere başlatıldıktan sonra ikinci kez start yöntemi çağrılırsa (bir kere başlatılan bir thread bir daha başlatılamaz), bu durumda RuntimeException türünden bir IllegalThreadStateException hatası oluşacaktır.</p><h3>17. Thread pool nedir?</h3><p>Thread pool, bir uygulamada aynı anda çalışan çok sayıda threadi etkili bir şekilde yönetmek için kullanılan bir tasarım desenidir. Thread pool, genellikle aşağıdaki avantajları sağlar:</p><p>Performans İyileştirmesi:</p><p>Her thread oluşturulduğunda bir miktar sistem kaynağı (bellek, işlemci zamanı) harcanır. Thread pool, bu maliyeti azaltarak performansı artırır. Zira önceden oluşturulan iş parçacıkları tekrar kullanılır.</p><p>Kaynak Yönetimi:</p><p>Thread pool, aynı anda çok sayıda threadin çalışmasına izin verirken, aşırı thread oluşturmanın önüne geçer. Bu, sistem kaynaklarının daha etkili kullanılmasını sağlar.</p><p>İstikrarlı Performans:</p><p>Sabit bir sayıda thread ile çalıştığı için, thread pool, sistemde aşırı iş yükü oluşturarak performans düşüklüğüne yol açan durumları engeller.</p><p>Thread Yönetimi:</p><p>Thread pool, iş parçacıklarını oluşturma, başlatma, sonlandırma ve takip etme gibi görevleri kolaylaştırır.</p><h3>18. Volatile keywordu ne işe yarar?</h3><p>volatile kelimesi, bir değişkenin değerini hafıza modelindeki bazı özelliklere uygun bir şekilde kullanmayı sağlar. volatile anahtar kelimesinin kullanıldığı bir değişken, bir thread tarafından yapılan değişikliklerin diğer iş parçacıkları tarafından hemen görülmesini sağlar. Bu, değişkenin bellek modelindeki ana hafıza konumunu temsil eder.</p><p>volatile anahtar kelimesi kullanıldığında, bir değişkenin değeri sadece okuma ve yazma işlemleri sırasında önbellek kullanımı minimize edilerek ana belleğe doğrudan erişimle güncellenir. Bu, diğer iş parçacıklarının güncel değeri hemen görmelerini sağlar.</p><p>Bu özellik, özellikle çoklu iş parçacıklı ortamlarda bir değişkenin güncellenmiş değerini diğer iş parçacıklarına hemen göstermesi gerektiği durumlarda kullanılır. Ancak, volatile kullanımı bazı durumlarda yeterli olmayabilir ve daha karmaşık senkronizasyon mekanizmaları (örneğin, synchronized bloklar veya java.util.concurrent kütüphanesindeki araçlar) gerekebilir.</p><p>Örnek kullanım:</p><pre>public class SharedResource {<br>private volatile boolean flag = false;<br>public void setFlagTrue() {<br>flag = true;<br>}<br>public boolean checkFlag() {<br>return flag;<br>}</pre><p>Bu örnekte, flag adlı değişken volatile olarak tanımlanmıştır. setFlagTrue metodu, flag değişkeninin değerini true yapar. Diğer iş parçacıkları, checkFlag metodu aracılığıyla flag değişkeninin güncel değerini anında görebilirler. volatile kullanılmış olsaydı, diğer iş parçacıkları bu değişikliği hemen fark edemeyebilirdi.</p><h3>19. Thread oluştururken run methodunu override etmezsek ne olur?</h3><p>Eğer run metodunu override etmezsek, Thread sınıfının varsayılan run metodunun uygulaması çalıştırılır. Bu durumda, Thread sınıfının run metodu içinde herhangi bir iş yapılması beklenmez ve bu metot boştur.</p><p>Eğer bir thread (thread) oluştururken kendi run metodumuzu sağlamazsak, sadece Thread sınıfının run metodunun içindeki varsayılan boş işlem gerçekleşir. Bu durumda, thread hiçbir özel görev gerçekleştirmeyecek ve derlenen programın davranışı değişmeyecektir.</p><h3>20. Java’da run metodunu overload edebilir miyiz?</h3><p>Evet, run metodunu overload edebiliriz ancak Thread sınıfının start metodunun her zaman parametre almayan run metodunu çağıracağını unutmamamız önemlidir. Overload run metodunu doğrudan start metodu tarafından çağırmaz.</p><p>Yani, eğer bir thread sınıfında birden fazla run metodunu tanımlarsak, Thread sınıfının start metodu yalnızca parametre almayan (run() şeklinde olanı) run metodunu çağırır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1673b15e9ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java Mülakatlara Hazırlık Soruları 2]]></title>
            <link>https://medium.com/@ozguraltug06/java-m%C3%BClakatlara-haz%C4%B1rl%C4%B1k-sorular%C4%B1-2-b0302780702e?source=rss-6391bbd52a20------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0302780702e</guid>
            <category><![CDATA[java-mülakat]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[java-sorular]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Özgür Altuğ]]></dc:creator>
            <pubDate>Tue, 21 Nov 2023 18:22:39 GMT</pubDate>
            <atom:updated>2023-11-21T18:22:39.707Z</atom:updated>
            <content:encoded><![CDATA[<p>Java öğrenme uzun bir periyottur. Bazen yeni bilgiler öğrendikçe eski bilgiler unutulmaya başlanır. Mülakatlara hazırlanmak ta bilgilerin derlenmesi adına fırsattır. Bütün sorular hızlıca okunmayabilir. Bu yüzden bundan sonraki hazırlık sorularını 20 şer soru üzerinden hazırlamanın okuyuculara daha kolaylık olacağını düşündüm. Umarım sizlere faydalı olur.</p><p><strong>1.</strong> <strong>Java’da try catch bloğunu açıklayınız?</strong></p><p>Java’da “try” ve “catch” anahtar kelimeleri, exeption durumlarının ele alınması için kullanılır.</p><p>“try” Bloğu:</p><p>“try” bloğu içinde, exception oluşturabilen veya fırlatabilecek kodları tanımlarız. Exception meydana geldiğinde bu blok çalışır ve kodunuzu değerlendirmeye alır. Eğer exception oluşmazsa, “try” bloğu normal bir şekilde çalışır.</p><p>Örnek “try” blok kullanımı:</p><p><em>try {</em></p><p><em>// İstisna oluşturabilen kodlar burada bulunur.</em></p><p><em>} catch (Exception e) {</em></p><p><em>// İstisna yakalandığında buradaki kod çalışır.</em></p><p><em>}</em></p><p>“catch” Bloğu:</p><p>“catch” bloğu, bir “try” bloğunda meydana gelen exception durumlarını yakalar. Exception durumu “try” bloğundan “catch” bloğuna iletilir ve burada işlenir. “catch” bloğu, exception türüne göre çalışacak kodu içerir. Böylece, exception oluştuğunda hangi işlemin yapılacağını belirleriz.</p><p>Örnek “catch” blok kullanımı:</p><p><em>try {</em></p><p><em>// İstisna oluşturabilen kodlar burada bulunur.</em></p><p><em>} catch (Exception e) {</em></p><p><em>// İstisna yakalandığında buradaki kod çalışır.</em></p><p><em>// “e” değişkeni, yakalanan istisnayı temsil eder.</em></p><p><em>// Burada istisnayı işleyebilir veya raporlayabiliriz.</em></p><p><em>}</em></p><p>Java’da bir “try” bloğu, bir “catch” bloğu ile tamamlanır ve bu ikisi birlikte bir exception işlem birimi oluşturur. Bir “catch” bloğu, yalnızca kendisinden önceki “try” bloğunda meydana gelen exceptionları yakalayabilir. Başka bir “try” bloğunun oluşturduğu exception, bir “catch” bloğu tarafından yakalanamaz.</p><p>Eğer programınızda exception oluşturan kod yoksa veya exception oluşturulmazsa, JVM (Java Sanal Makinesi) “try-catch” bloğunu görmezden gelir ve normal program akışı devam eder.</p><p><strong>2.</strong> <strong>Java’da catch bloğu kullanmadan try bloğu kullanılır mı?</strong></p><p>Bir “try” bloğunu, Java’da exception bir durumu ele almak veya kaynakları temizlemek için kullanabilirsiniz. Ancak bu “try” bloğunun yalnızca kendisi olmaz; ya bir “catch” bloğu ile hata işleme veya bir “finally” bloğu ile kaynak temizleme gibi bir sonuç sağlamalıdır.</p><p>Yani, bir “try” bloğu oluşturuyorsanız, aynı zamanda en az bir “catch” bloğu veya “finally” bloğu eklemeniz gerekmektedir. Sadece “try” bloğu kullanmak veya her ikisini birden atlamak (ne “catch” ne de “finally”) derleme hatasına yol açar. Bu nedenle, exception durumları ele almak veya kaynakları düzgün şekilde temizlemek için “try-catch” veya “try-finally” bloklarını kullanmak önemlidir.</p><p><strong>3.</strong> <strong>Java’da bir “try” bloğu için birden fazla “catch” bloğu kullanılabilir mi?</strong></p><p>Bir “try” bloğu içinde birden fazla “catch” bloğu kullanılabilir çünkü kodunuz birden çok farklı türde exception oluşturabilir. Her “catch” bloğu, belirli bir exception türünü ele alır ve ilgili işlemi gerçekleştirir. Bu şekilde, programınızın farklı türde hatalarla başa çıkabilmesini sağlayabilirsiniz.</p><p>Örnek bir “try” bloğu ile birden fazla “catch” bloğu kullanımı:</p><p><em>try {</em></p><p><em>// İstisna oluşturabilen kodlar burada bulunur.</em></p><p><em>} catch (ArithmeticException e) {</em></p><p><em>// ArithmeticException türündeki istisnaları ele al</em></p><p><em>// Bu blok, bölen sıfır hatası gibi matematiksel hataları işleyebilir.</em></p><p><em>} catch (NullPointerException e) {</em></p><p><em>// NullPointerException türündeki istisnaları ele al</em></p><p><em>// Bu blok, bir nesnenin olmadığı durumları işleyebilir.</em></p><p><em>} catch (IOException e) {</em></p><p><em>// IOException türündeki istisnaları ele al</em></p><p><em>// Bu blok, dosya okuma/yazma hatalarını işleyebilir.</em></p><p><em>} catch (Exception e) {</em></p><p><em>// Genel olarak tüm istisna türlerini ele al</em></p><p><em>// Bu blok, yukarıdaki catch bloklarının yakalayamadığı istisnaları işleyebilir.</em></p><p><em>}</em></p><p>Bu “catch” blokları, sırasıyla çalışır. Yani, bir exception meydana geldiğinde, JVM her bir “catch” bloğunu sırayla kontrol eder ve ilk eşleşen “catch” bloğunu çalıştırır. Geri kalan “catch” blokları atlanır. Bu nedenle, “catch” bloklarının sırası çok önemlidir.</p><p>Ayrıca, “catch” bloklarının sırasının alt sınıf exceptionlarından üst sınıf exceptionlarına doğru olması gerekir. Yani, daha özel exception türleri daha önce gelmelidir, sonra daha genel olanlar sıralanmalıdır. Bu, herhangi bir “catch” bloğunun çalıştırılmasını sağlar ve genel işlem sırasında daha özel durumları ele almanıza olanak tanır. Bu nedenle, “try” bloğu ile birden fazla “catch” bloğu kullanırken bu sıralamayı dikkate almak önemlidir.</p><p><strong>4.</strong> <strong>Java’da finally bloğunun önemini açıklayınız.</strong></p><p>“finally” bloğu, Java’da önemli bir rol oynar çünkü şu amaçlar için kullanılır:</p><p>Kaynak Temizleme: Genellikle “try” bloğu içinde kaynakların (veritabanı bağlantıları, dosya işlemleri, soketler vb.) kullanıldığı durumlarda, “finally” bloğu bu kaynakların temizlenmesi için kullanılır. Bu, kaynakların güvenli bir şekilde kapatılmasını ve kaynak sızıntılarının önlenmesini sağlar.</p><p>Hata Durumlarında İşlem Tamamlama: Eğer “try” bloğu exception oluşturmadan başarıyla çalışırsa, “finally” bloğu “catch” bloğunu atlamadan hemen sonra çalışır. Bu, temizleme veya sonlandırma işlemlerini gerçekleştirmeniz gereken durumlar için kullanışlıdır.</p><p>İstisna Durumlarında İşlem Tamamlama: Eğer “try” bloğunda bir exception oluşursa ve bu exception bir “catch” bloğu tarafından ele alınmazsa, yine de “finally” bloğu çalıştırılır. Bu, beklenmeyen hatalar durumunda kaynakları serbest bırakmanız veya temizlemeniz gerektiğinde kullanışlıdır.</p><p>“finally” bloğu, “try-catch-finally” yapısı içinde bulunur ve bu yapı, exceptionların düzgün bir şekilde ele alınması ve kaynakların güvenli bir şekilde temizlenmesi için çok önemlidir. Bu sayede, programlarınız daha güvenli ve sağlam hale gelir ve kaynak yönetimi konusundaki hatalar minimize edilir. Bu nedenle, “finally” bloğu Java’da önemli bir yapısal öğedir ve programların daha güvenilir olmasına yardımcı olur.</p><p><strong>5.</strong> <strong>Java’da “try” ve “catch” blokları arasında herhangi bir kod yazılabilir mi?</strong></p><p>“try” bloğu ve “catch” bloğu arasında herhangi bir kod bulunmamalıdır. “try” bloğu içindeki kod çalıştırılır ve bir exception oluşursa, bu exception “catch” bloğuna yönlendirilir. Eğer “try” bloğu ve “catch” bloğu arasında kod bulunursa, derleme hatası alırsınız. İstisna oluştuğunda, bu kod parçası atlanır ve “catch” bloğu çalıştırılmadan hemen sonra exception işlenir.</p><p>Doğru kullanım şu şekildedir:</p><p><em>try {</em></p><p><em>// try bloğunda istisna oluşturabilen kodlar burada bulunur</em></p><p><em>} catch (Exception e) {</em></p><p><em>// istisna yakalandığında bu blok çalışır</em></p><p><em>}</em></p><p>Yani, “try” bloğu ve “catch” bloğu birbirine bitişik olmalı ve aralarına herhangi bir kod parçası eklenmemelidir. Bu kurala uymak, kodunuzun beklenmedik hatalara karşı daha güvenli ve düzenli olmasına yardımcı olur.</p><p><strong>6.</strong> <strong>Java’da “try” ve “finally” blokları arasında herhangi bir kod yazılabilir mi?</strong></p><p>Java’da “try” bloğu ve “finally” bloğu arasında herhangi bir kod parçası yer alamaz. “finally” bloğu, “try” ve (varsa) “catch” blokları tamamlandıktan hemen sonra çalışır. Eğer “catch” bloğu yoksa, “try” bloğu tamamlandıktan hemen sonra “finally” bloğu çalışır.</p><p>Doğru kullanım şu şekildedir:</p><p><em>try {</em></p><p><em>// try bloğunda işlem yapılacak kodlar burada bulunur</em></p><p><em>} catch (Exception e) {</em></p><p><em>// istisna yakalandığında bu blok çalışır</em></p><p><em>} finally {</em></p><p><em>// finally bloğu, try ve catch tamamlandıktan sonra çalışır</em></p><p><em>}</em></p><p><strong>7.</strong> <strong>Java’da aynı “catch” bloğunda birden fazla exception türü ele alınır mı?</strong></p><p>Java 7&#39;den itibaren, aynı “catch” bloğunda birden fazla istisna türünü ele alabiliriz. Örneğin, aşağıdaki gibi bir yaklaşım kullanabiliriz:</p><p><em>try {</em></p><p><em>// İstisna oluşturabilen kodlar burada bulunur</em></p><p><em>} catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {</em></p><p><em>// Birden fazla istisna türünü aynı “catch” bloğunda ele alabiliriz</em></p><p><em>// e değişkeni, her iki istisna türünün de istisnasını temsil eder</em></p><p><em>// Bu blok, hem ArrayIndexOutOfBoundsException hem de</em> <em>ArithmeticException istisnalarını işleyebilir.</em></p><p><em>}</em></p><p>Ancak, aynı “catch” bloğunda birden fazla exception türünü ele alırken dikkate almanız gereken bazı önemli noktalar şunlardır:</p><p>“catch” parametresi zaten final olarak kabul edilir. Yani, bu değişkene başka bir değer atayamazsınız veya değiştiremezsiniz.</p><p>Aynı “catch” bloğunda ele alınan exception türleri arasında bir hiyerarşi olmalıdır. Yani, bir üst sınıfın exceptionsını bir alt sınıfın exceptionsı olarak ele almak mümkün değildir. Örneğin, “catch (Exception e)” ve “catch (RuntimeException e)” aynı “catch” bloğunda kullanılamaz.</p><p>Bu tür bir yaklaşım, kodunuzu daha temiz ve daha az tekrarlı hale getirebilir, ancak exception durumları mantıklı bir şekilde ele almak ve kodunuzun okunabilirliğini korumak için dikkatli olmalısınız.</p><p><strong>8.</strong> <strong>Checked Exceptions nelerdir?</strong></p><p>Kontrol Edilen Exceptionlar:</p><p>· “Throwable” sınıfının alt sınıfları arasında, “error”, “RuntimeException” ve onun alt sınıfları haricinde kalan tüm exception türleri “kontrol edilen exception” olarak kabul edilir.</p><p>· Kontrol edilen exception türleri, programcıların bu exceptionları işlemek veya bunları bildirmek için özel bir işlem yapmalarını gerektirir.</p><p>· Bu exception türlerini işlemek için “throws” anahtar kelimesi ile metot imzasında veya “try-catch” blokları kullanılmalıdır, aksi takdirde derleme hatası alınır.</p><p>Örnekler:</p><p>IOException: Dosya giriş/çıkış işlemleri sırasında oluşan hataları temsil eder.</p><p>SQLException: Veritabanı işlemleri sırasında oluşan hataları temsil eder.</p><p>FileNotFoundException: Belirtilen dosya bulunamadığında oluşan exceptionı temsil eder.</p><p>InvocationTargetException: Bir yordamın yürütülmesi sırasında exception oluştuğunda bu tür bir exception fırlatılır.</p><p>CloneNotSupportedException: Bir nesnenin klonlanmaya çalışıldığında ve klonlama işlemi desteklenmiyorsa oluşan exceptionı temsil eder.</p><p>ClassNotFoundException: Bir sınıfın yüklenmeye çalışıldığında ve bu sınıf mevcut değilse fırlatılan exceptionı temsil eder.</p><p>InstantiationException: Bir sınıfın bir örneği oluşturulamadığında fırlatılan exceptionı temsil eder.</p><p>Bu exception türleri, programın güvenliğini ve istikrarını sağlamak için önemlidir ve programcılar bu tür exceptionları yakalamak ve işlemek için gerekli önlemleri almalıdır.</p><p><strong>9.</strong> <strong>Unchecked Exceptions nelerdir?</strong></p><p>Kontrol Edilmemiş İstisnalar (Unchecked Exceptions):</p><p>“RuntimeException” sınıfının alt sınıfları, “unchecked exceptions” olarak adlandırılır. Bu tür exception türleri, programın derleyici tarafından exception yönetimi için kontrol edilmesini gerektirmez.</p><p>Programlar, bu tür exceptionları ele almasalar bile derlenebilir. Bu, “catch” veya “throws” kullanımına gerek olmadığı anlamına gelir.</p><p>Eğer bir kontrol edilmemiş exception meydana gelirse, programın çalışması sona erir. Bu nedenle bu tür exceptionların dikkatli bir şekilde ele alınması önemlidir.</p><p>Örnekler:</p><p>ArithmeticException: Matematiksel işlemlerde sıfıra bölme veya geçersiz işlemler nedeniyle oluşan exceptionları temsil eder.</p><p>ArrayIndexOutOfBoundsException: Dizi erişimi sırasında dizinin sınırlarının dışına çıkma exceptionlarını temsil eder.</p><p>ClassCastException: Nesne tür dönüşümü sırasında uyumsuz türler arasında dönüşüm yapma girişimleri nedeniyle oluşan exceptionları temsil eder.</p><p>IndexOutOfBoundsException: İndeks sınırları dışına çıkma exceptionlarını temsil eder.</p><p>NullPointerException: Null bir nesneye erişme girişimleri nedeniyle oluşan exceptionları temsil eder.</p><p>NumberFormatException: Bir sayısal dönüşüm hatası nedeniyle oluşan exceptionları temsil eder.</p><p>StringIndexOutOfBounds: Bir dize içinde belirtilen indeksin sınırları dışına çıkma exceptionlarını temsil eder.</p><p>UnsupportedOperationException: Bir koleksiyon üzerinde desteklenmeyen bir işlemi yapma girişimleri nedeniyle oluşan exceptionları temsil eder.</p><p>Bu tür exceptionlar, programların güvenliğini ve istikrarını sağlamak için önemlidir ve programcılar bu tür exceptionları öngörmeye ve ele almaya çalışmalıdır.</p><p><strong>10.</strong> <strong>Java’da varsayılan handle etme işlemi nedir?</strong></p><p>Java’da varsayılan exception işleme, Java Sanal Makinesi (JVM) tarafından otomatik olarak yürütülen bir mekanizmadır. Bir exception oluşturulduğunda veya tespit edildiğinde, JVM aşağıdaki bilgileri içeren yeni bir exception işleme nesnesi oluşturur:</p><p>Exception Türü Adı</p><p>Exception Hakkında Açıklama</p><p>Exception Oluşma Konumu</p><p>JVM, bu exception işleme nesnesini oluşturduktan sonra, programın bu exception ile başa çıkıp çıkamayacağını kontrol eder. Eğer programda exception işleme kodu varsa (yani “try-catch” veya “try-finally” blokları), bu kod çalışır ve program devam eder. Ancak, eğer programda uygun bir exception işleme kodu bulunmuyorsa, JVM bu sorumluluğu varsayılan bir işlemciden bekler ve programı beklenmedik bir şekilde sonlandırır.</p><p>Varsayılan exception işleyici, exception hakkında bilgi veren bir açıklama, bir exceptionın stacktrace’ini ve exception oluşma konumunu görüntüler. Programın aniden sonlandırılması, bu işlemin dezavantajlarından biridir çünkü programlar düzgün bir şekilde sona ermeli ve kullanıcıya hata mesajları verilmelidir. Bu nedenle, Java programlarında uygun exception işleme kodu eklemek, programın daha güvenilir ve kullanıcı dostu olmasına yardımcı olur.</p><p><strong>11.</strong> <strong>Java’da throw keywordunu açıklayınız?</strong></p><p>Java’da “throw” kelimesi, genellikle JVM’nin exceptionları fırlatmasına izin verdiği ve bu exceptionları try-catch blokları kullanarak ele aldığımız durumların dışında, kullanıcı tanımlı exceptionları veya çalışma zamanı exceptionlarını açıkça fırlatmak için kullanılır.</p><p>“throw” kelimesinin kullanımı için genel sözdizimi:</p><p>throw throwableInstance;</p><p>Burada, throwableInstance bir Throwable veya onun alt sınıflarından biri olmalıdır.</p><p>“throw” ifadesi çalıştırıldığında, bu ifadeden sonraki ifadeler çalıştırılmaz ve işlem durur. Ardından, JVM fırlatılan exceptionı ele alacak bir catch bloğu olup olmadığını kontrol eder. Eğer yoksa, bir sonraki catch ifadesine geçer ve uygun bir işleyici bulana kadar devam eder. Eğer uygun bir işleyici bulunamazsa, varsayılan exception işleyici programı durdurur ve exception açıklamasını ve konumunu yazdırır.</p><p>Genellikle “throw” kelimesini, kullanıcı tanımlı veya özel exceptionları fırlatmak için kullanırız. Bu şekilde, programın belirli durumları ele almasını sağlayabilir ve hata durumlarını düzgün bir şekilde işleyebiliriz.</p><p><strong>12.</strong> <strong>Java’da “throw” kullanımından sonra kod yazılır mı?</strong></p><p>“throw” ifadesi çalıştırıldığında, kontrol akışı ilgili catch bloğuna veya uygun bir işleyiciye geçer. throw ifadesinden sonraki ifadeler, exception fırlatıldığı için ulaşılamaz kod olarak kabul edilir. Bu nedenle, throw ifadesinden sonra herhangi bir kod yazmaya çalışırsanız, derleme zamanında “ulaşılamaz kod” hatası alırsınız. Derleyici, throw ifadesinden sonraki kodun hiçbir zaman çalıştırılamayacağını belirler ve bu durumu size bildirmek için bir hata mesajı oluşturur.</p><p><strong>13.</strong> <strong>Java’da throw keywordunun önemini açıklayınız?</strong></p><p>Java’da throws anahtar kelimesinin önemi :</p><p>Metodun İmzasında Belirtme: throws ifadesi, bir metodun imzasının sonunda kullanılır ve belirli bir türde bir exception bu metodun içinden fırlatılabileceğini belirtir.</p><p>İstisna İşleme Sorumluluğunu Delege Etme: throws ifadesinin temel amacı, kontrol edilen exceptionların durumunda exception işleme sorumluluğunu çağıran metotlara devretmektir. Yani, bir metodun içinde bir kontrol edilen exception (checked exception) oluşursa, bu durumu ele almaktan ziyade, metot throws ifadesi ile çağırana bu exception ile başa çıkma sorumluluğunu atar.</p><p>Unchecked (Kontrolsüz) İstisnalarda Gerekli Değil: Kontrolsüz exceptionlar (unchecked exceptions) için throws ifadesini kullanmak zorunlu değildir. Bu tür exceptionların genellikle programcı hatası veya beklenmeyen durumlar olduğu düşünülerek, bu exceptionları ele almak yerine programın çökmesine izin verilir.</p><p>Sadece Throwable Türleri İçin Kullanılabilir: throws ifadesi sadece Throwable türleri veya bu sınıflardan türetilmiş exception türleri için kullanılabilir. Aksi takdirde, uyumsuz türlerle ilgili bir derleme hatası alırsınız.</p><p>Öneri: Yalnızca Belirli İstisna Türlerini Belirtme: Metot içinde fırlatılan exceptionların alt sınıfları yerine, belirli exception türlerini belirtmek daha iyidir. Bu, kodun daha esnek ve anlaşılır olmasına katkıda bulunur.</p><p><em>class Test {</em></p><p><em>public static void main(String args[]) throws SpecificException {</em></p><p><em>// …</em></p><p><em>}</em></p><p><em>}</em></p><p>Bu örnekte, SpecificException veya bu sınıfın alt sınıflarından biri olabilecek bir istisna fırlatılabileceği belirtilmiştir.</p><p><strong>14.</strong> <strong>Finally ve return kullanımı nasıl olur?</strong></p><p>finally bloğu ve return ifadesi birlikte kullanıldığında, finally bloğu her iki durumda da (try veya catch bloğu içinde olsun veya olmasın) önemli bir rol oynar. Özellikle finally bloğu, programın normal akışını bozmaksızın son temizleme veya kaynak salma işlemlerini gerçekleştirmek için kullanılır. Bu, programın her durumda düzgün bir şekilde kapatılmasını sağlar.</p><p>Önemli bir senaryo şudur:</p><p>Return İfadesi Inside Try veya Catch Bloğu:</p><p><em>public int exampleMethod() {</em></p><p><em>try {</em></p><p><em>// Some code that may throw an exception</em></p><p><em>return 42;</em></p><p><em>} catch (Exception e) {</em></p><p><em>// Handle the exception</em></p><p><em>return -1;</em></p><p><em>} finally {</em></p><p><em>// This block will be executed no matter what</em></p><p><em>System.out.println(“Finally block executed”);</em></p><p><em>}</em></p><p><em>}</em></p><p>Bu örnekte, try bloğu içinde veya catch bloğu içinde bir return ifadesi bulunmaktadır. Ancak, bu return ifadesi çağrıldığında bile, finally bloğu yine de çalışacaktır.</p><p>Finally Bloğu Önceliklidir:</p><p>Eğer bir finally bloğu ve return ifadesi birlikte kullanılıyorsa, finally bloğu her zaman önceliklidir. Yani, finally bloğu tamamlandıktan sonra return ifadesi işlenir.</p><p>Örneğin, yukarıdaki exampleMethod örneğinde, eğer try bloğu içindeki return 42; satırı çalışırsa, bu değeri döndürmeden önce finally bloğu çalışacaktır. Dolayısıyla, sonuç olarak önce “Finally block executed” yazısı görülecektir, ardından 42 değeri döndürülecektir.</p><p>Bu, kaynakları serbest bırakma, temizlik işlemleri veya her iki durumda da yapılması gereken işlemler gibi durumlar için kullanışlıdır. finally bloğu, hata oluşsa bile belirli işlemlerin her zaman gerçekleştirilmesini sağlar. Bu nedenle, finally bloğu, özellikle kaynak yönetimi gibi durumlarda, programın düzgün çalışmasını sağlamak için önemlidir.</p><p><strong>15.</strong> <strong>Checked exceptions için catch kullanabilir miyiz?</strong></p><p>Java’da, kontrol edilen exceptionların (checked exceptions) işlenmesi için catch blokları eklemek gereklidir. Ancak, bir kod bloğunda kontrol edilen bir exception olasılığı yoksa, yani belirli bir blokta bir hata oluşma ihtimali yoksa, bu durumda bu exceptionı işlemek için bir catch bloğu eklemek zorunlu değildir.</p><p>Örneğin:</p><p><em>public class Example {</em></p><p><em>public static void main(String[] args) {</em></p><p><em>try {</em></p><p><em>// Kodunuz burada</em></p><p><em>} catch (CheckedException ex) {</em></p><p><em>// Eğer buraya hiçbir zaman gelinmiyorsa, bu bloğa gerek yok.</em></p><p><em>// Bu durumda, bu catch bloğu “unreachable code” hatası alabilir.</em></p><p><em>}</em></p><p><em>}</em></p><p><em>}</em></p><p>Yukarıdaki örnekte, catch (CheckedException ex) bloğu, eğer CheckedException türünde bir istisna fırlatma olasılığı yoksa gereksiz olacaktır. Bu durumda, bu catch bloğu “ulaşılamaz kod” hatası alabilir.</p><p>Bu nedenle, kodunuzda bir istisna olasılığı olup olmadığını dikkatlice değerlendirmek önemlidir. Eğer bir kod bloğunda belirli bir istisna türü olmayacağı kesinse, o istisnayı işlemek için gereksiz bir catch bloğu eklemekten kaçınılmalıdır. Aksi takdirde, derleme sırasında “ulaşılamaz kod” hatası alabilirsiniz.</p><p><strong>16.</strong> <strong>Kullanıcı tanımlı istisnalar (user-defined exceptions) ne demektir?</strong></p><p>Kullanıcı tanımlı exceptionlar (user-defined exceptions), programcıların özel durumları belirtmek ve özel hata mesajları oluşturmak için oluşturdukları exception türleridir. Bu tür exceptionlar, hem kontrol edilen (checked) exception türleri olarak hem de kontrolsüz (unchecked) exception türleri olarak oluşturulabilir.</p><p>Kontrol Edilen (Checked) User-Defined Exception:</p><p>Kullanıcı tanımlı exception türleri, Exception sınıfını genişleterek veya kontrol edilen exception sınıflarından birini genişleterek oluşturulabilir. Kontrol edilen bir exception, programcının bu exception türünü belirtmek için throws ifadesini kullanması gerektiği bir türdür.</p><p><em>public class MyCheckedException extends Exception {</em></p><p><em>// …</em></p><p><em>}</em></p><p>Bu durumda, MyCheckedException sınıfı, Exception sınıfını genişleterek kontrol edilen bir exception haline gelir.</p><p>Kontrolsüz (Unchecked) User-Defined Exception:</p><p>Kullanıcı tanımlı exception türleri, RuntimeException sınıfını genişleterek kontrolsüz bir exception haline getirilebilir. Bu tür exception türleri, programcının throws ifadesini kullanmak zorunda olmadığı, yani yakalanma veya işlenme zorunluluğu olmayan exception türleridir.</p><p><em>public class MyUncheckedException extends RuntimeException {</em></p><p><em>// …</em></p><p><em>}</em></p><p>Bu durumda, MyUncheckedException sınıfı, RuntimeException sınıfını genişleterek kontrolsüz bir exception haline gelir.</p><p>Not:</p><p>Genellikle özel bir durumu temsil etmek için kontrolsüz exception türlerini kullanmak daha yaygındır. Bu, programcının herhangi bir throws ifadesi eklemek zorunda kalmadan exception türünü kullanabilmesine olanak tanır. Bu nedenle, özel exception sınıflarını oluştururken, mümkünse RuntimeException sınıfını genişletmek önerilir.</p><p><strong>17.</strong> <strong>Java’da iç içe try bolakları kullanabilir miyiz ?</strong></p><p>Java’da try ifadelerini iç içe yerleştirebiliriz. Bir try ifadesini başka bir try ifadesinin bloğu içinde tanımlayabiliriz. Bu, belirli bir kod bloğunda farklı seviyelerde hata işleme stratejileri uygulamamıza olanak tanır.</p><p>Bir örnek:</p><p><em>public class NestedTryExample {</em></p><p><em>public static void main(String[] args) {</em></p><p><em>try {</em></p><p><em>// Dış try bloğu</em></p><p><em>System.out.println(“Outer Try Block”);</em></p><p><em>try {</em></p><p><em>// İç try bloğu</em></p><p><em>System.out.println(“Inner Try Block”);</em></p><p><em>int result = 10 / 0; // Bu satır bir ArithmeticException fırlatabilir</em></p><p><em>} catch (ArithmeticException innerException) {</em></p><p><em>// İç try bloğundaki ArithmeticException’ı işle</em></p><p><em>System.out.println(“Inner Catch Block: “ + innerException.getMessage());</em></p><p><em>}</em></p><p><em>System.out.println(“After Inner Try-Catch Block”);</em></p><p><em>} catch (Exception outerException) {</em></p><p><em>// Dış try bloğundaki genel istisnayı işle</em></p><p><em>System.out.println(“Outer Catch Block: “ + outerException.getMessage());</em></p><p><em>}</em></p><p><em>}</em></p><p><em>}</em></p><p>Bu örnekte, dış try ifadesi ile iç içe geçmiş bir iç try ifadesi bulunmaktadır. Eğer iç try bloğunda bir hata oluşursa, iç catch bloğu bu hatayı ele alacaktır. Eğer dış try bloğunda bir hata oluşursa, dış catch bloğu bu hatayı ele alacaktır. Bu, programcılara farklı durumları belirli bloklarda işlemek için esneklik sağlar.</p><p><strong>18.</strong> <strong>Throwable class ve methotlarının önemini açıklayınız?</strong></p><p>Throwable sınıfı, Java’daki exceptionların temel sınıfıdır. Bütün exceptionlar, bu Throwable sınıfından türetilir. Throwable sınıfının iki ana alt sınıfı Exception ve Error sınıflarıdır. Throwable sınıfının tanımladığı üç önemli metot şunlardır:</p><p>printStackTrace() Metodu:</p><p>Bu metot, exception bilgilerini aşağıdaki formatta yazdırır:</p><p>İstisna adı</p><p>Açıklama</p><p>Stack trace (yığın izi)</p><p><em>try {</em></p><p><em>// … bir exception fırlatabilecek kod</em></p><p><em>} catch (Exception e) {</em></p><p><em>e.printStackTrace();</em></p><p><em>}</em></p><p>Bu metot, hatanın nerede oluştuğunu belirlemek ve hatayı ayıklamak için çok kullanışlıdır.</p><p>getMessage() Metodu:</p><p>Bu metot, exception nesnesinin sadece açıklama (description) kısmını yazdırır. Bu, exception hakkında daha spesifik bilgiye ihtiyaç duyulmadığında kullanışlıdır.</p><p><em>try {</em></p><p><em>// … bir exception fırlatabilecek kod</em></p><p><em>} catch (Exception e) {</em></p><p><em>System.out.println(e.getMessage());</em></p><p><em>}</em></p><p>Bu şekilde, sadece exception açıklamasını elde edebilirsiniz.</p><p>toString() Metodu:</p><p>Bu metot, exception nesnesinin adını ve açıklamasını yazdırır. printStackTrace() metodu gibi detaylı bir yığın izini yazdırmaz, sadece exception adı ve açıklamasını döndürür.</p><p><em>try {</em></p><p><em>// … bir exception fırlatabilecek kod</em></p><p><em>} catch (Exception e) {</em></p><p><em>System.out.println(e.toString());</em></p><p><em>}</em></p><p>Bu metot, exception hakkında temel bilgi sağlamak için kullanışlıdır.</p><p><strong>19.</strong> <strong>ClassNotFoundException ne zaman fırlatılır, açıklayınız?</strong></p><p>ClassNotFoundException, JVM’nin bir sınıfı yüklemeye çalıştığında sınıfın bulunamaması durumunda ortaya çıkan bir exceptiondır. Bir sınıf adı, metin dizesi olarak verildiğinde ve JVM bu sınıfı yüklemeye çalıştığında, ancak belirtilen isimde bir sınıf bulunamadığında bu exception fırlatılır.</p><p>Örneğin, aşağıdaki gibi bir durumda ClassNotFoundException ortaya çıkabilir:</p><p><em>public class Main {</em></p><p><em>public static void main(String[] args) {</em></p><p><em>try {</em></p><p><em>// Belirtilen sınıf adıyla bir sınıf yüklemeye çalışıyoruz</em></p><p><em>Class.forName(“BilinmeyenSinif”);</em></p><p><em>} catch (ClassNotFoundException e) {</em></p><p><em>// ClassNotFoundException durumunda buraya düşeriz</em></p><p><em>e.printStackTrace();</em></p><p><em>}</em></p><p><em>}</em></p><p><em>}</em></p><p>Bu örnekte, Class.forName(“BilinmeyenSinif”); satırı, belirtilen sınıf adını yüklemeye çalışır. Ancak, “BilinmeyenSinif” adında bir sınıf bulunmadığı için JVM ClassNotFoundException fırlatır. Bu durum, sınıf adının yanlış yazıldığı veya var olmadığı bir durumu temsil eder.</p><p>ClassNotFoundException durumu, sınıf adlarını dinamik olarak belirleyerek veya yükleme işlemlerini yürütürken kullanıcı tarafından tanımlanan sınıfların yüklenmesi sırasında sıkça karşılaşılır. Programlar dinamik olarak sınıfları yüklerken veya sınıf adlarını kullanıcı girişi veya dış kaynaklardan alırken bu tür bir durum ortaya çıkabilir.</p><p><strong>20.</strong> <strong>NoClassDefFoundError ne zaman fırlatılır, açıklayınız?</strong></p><p>NoClassDefFoundError, JVM’nin bir sınıfı yüklemeye çalıştığında sınıfın tanımının bulunamaması durumunda ortaya çıkan bir hatadır. Bu hatanın sebepleri şunlar olabilir:</p><p>Sınıf Tanımının Bulunamaması:</p><p>Sınıfın tanımı compile (derleme) aşamasında var olabilir, ancak runtime (çalışma) aşamasında bu tanım bulunamazsa NoClassDefFoundError hatası ortaya çıkar.</p><p>Yanlış Sınıf Adı:</p><p>Sınıf adının yanlış yazılması veya belirtilen sınıf adının geçerli bir sınıfı işaret etmemesi durumunda bu hata ortaya çıkabilir.</p><p>Classpath Problemleri:</p><p>Sınıfın byte kodlarını içeren sınıf dosyasının veya sınıf dizininin, classpath üzerinde bulunamaması durumunda bu hatayla karşılaşılabilir.</p><p>Byte Kod Dosyasının Kaldırılması veya Değiştirilmesi:</p><p>Sınıfın byte kodlarını içeren dosyanın silinmesi veya değiştirilmesi durumunda, JVM sınıfı yükleyemez ve NoClassDefFoundError hatası alınabilir.</p><p>Örnek bir durumu göstermek için:</p><p><em>public class Main {</em></p><p><em>public static void main(String[] args) {</em></p><p><em>try {</em></p><p><em>// BilinmeyenSınıf adındaki sınıfı yüklemeye çalışıyoruz</em></p><p><em>BilinmeyenSinif obj = new BilinmeyenSinif();</em></p><p><em>} catch (NoClassDefFoundError e) {</em></p><p><em>// NoClassDefFoundError durumunda buraya düşeriz</em></p><p><em>e.printStackTrace();</em></p><p><em>}</em></p><p><em>}</em></p><p><em>}</em></p><p>Bu örnekte, BilinmeyenSinif adında bir sınıfı yüklemeye çalıştık, ancak bu sınıfın tanımı bulunamadığı için NoClassDefFoundError hatası alırız. Bu hatanın genellikle sınıfın adının yanlış yazılması, classpath sorunları veya sınıf dosyasının eksik veya bozuk olması gibi sebepleri vardır.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0302780702e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java Mülakatlara Hazırlananlar İçin Türkçe Soru ve Cevaplar]]></title>
            <link>https://medium.com/@ozguraltug06/java-m%C3%BClakatlara-haz%C4%B1rlananlar-i%CC%87%C3%A7in-t%C3%BCrk%C3%A7e-soru-ve-cevaplar-e795c3595b51?source=rss-6391bbd52a20------2</link>
            <guid isPermaLink="false">https://medium.com/p/e795c3595b51</guid>
            <dc:creator><![CDATA[Özgür Altuğ]]></dc:creator>
            <pubDate>Tue, 07 Nov 2023 19:33:31 GMT</pubDate>
            <atom:updated>2023-11-07T19:33:31.708Z</atom:updated>
            <content:encoded><![CDATA[<p>Java, yazılım geliştirme dünyasında yaygın olarak kullanılan bir programlama dili olarak öne çıkıyor. Büyük ölçüde platform bağımsız olması, güvenilirliği, taşınabilirliği ve geniş kullanım alanlarıyla Java, hem yeni başlayanlar hem de deneyimli geliştiriciler için popüler bir seçenek haline gelmiştir. Java, özellikle büyük ölçekli uygulamaların geliştirilmesi ve çoklu platformlarda çalıştırılması gerektiği durumlarda tercih edilen bir dil olmuştur.</p><p>Java mülakatları, yazılım geliştirme pozisyonlarına başvuran adaylar için sıkça karşılaşılan bir aşamadır. İyi bir Java geliştirici olmak, temel Java kavramlarına ve daha derinlemesine konulara hakim olmayı gerektirir. Bu mülakat soru koleksiyonu, hem Java dünyasına yeni başlayanlar hem de deneyimli geliştiriciler için faydalı olabilecek çeşitli sorular içermektedir.</p><p>Bu sorular, Java diline ilişkin temel kavramlardan başlayarak daha ileri seviyede konulara kadar uzanmaktadır. Mülakat sırasında bu soruları yanıtlamak, hem bilgi seviyenizi hem de pratik becerilerinizi değerlendirmenize yardımcı olacaktır. Hazırlık yaparken bu soruları gözden geçirmek, Java mülakatlarına daha fazla özgüvenle girebilmenize yardımcı olacaktır.</p><p>Aşağıda, Java mülakatları sırasında karşılaşabileceğiniz 50 soruyu bulacaksınız. Bu sorular, Java programlaması hakkındaki bilgi düzeyinizi ve uygulama yeteneklerinizi test etmek için tasarlanmıştır. Soruları yanıtlarken dikkatli ve mantıklı bir şekilde düşünmeye çalışın. Her bir soru, Java’nın farklı yönlerini kapsamaktadır ve sizi daha iyi bir Java geliştirici olma yolunda ilerletebilir.</p><p>Ayrıca Java öğrenmek isteyenleri veya hızlı tekrar yapmak isteyenleri <a href="https://www.youtube.com/@rehberkod">@rehberkod</a> youtube kanalıma bekliyorum…</p><p>Hazırsanız, başlayalım. İyi şanslar!</p><p><strong>1.</strong> <strong>Java’da “static blocks” ve “static initializers” olarak adlandırılan yapılar nelerdir?</strong></p><p>Classın yüklendiği veya ilk kez kullanılmaya başladığı zaman çalıştırılan kod bloklarıdır. Bu yapılar, sınıfın genel başlatma işlemlerini gerçekleştirmek için kullanılır.</p><p>“Static blocks” veya “static initializers” olarak adlandırılan bu bloklar aynı şeyi ifade eder ve sınıfın yüklendiği an veya ilk kez kullanılmadan önce çalışır. Bu bloklar, genellikle sınıfın sabitlerini, statik değişkenlerini veya diğer başlangıç işlemlerini yapmak için kullanılır. Özellikle classın ilk yüklendiği anlarda bu tür işlemler yapmak önemlidir, çünkü bu işlemler yalnızca bir kez gerçekleşmelidir.</p><p>Aşağıda, Java’da static blokların nasıl kullanılacağına dair örnek bir kod parçası bulunmaktadır:</p><blockquote>public class MyClass {</blockquote><blockquote>// Static initializer block</blockquote><blockquote>static {</blockquote><blockquote>// Bu blok sınıf yüklendiğinde çalışacak kodu içerir.</blockquote><blockquote>System.out.println(“MyClass sınıfı yüklendi.”);</blockquote><blockquote>}</blockquote><blockquote>// Diğer sınıf içeriği</blockquote><blockquote>// …</blockquote><blockquote>}</blockquote><p><strong>2.</strong> <strong>Bir constructor’ı başka bir constructor’dan nasıl çağırırız?</strong></p><p>Bir constructor içinden başka bir constructor’ı çağırmak için this() yöntemini kullanabiliriz. Ancak bu işlemi kullanırken bazı kısıtlamalara dikkat etmemiz gerekmektedir:</p><p>this() çağrısı, constructor içindeki ilk ifade olmalıdır: this() çağrısı, constructor içindeki diğer herhangi bir işlemden veya ifadeden önce gelmelidir. Yani, constructor içinde bir başka işlemi veya ifadeyi çalıştırmadan önce this() yöntemiyle diğer bir constructor’ı çağırmanız gerekmektedir.</p><p>Bir constructor içinde birden fazla this() çağrısı kullanılamaz: Bir constructor içinde sadece bir this() çağrısı kullanabilirsiniz. Aynı constructor içinde birden fazla this() çağrısı yapılmasına izin verilmez.</p><p>Örnek:</p><blockquote>public class MyClass {</blockquote><blockquote>private int value;</blockquote><blockquote>public MyClass() {</blockquote><blockquote>this(0); // Bu, diğer constructor’ı çağırır</blockquote><blockquote>// Başka işlemler</blockquote><blockquote>}</blockquote><blockquote>public MyClass(int value) {</blockquote><blockquote>this.value = value;</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Yukarıdaki örnekte, this(0) ifadesi, MyClass sınıfının parametresiz constructor’ından çağrı yapar ve bu çağrı, constructor içindeki ilk ifade olarak kullanılmıştır. Bu iki kurala uyulduğunda, constructor chaining (zincirleme çağrı) işlemi sorunsuz bir şekilde çalışır ve sınıfın farklı constructor’ları arasında kod tekrarı önlenmiş olur.</p><p><strong>3.</strong> <strong>Java’da method overriding nedir?</strong></p><p>Java’da method overriding, bir alt sınıfın, üst sınıfında zaten tanımlanmış bir metodun belirli bir uygulamasını sağlamasına izin veren bir nesne yönelimli programlama kavramıdır. Bir alt sınıf, üst sınıfındaki bir metodun adı, parametre türleri (imza) ve dönüş türü ile aynı olduğunda, bu metodun üzerine yazdığı söylenir.</p><p>Java’da method overriding’i neden ve ne zaman kullanırız:</p><p>4. <strong>Özelleştirme:</strong> Method overriding’i kullanırsınız çünkü bir alt sınıfta belirli bir metodun özelleştirilmiş bir uygulamasını sağlamak istiyorsunuz. Örneğin, bir <strong>Araç</strong> üst sınıfınızda bir <strong>motoruCalistir</strong> metodunuz olsun, ardından <strong>Araç</strong> sınıfının bir alt sınıfı olan <strong>Araba</strong> sınıfında, <strong>motoruCalistir</strong> metodunu bir arabanın özgü özelliklerine göre yeniden tanımlayabilirsiniz.</p><p>4. <strong>Polimorfizm:</strong> Method overriding, polimorfizmin önemli bir parçasıdır. Bu, farklı alt sınıfların nesnelerini genel bir üst sınıf olarak ele almanıza olanak tanır. Bir nesne üzerinde bir metodu bir üst sınıf referansı kullanarak çağırabilirsiniz ve alt sınıfta üzerine yazılmış bir metod çalıştırılır. Bu, daha genel ve esnek kod yazmak için kullanışlıdır.</p><p>Örneğin, bir <strong>Araç</strong> referansı kullanarak bir <strong>Araba</strong> nesnesinin <strong>motoruCalistir</strong> metodunu çağırdığınızda, bu metodun <strong>Araba</strong> sınıfındaki üzerine yazılmış hali çalışır.</p><p>Aşağıda örnek bir Java kodu bulunmaktadır:</p><blockquote>class Araç {</blockquote><blockquote>void motoruCalistir() {</blockquote><blockquote>System.out.println(“Bir aracın motoru çalıştırılıyor”);</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><blockquote>class Araba extends Araç {</blockquote><blockquote>@Override</blockquote><blockquote>void motoruCalistir() {</blockquote><blockquote>System.out.println(“Bir arabanın motoru çalıştırılıyor”);</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><blockquote>public class Ana {</blockquote><blockquote>public static void main(String[] args) {</blockquote><blockquote>Araç araç = new Araba();</blockquote><blockquote>araç.motoruCalistir(); // Araba sınıfındaki üzerine yazılmış metod çalışır</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Yukarıdaki örnekte, <strong>motoruCalistir</strong> metodu <strong>Araba</strong> sınıfında üzerine yazılmıştır ve bir <strong>Araç</strong> referansı kullanılarak bu metodu çağırdığınızda, <strong>Araba</strong> sınıfındaki üzerine yazılmış <strong>motoruCalistir</strong> metodu çalışır. Bu, Java’da method overriding ve polimorfizm kavramlarını gösterir.</p><p><strong>4.</strong> <strong>Java’da “süper” anahtar kelimesi nedir?</strong></p><p>Java’da “super” anahtar kelimesi, bir alt sınıfın üst sınıfının değişkenlerine, metodlarına veya constructor’ına erişmek için kullanılan bir mekanizmadır. Bu anahtar kelime, aşağıdaki iki şekilde kullanılabilir:</p><p>1. <strong>İlk form, üst sınıf constructor’ını çağırmak için kullanılır:</strong> Alt sınıfın kendi constructor’ının içinde, üst sınıfın constructor’ını çağırmak için “super” anahtar kelimesi kullanılabilir. Bu, alt sınıfın constructor’ının işini tamamladıktan sonra üst sınıfın constructor’ının çalışmasını sağlar.</p><p>Örnek:</p><blockquote><strong>class ÜstSınıf {</strong></blockquote><blockquote><strong>ÜstSınıf() {</strong></blockquote><blockquote><strong>System.out.println(“Üst sınıfın yapıcısı”);</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>class AltSınıf extends ÜstSınıf {</strong></blockquote><blockquote><strong>AltSınıf() {</strong></blockquote><blockquote><strong>super(); // Üst sınıfın constructor’ını çağır</strong></blockquote><blockquote><strong>System.out.println(“Alt sınıfın yapıcısı”);</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>}</strong></blockquote><p>2. <strong>İkinci form, üst sınıf değişkenleri ve metodlarını çağırmak için kullanılır:</strong> Bir alt sınıf içinde, üst sınıfın değişkenlerine veya metodlarına erişmek isterseniz “super” anahtar kelimesini kullanabilirsiniz. Bu, üst sınıfın değişkenleri veya metodları alt sınıf tarafından aynı isimle aynı isimle aşırı yazıldıysa dahi üst sınıfın üyelerine erişmenizi sağlar.</p><p>Örnek:</p><blockquote><strong>class ÜstSınıf {</strong></blockquote><blockquote><strong>int sayı = 10;</strong></blockquote><blockquote><strong>void metot() {</strong></blockquote><blockquote><strong>System.out.println(“Üst sınıfın metodu”);</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>class AltSınıf extends ÜstSınıf {</strong></blockquote><blockquote><strong>int sayı = 20;</strong></blockquote><blockquote><strong>void metot() {</strong></blockquote><blockquote><strong>System.out.println(“Alt sınıfın metodu”);</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>void örnekMetod() {</strong></blockquote><blockquote><strong>System.out.println(super.sayı); // Üst sınıfın sayısını yazdır</strong></blockquote><blockquote><strong>super.metot(); // Üst sınıfın metodu çağrılır</strong></blockquote><blockquote><strong>}</strong></blockquote><blockquote><strong>}</strong></blockquote><p>Yani “super” anahtar kelimesi, alt sınıfın üst sınıfının üyelerine erişmesine izin verir, aynı isimdeki üyelerin üzerine yazılmasına rağmen bu üyelere erişim sağlar. “super” her zaman birinci ifade olmalıdır, yani bir yöntemde veya yapıcıda ilk kullanılan ifade olmalıdır.</p><p><strong>5.</strong> <strong>Java’da metod overloading ve metod overriding arasındaki farklar nelerdir?</strong></p><p>Metot Overloading aynı class içinde gerçekleşir.</p><p>Metot Overriding iki farklı class arasında gerçekleşir, yani bir üst class (superclass) ve bir alt class (subclass) arasında.</p><p>Metot Overloading te Miras (inheritance) kullanımı zorunlu değildir, yani aynı sınıf içindeki metotların farklı sürümlerini oluştururken, sınıfın kendisi üzerinde çalışılır.</p><p>Metot Overriding te Miras (inheritance) kullanılır, yani bir sınıfın diğer sınıfın özelliklerini alması ve bu özellikleri değiştirmesi gereklidir.</p><p>Overloading metotların dönüş türü (return type) aynı olmak zorunda değildir.</p><p>Overriding metotların dönüş türü aynı olmalıdır.</p><p>Metot Overloading te parametreler farklı olmalıdır, yani aynı metot adı, ancak farklı parametre listeleri kullanılır.</p><p>Metot Overriding te parametreler aynı olmalıdır, yani aşırı yazan metot aynı isimde ve aynı parametre listesi ile yazılmalıdır.</p><p>Statik çok biçimlilik (static polymorphism) metot overloading ile elde edilir. Hangi metotun çağrılacağı derleme zamanında belirlenir.</p><p>Dinamik çok biçimlilik (dynamic polymorphism) metot overriding ile elde edilir. Hangi metotun çağrılacağı çalışma zamanında belirlenir.</p><p>Overloading sırasında bir metot diğerini gizleyemez. Yani, aynı classta overloading metotlar birbirlerini gizleyemezler.</p><p>Overriding sırasında alt classın metodu, üst classın metotunu gizler. Yani, aynı isimde ve aynı parametre listesi ile yazılmışsa, alt classın metodu üst classın metotunu gizler ve çağrıldığında alt classın metodu çalışır.</p><p><strong>6.</strong> <strong>Abstract Class ve interface arasındaki farklar nelerdir?</strong></p><p>İnterface yalnızca soyut (abstract) metotları içerir.</p><p>Abstract sınıf, soyut metotlar, somut metotlar veya her ikisini de içerebilir.</p><p>İnterfacedeki metotların erişim belirleyicileri (access specifiers) her zaman public olmalıdır.</p><p>Somut (concrete) sınıfın aksine, soyut sınıfın metotlarının erişim belirleyicileri (access specifiers) daha esnek olabilir; yalnızca private kullanılamaz.</p><p>İnterfacede tanımlanan değişkenler her zaman public, static ve final olmalıdır.</p><p>Abstract sınıf içindeki değişkenler, private dışında diğer erişim belirleyicilerini kullanabilir.</p><p>Java’da çoklu kalıtımı İnterfaceler kullanılarak uygularız.</p><p>Java’da abstract sınıflarla çoklu kalıtımı başaramayız, yani bir sınıf yalnızca bir soyut sınıftan türeyebilir.</p><p>Bir İnterface i uygulamak için “implements” anahtar kelimesi kullanılır.</p><p>Bir soyut sınıfı uygulamak için “extends” anahtar kelimesi kullanılır.</p><p><strong>7.</strong> <strong>Java için neden platformdan bağımsızdır ifadesi kullanılır?</strong></p><p>Java’nın platform bağımsız olmasının en önemli özelliği, Java’nın kaynak kodunun herhangi bir platform üzerinde çalıştırılabilmesidir. Diğer birçok programlama dilinde, kaynak kodu derlendikten sonra platforma özgü bir yürütülebilir dosya oluşturulur. Bu dosyalar farklı işletim sistemleri ve platformlarda çalışmayabilir. Ancak Java’da, kaynak kodu “javac” derleyicisi tarafından derlendiğinde, “.class” uzantılı yürütülebilir bir dosya oluşturulur.</p><p>Bu “.class” dosyası, Java tarafından üretilen “byte code” adı verilen bir tür ara dil kodu içerir. Byte code, sadece Java Sanal Makineleri (JVM) tarafından yorumlanabilir. Sun Microsystems (şu anda Oracle Corporation) tarafından geliştirilen JVM’ler, farklı platformlar için sunulur. Bu nedenle, bir Java programının oluşturduğu byte code Windows ortamında üretildiyse, aynı byte code Linux ortamında da çalıştırılabilir. Bu, Java’nın platform bağımsızlığını sağlar.</p><p>Özetle, Java’nın platform bağımsız olmasının nedeni, byte code’un JVM’ler aracılığıyla farklı platformlarda yorumlanabilmesidir. Bu, aynı Java programının farklı işletim sistemlerinde ve donanım platformlarında çalıştırılabilmesini mümkün kılar.</p><p><strong>8.</strong> <strong>Java’da overloading methodu nedir?</strong></p><p>Java’da metod overloading, aynı isme sahip ancak farklı parametrelerle tanımlanmış iki veya daha fazla metodu ifade eder. Java’da metodlar aynı isme sahip olabilir, ancak parametrelerin türleri, sırası veya sayısı farklı olmalıdır. Metod overloading sayesinde aynı isim altında birden fazla metot tanımlayabiliriz ve bu metotlar farklı işlevler veya girdilerle çalışabilir.</p><p>Java’da static polymorphism, yani hangi metodu çağıracağınızın derleme zamanında belirlenmesi, metod overloading ile elde edilir. Derleyici, overloading metotların ismini, parametre sayısını ve parametre türlerini dikkate alarak hangi metodu çağıracağınızı belirler. Bu nedenle, aynı metot ismi altında birden fazla metot tanımlanabilir ve bu metotlar overload edilmiş olur.</p><p>Önemli bir not olarak, metotların dönüş türü (return type) metot signature ın bir parçası değildir. Yani, farklı dönüş türlerine sahip metotlar overload edilebilir, ancak bu dönüş türleri metodu çağırmak için yeterli değildir. Hangi metodu çağıracağınızı belirlemek için derleyici, metot ismi ve parametrelerin türleri ve sırası gibi faktörleri kullanır. Bu nedenle, overload edilmiş metotlar aynı ismi paylaşsa bile farklı parametrelerle çağrılabilir.</p><p><strong>9.</strong> <strong>JIT (Just-In-Time) derleyiciyisi nedir?</strong></p><p>JIT derleyici, Java bytecode’unu çalıştırılabilir kod haline getiren bir bileşen olarak JVM içinde bulunur. Ancak, JIT derleyici bir Java programını tamamen çalıştırılabilir kod haline dönüştürmez. Bunun yerine, Java programı çalıştırıldığında ihtiyaç duyulan kısımları bytecode’dan çalıştırılabilir kod haline çevirir. Böylece, Java programı daha etkili bir şekilde çalıştırılabilir.</p><p><strong>10.</strong> <strong>Java’da bytecode nedir?</strong></p><p>Bytecode, bir Java programının kaynak kodunun derlenmesi sonucunda oluşturulan .class dosyasında bulunan bir dizi talimat setidir. Bytecode, bir makine bağımsız dil olarak kabul edilir ve yalnızca Java Sanal Makinesi (JVM) tarafından yürütülmek üzere tasarlanmış talimatları içerir. Yani, Java kaynak kodu derlendikten sonra oluşturulan bytecode, JVM tarafından yorumlanabilir ve çalıştırılabilir. Bu, Java’nın platform bağımsızlığına katkıda bulunan önemli bir özelliktir, çünkü bytecode aynıdır, ancak farklı işletim sistemlerinde çalışan JVM’ler tarafından yürütülür.</p><p><strong>11.</strong> <strong>Java’da this() ve süper() keywords leri arasındaki farklar nelerdir?</strong></p><p>this():</p><p>this() anahtar kelimesi, aynı sınıf içerisindeki bir başka yapıyı (genellikle bir başka constructor’ı) çağırmak için kullanılır.</p><p>Genellikle overloading constructor’ları çağırmak veya aynı sınıf içindeki diğer constructor’larda tekrarlayan kodu önlemek için kullanılır.</p><p>this() anahtar kelimesi, aynı sınıf içindeki başka bir constructor’ı çağırmadan önce kullanılır ve constructor içinde sadece bir kere çağrılabilir.</p><p>İlgili constructor çağrıldıktan sonra bu constructor içindeki diğer işlemler devam eder.</p><p>super():</p><p>super() anahtar kelimesi, alt sınıfın constructor’ı içinde üst sınıfın constructor’ını çağırmak için kullanılır.</p><p>Java’da her alt sınıfın bir üst sınıfı vardır, ve bu nedenle alt sınıf constructor’ları, üst sınıf constructor’ını çağırmalıdır.</p><p>super() anahtar kelimesi, alt sınıf constructor’ının ilk satırında kullanılmalıdır.</p><p><strong>12.</strong> <strong>Java’da class kavramı nedir?</strong></p><p>Bir class, Nesne Yönelimli Programlama (OOP) içinde temel birimlerden biridir.</p><p>Bir class, nesnelerin tasarım şablonunu veya yapısını temsil eder.</p><p>Classlar, değişkenler (variables) ve metotları (methods) tanımlarlar.</p><p>Her class, belirli bir türde nesnelerin oluşturulabileceğini tanımlar. Örneğin, “Department” classı, departman türünde nesnelerin oluşturulabileceğini belirtir.</p><p>Java’da tüm program yapısı classlar içinde tanımlanır.</p><p>Bir Java uygulamasında en az bir class ve bir “main” metodu (main method) bulunmalıdır.</p><p>Bir class tanımı “class” anahtar kelimesi ile başlar.</p><p>Class tanımı, aynı isme sahip bir class dosyasında (“.java” uzantılı) saklanmalıdır.</p><p>Class dosyalarının adı, classın adı ile aynı olmalıdır.</p><p>Class dosyaları derlendiğinde JVM (Java Sanal Makinesi), classı yükler ve bir “.class” dosyası oluşturur.</p><p>Program çalıştırıldığında, classı çalıştırır ve “main” metodu çalıştırır.</p><p>Yani, classlar, nesnelerin oluşturulmasını ve programların yapılandırılmasını tanımlamak için kullanılan temel yapı taşlarıdır.</p><p><strong>13.</strong> <strong>Java’da object nedir?</strong></p><p>Bir object, bir classın örneğidir. Yani, class bir türün (type) tasarımını veya şablonunu belirtirken, objectler bu türün somut örnekleridir.</p><p>Her object, bir classa aittir. Class, objectlerin temel yapısını ve davranışını tanımlar.</p><p>Bir object, iki temel bileşeni içerir: durum (state) ve davranış (behavior).</p><p>Durum, objectin özelliklerinin veya niteliklerinin değerlerini temsil eder. Bu özellikler, classın tanımladığı öznitelikler veya değişkenler olabilir.</p><p>Davranış, objectin yapabileceği işlemleri veya yöntemleri temsil eder. Bu yöntemler, classın tanımladığı işlevleri ifade eder.</p><p>Objectler ayrıca “örnek”(instance) olarak da adlandırılır.</p><p>Bir classın objectini oluşturmak için, new anahtar kelimesini kullanarak bir örnek (instance) oluşturulur. Örneğin, FirstClass classının bir örneğini oluşturmak için aşağıdaki gibi bir kod kullanılabilir:</p><p>FirstClass f = new FirstClass();</p><p>Burada f, FirstClass classının bir örneğini temsil eder ve bu örneğe erişmek için kullanılır.</p><p>Yani, bir object, bir classın belirlediği yapı ve davranışa sahip somut bir örneğidir. Objectler, classların özelliklerini ve işlevlerini kullanarak programın temel taşlarıdır ve programlar objectler aracılığıyla veri ve işlemler üzerinde çalışırlar.</p><p><strong>14.</strong> <strong>Method nedir?</strong></p><p>Java’da bir “metot” (method), bir class içindeki işlevsel bir bloktur ve belirli bir nesne üzerinde çalıştırılabilir. İşte</p><p>Metotlar, bir class içindeki işlevleri veya operasyonları tanımlarlar. Bir classın nesneleri, bu metotları çağırarak belirli işlemleri gerçekleştirebilir.</p><p>Bir metot, şu temel unsurları içerir:</p><p>Metot adı: Metodun adı, metodu tanımlayan bir isimdir. Bu isimle metodu çağırabilirsiniz.</p><p>Parametreler veya argümanlar: Metot, çalıştırılması sırasında aldığı verileri işlemek için parametreleri kullanabilir. Parametreler metot adının hemen sonra parantez içinde belirtilir.</p><p>Dönüş türü: Metot, bir sonuç döndürebilir veya dönüş yapmayabilir. Dönüş türü, metotun ne tür bir değer dönebileceğini belirtir. Örneğin, int veya float gibi bir veri türü olabilir.</p><p>Metotların temel sözdizimi şu şekildedir:</p><p>dönüş_türü metot_adı(parametre_listesi) {</p><p>// Metodun işlevselliğini tanımlayan kod burada bulunur</p><p>}</p><p>Örnek bir metot tanımı:</p><blockquote>public float toplama(int a, int b, int c) {</blockquote><blockquote>int sonuc = a + b + c;</blockquote><blockquote>return sonuc;</blockquote><blockquote>}</blockquote><p>Metotlar birden fazla parametre alabilir ve parametreler virgülle ayrılır. Metotun işlevselliğini tanımlayan kod, süslü parantezlerin içine yerleştirilir.</p><p>Sonuç olarak, bir metot Java programında bir işlemi veya işlevselliği temsil eder. Bu işlevselliği çağırmak için metot adını ve gerekli parametreleri kullanabilirsiniz. Metotlar, programlarınızın düzenli ve modüler olmasına yardımcı olan önemli yapı taşlarıdır.</p><p><strong>15.</strong> <strong>Encapsulation nedir?</strong></p><p>Encapsulation, verileri bir tekil birim olan class içine sarmak veya yerleştirmek ve verilerin yanlış kullanımından korumak işlemidir.</p><p>Encapsulation (kapsülleme), verileri ve bu verilere erişim yöntemlerini (metotları) bir class içinde toplama ve düzenleme sürecini ifade eder. Bu, verilerin dışarıdan doğrudan erişilmesini sınırlar ve kontrol altına alır.</p><p>Java’da encapsulation, verilere erişim kontrolü ile desteklenir. Bu kontrol, dört erişim kontrol belirleyicisi (modifier) kullanılarak sağlanır: public, private, protected ve default (veya package-private).</p><p>Bir örnek üzerinden açıklamak gerekirse, bir “araba” classını ele alalım. Bir arabanın içinde birçok parça ve veri bulunur, ancak sürücünün sadece arabayı nasıl çalıştıracağı ve nasıl durduracağı hakkında bilgiye ihtiyacı vardır. Bu nedenle, encapsulation kullanarak sürücüye sadece gerekli olan bilgileri sunabilir ve geri kalan bilgileri gizleyebiliriz.</p><p>Encapsulation, verilere erişimi kontrol altına alarak veri güvenliğini artırır ve bir classın iç yapısını gizleyerek daha sade ve anlaşılır bir arabirim sunar.</p><p>Sonuç olarak, encapsulation (kapsülleme), verilerin gizliliğini korumak ve erişimi kontrol altına almak için kullanılan bir nesne yönelimli programlama prensibidir. Bu prensip, daha güvenli ve modüler yazılım geliştirmeye yardımcı olur.</p><p><strong>16.</strong> <strong>Java’da main methodu neden public, static ve void olarak tanımlanmıştır?</strong></p><p>public: public bir erişim belirleyicisidir ve bu, main methodunun diğer sınıflardan (veya sınıf dışından) erişilebilir olmasını sağlar. Java programlarının başlangıç noktası olan main methodu, JVM (Java Virtual Machine) tarafından çağrılmalıdır, bu nedenle public olarak işaretlenmesi, başka sınıflardan veya JVM’den erişilebilir olmasını sağlar.</p><p>static: main methodu nesne oluşturmadan çağrılabilmesi gereken özel bir methoddur. Java programının başlangıcı için kullanıldığı için bu method, sınıf düzeyinde (yani sınıfın bir örneği oluşturulmadan) çağrılmalıdır. Bu nedenle static olarak işaretlenir. Bir method static olarak işaretlendiğinde, bu method sınıfın bir örneği (nesnesi) oluşturulmadan çağrılabilir.</p><p>void: main methodu bir sonuç döndürmez. Java’da methodlar belirli bir türde bir değer dönebilirler, ancak main methodu programın başlangıcı olduğu için herhangi bir değer döndürmesine gerek yoktur. Bu nedenle void olarak işaretlenir. Yani, main methodu işlemleri gerçekleştirir, ancak herhangi bir değer geri döndürmez.</p><p>Özetle, public static void main(String[] args) ifadesi, Java programlarının başlangıcı için özel olarak tanımlanan main methodunun imzasını belirtir ve bu imza, programın başlatılmasını ve çalıştırılmasını sağlar. Bu nedenle, main methodu programın giriş noktasıdır ve yukarıdaki imza, Java’nın bu noktayı bulmasına ve çalıştırmasına yardımcı olur.</p><p><strong>17.</strong> <strong>Java’da constructor nedir?</strong></p><p>Java’da bir constructor, bir sınıfın örneklerini oluştururken bu örneklerin başlangıç değerlerini ayarlamak için kullanılan özel bir metoddur. İnşa edici metodlar, bir sınıfın yapısını ve davranışlarını belirlemek için kullanılan bir tür yapıcı işlevi görürler. İnşa ediciler, yeni bir nesne oluşturulduğunda otomatik olarak çağrılır ve nesnenin başlangıç durumunu ayarlamak için kullanılır.</p><p>Java’da iki temel türde constructor bulunur:</p><p>Default Constructor (Parametresiz Constructor): Bir sınıfın herhangi bir constructor tanımlanmadığında, Java otomatik olarak bir varsayılan constructor sağlar. Bu varsayılan constructor, sınıfın nesnelerini oluştururken herhangi bir argüman almayan ve genellikle sınıfın içinde herhangi bir işlem yapmayan bir constructor’dır. Örnek olarak:</p><blockquote>public class MyClass {</blockquote><blockquote>public MyClass() {</blockquote><blockquote>// Default constructor</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Parameterized Constructor (Parametre Alan Constructor): Parametreli constructorlar, nesneleri oluştururken belirli parametreleri alabilir ve bu parametrelere dayalı olarak nesnenin başlangıç durumunu ayarlar. Bu tür constructorlar genellikle sınıfın özelliklerini başlangıç değerleri ile doldurmak için kullanılır. Örnek olarak:</p><blockquote>public class Person {</blockquote><blockquote>private String name;</blockquote><blockquote>private int age;</blockquote><blockquote>public Person(String name, int age) {</blockquote><blockquote>this.name = name;</blockquote><blockquote>this.age = age;</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Yukarıdaki örnek, Person sınıfı için bir parametreli constructor gösterir. Bu constructor, name ve age adlı iki parametre alır ve bu parametreleri kullanarak Person nesnesinin başlangıç değerlerini ayarlar.</p><p>Constructorlar, sınıfın yapısını tanımlamak ve sınıf örneklerini başlatmak için önemli bir rol oynarlar ve Java’da sınıf oluştururken yaygın olarak kullanılırlar.</p><p><strong>18.</strong> <strong>Java’da length ve length() ifadeleri arasındaki fark nedir?</strong></p><p>length(): Bu, bir String nesnesinin metin uzunluğunu döndüren bir metoddur. length() bir metin nesnesinin karakterlerinin sayısını verir. Örnek olarak:</p><p>String str = “Hello World”;</p><p>int uzunluk = str.length(); // uzunluk, “Hello World” ifadesinin karakter sayısı olan 11&#39;i döndürecektir.</p><p>length() yöntemi bir String nesnesi üzerinde çağrılır ve bu nesnenin uzunluğunu karakter sayısı olarak döndürür.</p><p>length: Bu, dizilerin veya dizilimlerin (arrays) uzunluğunu döndüren bir özelliktir. Dizilerin boyutunu (kaç eleman içerdiğini) belirtir. Örneğin:</p><p>String[] days = {“Sun”, “Mon”, “Wed”, “Thu”, “Fri”, “Sat”};</p><p>int uzunluk = days.length; // uzunluk, “days” dizisinin içerdiği eleman sayısı olan 6&#39;yı döndürecektir.</p><p>length özelliği, bir dizi veya dizilim üzerinde kullanılır ve bu yapıdaki elemanların sayısını verir.</p><p>Özetle, length() bir String nesnesinin karakter sayısını döndürürken, length özelliği bir dizi veya dizilimin içerdiği eleman sayısını döndürür. Bu iki ifade arasındaki fark, kullanıldıkları veri türüne ve kullanım bağlamına dayanır.</p><p><strong>19.</strong> <strong>ASCII (American Standard Code for Information Interchange) kodu nedir?</strong></p><p>ASCII, bilgisayarların ve iletişim sistemlerinin metin karakterlerini temsil etmek için kullanılan bir karakter kodlaması standardıdır. ASCII, 0&#39;dan 127&#39;ye kadar olan karakterleri tanımlayan yedi bitlik bir karakter setidir. 0 ile 127 arasındaki karakterler, İngilizce alfabesi, rakamlar, temel noktalama işaretleri ve bazı kontrol karakterlerini içerir.</p><p>Bu standart, özellikle eski bilgisayar sistemlerinde ve yazılım uygulamalarında yaygın olarak kullanılmıştır. ASCII karakter seti, İngilizce dilindeki metinlerin temsilinde işe yarar, ancak diğer dillerin karakterlerini veya sembollerini desteklemez. Bu nedenle, ASCII karakter seti sınırlı bir karakter yelpazesine sahiptir ve yalnızca temel İngilizce karakterleri içerir.</p><p>Açıklamada belirtildiği gibi, C programlama dili geleneksel olarak ASCII karakterlerini kullanır. Bu nedenle, C dilinde yazılmış programlar genellikle İngilizce karakterlerle yazılmalıdır. Başka dillerdeki karakterlerin veya sembollerin C programlarına dahil edilmesi zordur, çünkü ASCII karakter seti bu karakterleri desteklemez.</p><p>Günümüzde, daha geniş karakter kümelerini ve uluslararası dil desteğini sağlayan Unicode gibi karakter kodlamaları, ASCII’nin yerini almıştır. Unicode, dünya genelinde farklı dillerdeki karakterlerin ve sembollerin temsilini sağlar ve çok daha geniş bir karakter yelpazesi sunar.</p><p><strong>20.</strong> <strong>Unicode nedir?</strong></p><p>Unicode, dünya genelinde tüm dillerin karakterlerini ve sembollerini temsil etmek amacıyla oluşturulan bir karakter kümesidir. Unicode, Unicode Consortium adlı bir kuruluş tarafından geliştirilmiştir ve farklı dillerdeki karakterlerin ve sembollerin benzersiz bir kodlanmış temsilini sağlar.</p><p>Aşağıdaki noktalara dikkat edilmelidir:</p><p>Unicode Karakter Aralığı: Unicode karakterleri 16 bit (2 byte) olarak temsil edilir, bu da toplamda 65,536 (0&#39;dan 65,535&#39;e kadar) farklı karakteri içeren bir karakter kümesi sağlar. Bu, dünya genelindeki birçok dilin karakterlerini içerir.</p><p>Java ve Unicode: Java, Unicode karakterlerini destekler. Java programlama dilindeki String’ler, tanımlayıcılar (identifiers) ve yorumlar (comments) gibi metin verileri için Unicode kullanılır. Bu, Java’nın farklı dillerdeki karakterleri ve sembolleri doğru bir şekilde temsil etmesini sağlar. Örneğin, Java’da Telugu dilindeki karakterler kullanılarak tanımlayıcılar (değişken adları) oluşturulabilir ve Telugu dilinde yorumlar yazılabilir.</p><p>Java’nın Unicode’ı desteklemesi, çok dilli uygulamalar geliştirmek için kullanışlıdır. Java, uluslararası yazılım geliştirme için yaygın olarak tercih edilen bir dildir çünkü Unicode desteği sayesinde dünya genelinde kullanılabilir ve çoklu dil desteği sağlar.</p><p><strong>21.</strong> <strong>Java’da ‘&gt;&gt;’ ve ‘&gt;&gt;&gt;’ operatörleri arasındaki fark nedir?</strong></p><p>‘&gt;&gt;’ (Sağa Kaydırma Operatörü):</p><p>‘&gt;&gt;’ operatörü, bir değerin tüm bitlerini belirtilen sayıda sağa kaydırmak için kullanılır.</p><p>Sağa kaydırma işlemi yapılırken, en sol taraftaki bitin değeri önceki değerine göre korunur ve sağa doğru belirtilen sayıda boşluk bırakılır.</p><p>Eğer kaydırma işlemi sonucunda boşalan bitler, kaydırma işlemi yapılan sayının işareti ile doldurulur. Yani, eğer işaretli bir tamsayıyı kaydırıyorsanız, sol taraftaki boşluklar işaret biti (negatiflik) ile doldurulur.</p><p>Örnek:</p><blockquote>int a = 15;</blockquote><blockquote>a = a &gt;&gt; 3; // Sonuç: 1</blockquote><p>Bu örnekte, 15 değeri ikili olarak ‘00001111’ temsil edilir ve bu değer 3 kez sağa kaydırıldığında ‘00000001’ elde edilir.</p><p>‘&gt;&gt;&gt;’ (Sağa Kaydırma Operatörü — İşaretsiz):</p><p>‘&gt;&gt;&gt;’ operatörü, sağa kaydırma işlemi yaparken işaretsiz (unsigned) bir kaydırma gerçekleştirir.</p><p>Bu operatör ile kaydırma işlemi sonucunda boşalan bitler her zaman sıfır ile doldurulur. Yani, işaret biti (negatiflik) göz ardı edilir.</p><p>Örnek:</p><blockquote>int a = -15;</blockquote><blockquote>a = a &gt;&gt;&gt; 3; // Sonuç: 536870909</blockquote><p>Bu örnekte, -15 değeri ikili olarak ‘11111111111111111111111111110001’ temsil edilir. Ancak ‘&gt;&gt;&gt;’ operatörü ile 3 kez sağa kaydırıldığında, işaret biti dikkate alınmaz ve sonuç ‘00011111111111111111111111111100’ olur. Bu nedenle sonuç işaretsiz bir tam sayı olarak 536870909&#39;dur.</p><p>‘&gt;&gt;’ ve ‘&gt;&gt;&gt;’ operatörleri arasındaki temel fark, işaret bitinin (negatiflik) nasıl işlendiği ve kaydırma işlemi sonucunda boşalan bitlerin nasıl doldurulduğudur.</p><p><strong>22.</strong> <strong>Java kodlama standartları veya Java kodlama kurallarını (Java Coding Conventions) açıklayınız?</strong></p><p>Java kodlama standartları veya Java kodlama kuralları (Java Coding Conventions) genellikle yazılım geliştiricilerin kodlarını daha okunaklı ve tutarlı bir şekilde yazmalarına yardımcı olur. Java sınıfları için kodlama standartlarına dair önemli noktalar:</p><p>Sınıf İsimleri Büyük Harfle Başlamalıdır:</p><p>Java sınıf isimleri büyük harfle başlamalıdır. Bu, sınıfları diğer öğelerden (değişkenler, metotlar vb.) ayırt etmek için kullanışlıdır.</p><p>Örnek: Çalışan veya MüşteriHesabı</p><p>Sınıf İsimleri İsimler Olmalıdır:</p><p>Sınıf isimleri genellikle isim (noun) olmalıdır ve sınıfın temsil ettiği nesnenin ne olduğunu açıkça yansıtmalıdır.</p><p>Örnek: Çalışan sınıfı bir çalışanı temsil ediyorsa, ismi Çalışan olabilir.</p><p>Birden Fazla Kelimeden Oluşan Sınıf İsimleri:</p><p>Eğer bir sınıf adı birden fazla kelimeden oluşuyorsa, iç kelimelerin ilk harfi büyük olmalıdır. Buna “Camel Case” denir.</p><p>Örnek: MüşteriHesabı, KişiProfilBilgisi, Kutuİşlemi</p><p>Java kodlama standartları, kodun okunabilirliğini artırmak, yazılım projelerini daha kolay yönetilebilir hale getirmek ve geliştiriciler arasında tutarlılık sağlamak amacıyla kullanılır. Bu kurallara uymak, kodun daha iyi anlaşılmasını ve bakımını kolaylaştırır ve daha profesyonel bir yazılım geliştirme süreci sunar.</p><p><strong>23.</strong> <strong>Java’da interfaceler için standartlar nelerdir?</strong></p><p>İnterface İsmi Büyük Harfle Başlamalıdır:</p><p>Java interface isimleri büyük harfle başlamalıdır. Bu, interfaceleri diğer öğelerden (sınıflar, değişkenler vb.) ayırt etmek için kullanışlıdır.</p><p>Örnek: Çalıştırılabilir, Serileştirilebilir</p><p>İnterface İsimleri Sıfat Olmalıdır:</p><p>İnterface isimleri genellikle sıfat (adjective) olmalıdır ve interface in temsil ettiği yeteneği, özelliği veya davranışı açıkça yansıtmalıdır.</p><p>Örnek: ÇoğulUyumluluk interface i, bir sınıfın çoğul uyumlu (Runnable) olduğunu ifade eder. Serileştirilebilir interface i, bir sınıfın serileştirilebilir (Serializable) olduğunu ifade eder. Klonlanabilir interface i, bir sınıfın klonlanabilir (Cloneable) olduğunu ifade eder.</p><p>Java’da bu tür kodlama standartları ve adlandırma kuralları, kodun okunabilirliğini artırır ve yazılım projelerini daha anlaşılır ve yönetilebilir hale getirir. Ayrıca, diğer geliştiriciler için daha açık ve tutarlı bir programlama deneyimi sağlar. Bu standartlara uyum, yazılım geliştirme sürecini daha profesyonel hale getirir ve işbirliğini kolaylaştırır.</p><p><strong>24.</strong> <strong>Java’da metod kullanım standartları nelerdir?</strong></p><p>Metot İsimleri Küçük Harfle Başlamalıdır:</p><p>Java metot isimleri küçük harfle başlamalıdır. Bu, metotları diğer öğelerden (sınıflar, arayüzler, değişkenler vb.) ayırt etmek için kullanışlıdır.</p><p>Örnek: toString(), hesapla().</p><p>Metot İsimleri Genellikle Fiil Olmalıdır:</p><p>Metot isimleri genellikle fiil (verb) olmalıdır çünkü metotlar bir eylemi gerçekleştirir.</p><p>Örnek: hesapla(), oluştur(), güncelle().</p><p>Birden Fazla Kelimeden Oluşan Metot İsimleri:</p><p>Eğer bir metot adı birden fazla kelimeden oluşuyorsa, iç kelimelerin ilk harfi büyük olmalıdır. Buna “Camel Case” denir.</p><p>Örnek: getArabaAdı(), getArabaNumarası(). Bu şekilde metot adları daha okunaklı ve anlaşılır olur.</p><p>Metot İsmi Genellikle Fiil ve İsimin Kombinasyonu Olmalıdır:</p><p>Metot ismi, metotun ne yaptığını ve neyi döndürdüğünü açıkça ifade etmelidir. Genellikle bir eylemi (fiil) ve bu eylemin üzerinde çalıştığı nesneyi (isim) içerir.</p><p>Örnek: getArabaAdı() metodu, bir arabanın adını döndürür. hesaplaToplam() metodu, bir toplamı hesaplar ve sonucu döndürür.</p><p>Java’da bu tür kodlama standartları ve adlandırma kuralları, kodun okunabilirliğini artırır ve yazılım projelerini daha anlaşılır ve yönetilebilir hale getirir. Ayrıca, diğer geliştiriciler için daha açık ve tutarlı bir programlama deneyimi sağlar. Bu standartlara uyum, yazılım geliştirme sürecini daha profesyonel hale getirir ve işbirliğini kolaylaştırır.</p><p><strong>25.</strong> <strong>Java’da variable(değişken) kullanım standartları nelerdir?</strong></p><p>Değişken İsimleri Küçük Harfle Başlamalıdır:</p><p>Java değişken isimleri küçük harfle başlamalıdır. Bu, değişkenleri diğer öğelerden (sınıflar, metotlar, arayüzler vb.) ayırt etmek için kullanışlıdır.</p><p>Örnek: string, değer, çalışanAdı, çalışanMaaşı.</p><p>Değişken İsimleri Genellikle İsim Olmalıdır:</p><p>Değişken isimleri genellikle isim (noun) olmalıdır ve değişkenin temsil ettiği verinin ne olduğunu açıkça yansıtmalıdır.</p><p>Örnek: sayı, müşteri, kitapAdı, öğrenciNotları.</p><p>Kısa ve Anlamlı İsimler Tavsiye Edilir:</p><p>Değişken isimleri kısa olmalıdır, ancak anlamlı olmalıdır. Değişkenin temsil ettiği veriyi açıkça ifade etmelidir.</p><p>Örnek: yaş, fiyat, ad, boyut.</p><p>Birden Fazla Kelimeden Oluşan Değişken İsimleri:</p><p>Eğer bir değişken adı birden fazla kelimeden oluşuyorsa, iç kelimelerin ilk harfi büyük olmalıdır. Buna “Camel Case” denir.</p><p>Örnek: çalışanAdı, öğrenciNotları, kitapListesi.</p><p>Java’da bu tür kodlama standartları ve adlandırma kuralları, kodun okunabilirliğini artırır ve yazılım projelerini daha anlaşılır ve yönetilebilir hale getirir. Ayrıca, diğer geliştiriciler için daha açık ve tutarlı bir programlama deneyimi sağlar. Bu standartlara uyum, yazılım geliştirme sürecini daha profesyonel hale getirir ve işbirliğini kolaylaştırır.</p><p><strong>26.</strong> <strong>Java’da sabitler (constant) ile ilgili standartlar nelerdir?</strong></p><p>Sabitler yalnızca büyük harflerle yazılmalıdır.</p><p>Örneğin:</p><blockquote>public static final int MAX_VALUE = 100;</blockquote><blockquote>public static final String DATABASE_NAME = “MyDatabase”;</blockquote><p>Sabit isimleri iki kelimenin birleşiminden oluşuyorsa, bu kelimeler alt çizgi (_) ile ayrılmalıdır. Bu, sabitlerin okunabilirliğini artırır.</p><p>Örneğin:</p><blockquote>public static final int MAX_LENGTH = 255;</blockquote><blockquote>public static final String API_KEY = “my_api_key”;</blockquote><p>Sabit isimleri genellikle isimler veya nesnelerle ilişkilendirilen kelimeler olmalıdır. Bu, sabitin ne tür bir veriyi temsil ettiğini açıkça belirtir.</p><p>Örneğin:</p><blockquote>public static final int DEFAULT_TIMEOUT = 5000;</blockquote><blockquote>public static final String ERROR_MESSAGE = “An error occurred.”;</blockquote><p>Bu kurallar, sabitlerin kodunuzda daha iyi anlaşılabilir ve bakımı daha kolay olmasını sağlar. Ayrıca, sabitlerin değerlerinin değiştirilemez (final) olduğundan emin olur, böylece bu değerlerin yanlışlıkla değiştirilmesini engeller ve kodunuzun güvenilirliğini artırır.</p><p><strong>27.</strong> <strong>Java’da “IS-A” ilişkisi nedir?</strong></p><p>Java’da “IS-A” ilişkisi, genellikle miras (inheritance) olarak bilinir. “IS-A” ilişkisi, bir sınıfın başka bir sınıftan türetildiği veya kalıtım aldığı durumu ifade eder. Bu türetilen sınıf, türeten sınıfın özelliklerini ve davranışlarını devralır. Java’da “IS-A” ilişkisi, “extends” anahtar kelimesi kullanılarak gerçekleştirilir. Miras alınan sınıf, miras alan sınıfın bir alt sınıfıdır.</p><p>Örnek olarak, “Araç” sınıfını ele alalım:</p><blockquote>public class Araç {</blockquote><blockquote>// Araç sınıfına ait özellikler ve davranışlar burada tanımlanır.</blockquote><blockquote>}</blockquote><p>Bu durumda, “Araç” sınıfı bir üst sınıftır. Şimdi bu sınıftan türetilen “Motosiklet” ve “Araba” sınıflarını düşünelim:</p><blockquote>public class Motosiklet extends Araç {</blockquote><blockquote>// Motosiklet sınıfının özellikleri ve davranışları burada tanımlanır.</blockquote><blockquote>}</blockquote><blockquote>public class Araba extends Araç {</blockquote><blockquote>// Araba sınıfının özellikleri ve davranışları burada tanımlanır.</blockquote><blockquote>}</blockquote><p>Bu durumda, “Motosiklet” ve “Araba” sınıfları “Araç” sınıfından türetilmiştir ve “Araç” sınıfının özelliklerini ve davranışlarını miras almışlardır. Bu, “Motosiklet bir Araç’tır” ve “Araba bir Araç’tır” ifadelerini doğru bir şekilde ifade eder.</p><p>Miras (inheritance), kodun yeniden kullanılabilirliğini artırır ve sınıf hiyerarşileri oluşturarak nesne yönelimli programlamada (OOP) önemli bir konsepttir.</p><p><strong>28.</strong> <strong>Java’da “HAS-A” ilişkisi nedir?</strong></p><p>Java’da “HAS-A” ilişkisi, “kompozisyon” veya “birleştirme (aggregation)” olarak da bilinir. “HAS-A” ilişkisi, bir sınıfın başka bir sınıfı içerdiği veya ona sahip olduğu bir ilişkiyi ifade eder. Bu ilişki, bir sınıfın başka bir sınıfın nesnesini içermesini veya bu nesneye erişim sağlamasını içerir. “HAS-A” ilişkisi, Java’da “extends” anahtar kelimesi gibi özel bir anahtar kelime kullanılmadan gerçekleştirilir.</p><p>Örnek olarak, “Araba” sınıfının içinde bir “Motor” sınıfına sahip olduğunu düşünelim:</p><blockquote>public class Motor {</blockquote><blockquote>// Motor sınıfına ait özellikler ve davranışlar burada tanımlanır.</blockquote><blockquote>}</blockquote><blockquote>public class Araba {</blockquote><blockquote>private Motor motor; // Araba sınıfı, Motor sınıfının bir nesnesini içerir.</blockquote><blockquote>public Araba() {</blockquote><blockquote>motor = new Motor(); // Araba nesnesi oluşturulduğunda bir Motor nesnesi de oluşturulur.</blockquote><blockquote>}</blockquote><blockquote>// Araba sınıfına ait diğer özellikler ve davranışlar burada tanımlanır.</blockquote><blockquote>}</blockquote><p>Bu durumda, “Araba” sınıfı bir “Motor” nesnesini içeriyor. Bu, “Araba HAS-A Motor” ilişkisini ifade eder. “Araba” sınıfı, “Motor” sınıfının özelliklerine ve davranışlarına erişebilir ve onları kullanabilir.</p><p>“HAS-A” ilişkisi, kodun yeniden kullanılabilirliğini artırır, çünkü bir sınıfın başka bir sınıfın özelliklerini veya davranışlarını içermesi sayesinde, kod tekrarı önlenir ve kodun daha modüler ve anlaşılır hale gelmesine yardımcı olur. Bu tür ilişkiler, nesne yönelimli programlamanın (OOP) temel kavramlarından biridir.</p><p><strong>29.</strong> <strong>Java’da “IS-A” ilişkisi ile “HAS-A” ilişkisi arasındaki farklar nelerdir?</strong></p><p>“IS-A” ilişkisi</p><p>“HAS-A” ilişkisi</p><p>Miras (inheritance) ilişkisi olarak bilinir.</p><p>Kompozisyon (composition) veya birleştirme (aggregation) ilişkisi olarak bilinir.</p><p>Bir sınıfın başka bir sınıftan türetildiği veya kalıtım aldığı bir ilişkiyi ifade eder.</p><p>Bir sınıfın başka bir sınıfı içerdiği veya ona sahip olduğu bir ilişkiyi ifade eder.</p><p>“extends” anahtar kelimesi kullanılarak gerçekleştirilir. Türetilen sınıf, türeten sınıfın bir alt sınıfıdır.</p><p>Özel bir anahtar kelime kullanılmadan gerçekleştirilir. Sınıf içinde diğer bir sınıfın nesnesi saklanarak veya bu nesneye erişilerek gerçekleştirilir.</p><p>Örnek: “Araba bir Taşıt’tır.” (“Car is a Vehicle.”) ifadesi doğru bir IS-A ilişkisini ifade eder.</p><p>Örnek: “Araba bir Motor’a sahiptir.” (“Car has an Engine.”) ifadesi doğru bir HAS-A ilişkisini ifade eder.</p><p>Mirasın başlıca avantajı kodun yeniden kullanılabilirliğini artırmaktır.</p><p>Burada dikkat edilmesi gereken önemli bir nokta, HAS-A ilişkisi ile türetilen sınıfın ayrı bir sınıf olduğudur. Yani Araba sınıfı Motor sınıfının bir alt sınıfı değil, yalnızca bir Motor nesnesine sahiptir.</p><p><strong>30.</strong> <strong>Java’da instanceof operatörünü açıklayınız?</strong></p><p>instanceof operatörü, bir nesnenin hangi türde olduğunu test etmek için kullanılır. Bu operatör, bir referans ifadesini ve bir hedef türü alır ve referans ifadesinin belirtilen hedef türün bir alt türü olup olmadığını kontrol eder. instanceof ifadesi doğru (true) veya yanlış (false) bir değer döndürür.</p><p>instanceof operatörünün sözdizimi şu şekildedir:</p><p>&lt;referans ifadesi&gt; instanceof &lt;hedef tür&gt;</p><p>instanceof, aşağıdaki iki sonucu üretebilir:</p><p>true: Eğer referans ifadesi, hedef türün bir alt türü ise, instanceof operatörü true değeri döndürür.</p><p>false: Eğer referans ifadesi hedef türün bir alt türü değilse veya referans ifadesi null ise, instanceof operatörü false değeri döndürür.</p><p>Örnek olarak, aşağıdaki Java kodu instanceof operatörünü kullanır:</p><blockquote>public class InstanceOfOrnegi {</blockquote><blockquote>public static void main(String[] args) {</blockquote><blockquote>Integer a = new Integer(5);</blockquote><blockquote>if (a instanceof java.lang.Integer) {</blockquote><blockquote>System.out.println(true);</blockquote><blockquote>} else {</blockquote><blockquote>System.out.println(false);</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Bu örnekte, a değişkeni bir Integer türündedir ve a instanceof java.lang.Integer ifadesi true değeri döndürür çünkü a, java.lang.Integer türünün bir örneğidir.</p><p>instanceof operatörü, nesnelerin türlerini kontrol etmek, uygun işlemleri gerçekleştirmek ve tip güvenliğini sağlamak için kullanılır. Eğer bir referansın belirli bir türün bir alt türü olup olmadığını kontrol etmeniz gerekiyorsa, instanceof operatörü bu işlemi yapmanıza yardımcı olur.</p><p><strong>31.</strong> <strong>Java’da null nedir?</strong></p><p>“null” terimi Java’da bir referans değişkeninin hiçbir değeri göstermediğini ifade eder. Yani, bir referans değişkeni tanımlanmıştır, ancak herhangi bir nesneye işaret etmez. Bu, değişkenin bellekte bir konumu olmasına rağmen içeriğinin boş olduğu anlamına gelir.</p><p>Örneğin, şu kodda bir Employee (Çalışan) nesnesi oluşturmadan sadece bir referans değişkeni tanımlanmıştır:</p><p>Employee employee;</p><p>Bu durumda, employee değişkeni null olarak başlatılmıştır çünkü henüz hiçbir çalışan nesnesi oluşturulmamıştır. Bu değişkeni kullanmak istediğinizde, önce bir Employee nesnesi oluşturmanız ve employee değişkenine atamanız gerekecektir. Aksi halde, employee değişkeni hâlâ null değerini tutacaktır.</p><p>null değeri, bir referansın hiçbir nesneye işaret etmediğini belirtmek için kullanılır ve Java’da sıklıkla kontrol ifadelerinde ve nesne durumunu belirlemede kullanılır.</p><p><strong>32.</strong> <strong>Java’da bir kaynak dosyası içinde birden fazla sınıf tanımlanabilir mi?</strong></p><p>Evet, Java’da bir kaynak dosyası içinde birden fazla sınıf tanımlayabilirsiniz, ancak bu nadiren kullanılır ve genellikle tavsiye edilmez. Ancak, bu sınıflardan yalnızca bir tanesi public olarak işaretlenebilir. Başka bir deyişle, kaynak dosyanızda yalnızca bir tane public anahtar kelimesiyle belirtilen sınıf olabilir. Diğer sınıflar public anahtar kelimesiyle belirtilmez.</p><p>Eğer aynı kaynak dosyasında birden fazla public sınıf tanımlamaya çalışırsak, aşağıdaki derleme hatasını alırız:</p><p>“The public type must be defined in its own file”</p><p>“public türü kendi dosyasında tanımlanmalıdır.”</p><p>Yani, her public sınıfın kendi ayrı kaynak dosyasına sahip olması gerekmektedir. Diğer sınıflar ise public anahtar kelimesi olmadan aynı dosyada tanımlanabilir ve aynı paket içinde kullanılabilir. Bu, sınıfları düzenli ve daha okunaklı tutmak için genellikle daha iyi bir uygulama yöntemidir.</p><p><strong>33.</strong> <strong>Java’da, en üst düzey sınıflar (top level class), hangi erişim belirleyiciler (access modifier) kullanılabilir?</strong></p><p>Java’da, en üst düzey sınıflar (top level class), yani bir dosyanın ana sınıfları için yalnızca iki erişim belirleyici (access modifier) kullanılabilir: public ve varsayılan (default). İşte bu erişim belirleyicilerin anlamları:</p><p>public: Eğer bir sınıf public olarak işaretlenirse, bu sınıf her yerden erişilebilir hale gelir. Başka paketlerdeki sınıflar da bu sınıfa erişebilirler.</p><p>Varsayılan (default): Eğer bir sınıf herhangi bir erişim belirleyici belirtilmeden (yani public, private, protected veya package-private olmaksızın) tanımlanırsa, bu sınıf sadece aynı paket içindeki diğer sınıflar tarafından erişilebilir. Başka paketlerdeki sınıflar bu sınıfa erişemezler.</p><p>Ancak, bir en üst düzey sınıfı private veya protected gibi diğer erişim belirleyicileri ile işaretlemeye çalışırsanız, aşağıdaki derleme hatasını alırsınız:</p><p>Illegal Modifier for the class only public, abstract and final are permitted.</p><p>“Sınıf için yalnızca public, abstract ve final erişim belirleyicileri izinlidir.”</p><p>Bu hatanın anlamı, en üst düzey sınıfların yalnızca public, abstract ve final erişim belirleyicileri ile işaretlenebileceğidir. Bu sınıfları diğer erişim belirleyicileriyle işaretlemek geçerli değildir.</p><p><strong>34.</strong> <strong>Java’da “package” neyi ifade eder?</strong></p><p>Java’da “package” (paket), ilgili sınıfları, arayüzleri ve enumları tek bir modül içinde gruplamak için kullanılan bir mekanizmadır. Bir paket, Java programınızı düzenlemek ve sınıfları mantıklı bir şekilde gruplandırmak için kullanabileceğiniz bir araçtır. Paketler, kodunuzu daha düzenli, okunaklı ve sürdürülebilir hale getirmenize yardımcı olur.</p><p>Paketlerin kullanımı şu şekilde tanımlanır:</p><p>Bir paket, package anahtar kelimesi ile tanımlanır, örneğin: package com.example.myapp;</p><p>Paket adı küçük harfle yazılmalıdır, bu bir kodlama kuralıdır.</p><p>Paketlerin ana amaçları şunlardır:</p><p>İsim Çakışmalarını Çözmek: Java’da farklı paketlerde aynı isme sahip sınıflar veya arabirimler olabilir. Paketler, bu tür çakışmaları önlemek veya çözmek için kullanılır. Her paket, kendi isim alanını tanımlar ve bu sayede isim çakışmaları önlenir.</p><p>Görünürlük Kontrolü: Paketler aynı zamanda sınıflar ve arabirimlerin başka sınıflar tarafından erişimini kontrol etmek için kullanılabilir. Varsayılan erişim (package-private) olarak işaretlenen sınıflar ve üyeler, yalnızca aynı paket içindeki diğer sınıflardan erişilebilir. Bu, sınıflarınızın daha iyi bir şekilde kapsülasyonunu sağlar ve kodunuzu daha güvenli hale getirir.</p><p>Özetlemek gerekirse, Java’da paketler, kodunuzu düzenlemek, isim çakışmalarını önlemek ve sınıflarınızın erişimini kontrol etmek için kullanılan önemli bir araçtır. Bu sayede daha büyük ve karmaşık Java uygulamalarını daha iyi yönetebilirsiniz.</p><p><strong>35.</strong> <strong>Java’da bir kaynak dosyası içinde birden fazla “package” ifadesi (paket ifadesi) bulunabilir mi?</strong></p><p>Java’da bir kaynak dosyası içinde birden fazla “package” ifadesi (paket ifadesi) bulunamaz. Bir Java programında yalnızca en fazla bir “package” ifadesi bulunabilir. Eğer kaynak dosyanızda birden fazla “package” ifadesi bulunursa, derleme hatası alırsınız. Yani, aynı kaynak dosyasında yalnızca bir kez “package” ifadesi kullanabilirsiniz. İşte bu kuralın Türkçe açıklaması:</p><p>Bir Java programında sadece bir “package” ifadesi bulunabilir. Eğer kaynak dosyasında birden fazla “package” ifadesi bulunursa, derleme hatası alırsınız. Yani, bir kaynak dosyası sadece bir paket içinde tanımlanabilir ve bu paket ifadesi dosyanın en başında yer almalıdır. Bu, Java’nın paketleme ve isim alanı yönetimi kurallarına uygunluğu sağlamak için gereklidir.</p><p><strong>36.</strong> <strong>Java’da import ifadesinden sonra package ifadesini tanımlayabilir miyiz?</strong></p><p>Java dilinde package ifadesi her zaman import ifadesinden önce gelmelidir ve package ifadesi bir Java kaynak dosyasındaki ilk ifade olmalıdır. Yani import ifadesinden önce bir package ifadesi tanımlanamaz. Ancak package ifadesinden önce yorum satırları (comment lines) bulunabilir. Java kaynak dosyalarında yorum satırları herhangi bir yerde bulunabilir ve kod tarafından görmezden gelinirler.</p><p>Örnek bir Java kaynak dosyası şu şekilde olabilir:</p><blockquote>// Bu bir yorum satırıdır</blockquote><blockquote>package com.example.mypackage; // Bu geçerli bir package ifadesidir</blockquote><blockquote>import java.util.List;</blockquote><blockquote>public class MyClass {</blockquote><blockquote>// Sınıfın kodu burada gelir</blockquote><blockquote>}</blockquote><p>Yukarıdaki örnekte, yorum satırları package ifadesinden önce bulunabilir, ancak package ifadesi import ifadesinden önce gelmelidir. Bu, Java dilindeki sözdizimi kurallarına uyar.</p><p><strong>37.</strong> <strong>Java’da identifiers lar nelerdir?</strong></p><p>· Tanımlayıcılar harf, alt çizgi (_) veya dolar işareti ($) ile başlamalıdır.</p><p>· Tanımlayıcılar rakamla başlayamaz.</p><p>· Tanımlayıcıların uzunluğunda bir sınırlama yoktur, ancak 15 karakterden fazla kullanmak önerilmez.</p><p>· Java tanımlayıcıları büyük-küçük harf duyarlıdır. Yani büyük harfle başlayan bir tanımlayıcı ile küçük harfle başlayan bir tanımlayıcı farklı kabul edilir.</p><p>· İlk harf bir harf (alfabe karakteri), alt çizgi (_) veya dolar işareti ($) olabilir. İkinci harften itibaren rakam da kullanabilirsiniz.</p><p>· Java’da tanımlayıcılar için ayrılmış (rezerve) kelimeleri kullanmamalıyız. Yani özel anlam taşıyan Java anahtar kelimeleri, sınıf adları, metod adları veya değişken adları olarak kullanılmamalıdır.</p><p>Örnek birkaç tanımlayıcı:</p><p>Doğru tanımlanmış bir sınıf adı: public class Araba { }</p><p>Doğru tanımlanmış bir metod adı: public void hesaplaSonucu() { }</p><p>Doğru tanımlanmış bir değişken adı: int ogrenciSayisi = 42;</p><p>Bu kurallara uyarak tanımlayıcılarınızı oluşturmalı ve Java kodunuzu daha anlaşılır ve düzenli hale getirmelisiniz.</p><p><strong>38.</strong> <strong>Java’da erişim değiştiricileri (access modifiers) nelerdir?</strong></p><p>Java’da erişim değiştiricileri (access modifiers), sınıfların, metodların ve üyelerin (değişkenlerin veya alanların) erişim seviyelerini kontrol etmek için kullanılan önemli özelliklerden biridir. Erişim kontrolü, bir sınıfın, metodun veya üyenin nasıl kullanılabileceğini belirler ve bu sayede yanlış kullanımların önüne geçilir.</p><p>Java’da üç tür erişim değiştirici bulunur:</p><p>public: Bu değiştirici, bir sınıfın, metodun veya üyenin herhangi bir yerden (başka bir sınıf, paket veya proje içinden) erişilebilir olduğunu belirtir. Yani herkes bu öğeye erişebilir.</p><p>private: Bu değiştirici, bir sınıfın, metodun veya üyenin sadece kendi sınıfı içinden erişilebilir olduğunu belirtir. Başka sınıflar bu öğeye erişemez.</p><p>protected: Bu değiştirici, bir sınıfın, metodun veya üyenin aynı paket içinde veya alt sınıflardan erişilebilir olduğunu belirtir. Diğer paketlerden gelen sınıfların erişimi sınırlanır.</p><p>Ayrıca, bir erişim değiştirici belirtilmezse, varsayılan bir erişim düzeyi kullanılır. Varsayılan erişim, sadece aynı paketten erişimi sağlar. Başka bir paketten gelen sınıflar bu öğeye erişemezler.</p><p>Özetle, erişim değiştiricileri Java’da sınıfların, metodların ve üyelerin kimler tarafından erişebileceğini kontrol etmek için kullanılır ve bu, kodun daha güvenli ve düzenli olmasına yardımcı olur.</p><p><strong>39.</strong> <strong>Java’da sınıflar için kullanılabilecek erişim değiştiricileri (access modifiers) nelerdir?</strong></p><p>· public: Bir sınıfın erişim düzeyi “public” olarak belirtilirse, bu sınıf her yerden erişilebilir hale gelir. Yani, bu sınıfın neredeyse her yerden erişilebilir olur. İşte erişim seviyesi “public” olan bir sınıfın hangi yerlerden erişilebileceği:</p><p>Aynı sınıf içinde (kendi sınıfının içinde).</p><p>Aynı paket içinde yer alan başka sınıflar ve alt sınıflar tarafından erişilebilir.</p><p>Aynı paket içinde yer alan başka sınıflar ve alt sınıflar olmayan sınıflar tarafından erişilebilir.</p><p>Farklı bir paket içinde yer alan alt sınıflar tarafından erişilebilir.</p><p>Farklı bir paket içinde yer alan alt sınıflar olmayan sınıflar tarafından erişilebilir.</p><p>· Varsayılan (Default): Erişim değiştirici belirtilmediğinde, sınıfın erişim düzeyi “varsayılan” olarak kabul edilir. Varsayılan erişim, yalnızca aynı paket içinde bulunan sınıflar tarafından erişilebilir. Bu, paket düzeyinde erişim sağlar. Yani, sınıfın aynı paket içinde yer alan diğer sınıflar tarafından erişilebilir olduğu anlamına gelir.</p><p>Özetle, Java’da sınıflar için iki tür erişim değiştirici kullanılabilir: “public” ve “varsayılan” (default). Bu değiştiriciler, sınıfların hangi yerlerden erişilebileceğini belirler ve kodun kontrol edilmesine yardımcı olur.</p><p><strong>40.</strong> <strong>Java’da, metodlar için kullanılabilecek erişim değiştiricileri (access modifiers) nelerdir?</strong></p><p>· public: Bir metodun erişim düzeyi “public” olarak belirtilirse, bu metod her yerden erişilebilir hale gelir. Yani, bu metodun neredeyse her yerden erişilebilir olur. İşte erişim seviyesi “public” olan bir metodun hangi yerlerden erişilebileceği:</p><p>Aynı sınıf içinde (kendi sınıfının içinde).</p><p>Aynı paket içinde yer alan başka sınıflar ve alt sınıflar tarafından erişilebilir.</p><p>Aynı paket içinde yer alan başka sınıflar ve alt sınıflar olmayan sınıflar tarafından erişilebilir.</p><p>Farklı bir paket içinde yer alan alt sınıflar tarafından erişilebilir.</p><p>Farklı bir paket içinde yer alan alt sınıflar olmayan sınıflar tarafından erişilebilir.</p><p>· Varsayılan (Default): Erişim değiştirici belirtilmediğinde, bir metodun erişim düzeyi “varsayılan” olarak kabul edilir. Varsayılan erişim, yalnızca aynı paket içinde bulunan sınıflar ve alt sınıflar tarafından erişilebilir. Bu, paket düzeyinde erişim sağlar. Yani, metodun aynı paket içinde yer alan diğer sınıflar ve alt sınıflar tarafından erişilebilir olduğu anlamına gelir.</p><p>· protected: Bir metodun erişim düzeyi “protected” olarak belirtilirse, bu metod aynı sınıf, aynı paket içindeki sınıflar, alt sınıflar ve farklı paket içindeki alt sınıflar tarafından erişilebilir. Ancak, farklı bir paket içinde yer alan non-subclass (alt sınıf olmayan) sınıflar bu metoda erişemez.</p><p>· private: Bir metodun erişim düzeyi “private” olarak belirtilirse, bu metod sadece kendi sınıfı içinde erişilebilir hale gelir. Yani, başka sınıfların veya alt sınıfların bu metoda erişmesine izin verilmez.</p><p>Bu erişim değiştiricileri, metodların hangi yerlerden erişilebileceğini ve kimlerin bu metodları kullanabileceğini belirlemek için kullanılır. Bu, kodun güvenliğini ve düzenini sağlamak için önemlidir.</p><p><strong>41.</strong> <strong>Java’da final access modifier nedir?</strong></p><p>Final Class (Final Sınıf):</p><p>Bir sınıfın “final” olarak işaretlenmesi, bu sınıfın başka bir sınıf tarafından alt sınıf olarak genişletilmesini veya miras alınmasını önler.</p><p>Final bir sınıfın avantajı, güvenliği artırmaktır, yani bu sınıfın davranışı değiştirilemez.</p><p>Dezavantajı ise Java’nın nesne yönelimli programlama (OOP) kavramlarını kullanırken bu sınıfın miras alınamayacak olmasıdır.</p><p>Örnek:</p><blockquote>final class FinalClass {</blockquote><blockquote>// …</blockquote><blockquote>}</blockquote><p>Final Method (Final Metod):</p><p>Bir metodu “final” olarak işaretlemek, bu metodun alt sınıflar tarafından ezilememesini sağlar. Yani bu metodun davranışı değiştirilemez.</p><p>Metodların override edilmesini istemediğiniz durumlarda final metotlar kullanışlıdır.</p><p>Örnek:</p><blockquote>class BaseClass {</blockquote><blockquote>public final void finalMethod() {</blockquote><blockquote>// …</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Final Variable (Final Değişken):</p><p>Bir değişkeni “final” olarak işaretlemek, bu değişkenin bir kez değer atanabilen ve sonrasında değiştirilemeyen bir sabit gibi davranmasını sağlar.</p><p>Herhangi bir deneme değişkenin değerini değiştirmeye çalışmak derleme hatası verir.</p><p>Örnek:</p><blockquote>public class FinalVariableExample {</blockquote><blockquote>public static final int MY_CONSTANT = 42;</blockquote><blockquote>}</blockquote><p>Bu final erişim belirleyicileri, kodunuzun güvenliğini artırmak ve belirli durumlarda OOP kavramlarına (örneğin miras) karşı koruma sağlamak için kullanışlıdır. Ancak, bu belirleyicileri dikkatli bir şekilde kullanmalısınız, çünkü aşırı kullanıldığında kodunuzu esnekliğini kaybetmesine neden olabilirler.</p><p><strong>42.</strong> <strong>Java’da Abstract Classı açıklayınız?</strong></p><p>Java’da soyut sınıflar (abstract classes), bazı durumlarda bir sınıftaki tüm metodlara uygulama sağlayamayabileceğimiz durumlarla karşılaştığımızda kullanılırlar. Bu durumda, ilgili metodların uygulamasını, bu soyut sınıfı genişleten bir başka sınıfa bırakmak isteriz. Bir sınıfı soyut yapmak için “abstract” anahtar kelimesini kullanırız. Bir veya daha fazla soyut metod içeren her sınıf soyut olarak işaretlenir. Eğer soyut metotlar içeren bir sınıfı soyut olarak işaretlemezsek, derleme zamanında hata alırız ve şu hata mesajını alırız:</p><p>“Soyut metodları tanımlamak için &lt;sınıf adı&gt; sınıfı soyut bir sınıf olmalıdır.”</p><p>Örnek olarak, bir araç sınıfını ele alalım. Bu sınıfa uygulama sağlayamayabiliriz çünkü iki tekerlekli, dört tekerlekli vb. gibi farklı araç türleri olabilir. Bu durumda, araç sınıfını soyut yaparız. Araç sınıfında araçların ortak özellikleri soyut metodlar olarak tanımlanır. Araç sınıfını genişleten herhangi bir sınıf, bu metodları kendi uygulayacaktır. Alt sınıfın, bu soyut metodları uygulamakla yükümlüdür.</p><p>Soyut sınıfların önemli özellikleri şunlardır:</p><p>· Soyut sınıfların örnekleri oluşturulamaz.</p><p>· Soyut sınıflar, soyut metotlar, somut metotlar veya her ikisini içerebilir.</p><p>· Bir soyut sınıfı genişleten her sınıf, soyut sınıfın tüm metodlarını geçersiz kılmak (override) zorundadır.</p><p>· Bir soyut sınıf 0 veya daha fazla soyut metot içerebilir.</p><p>Örnek bir soyut sınıf:</p><blockquote>abstract class Shape {</blockquote><blockquote>// Soyut metotlar</blockquote><blockquote>public abstract double getArea();</blockquote><blockquote>public abstract double getPerimeter();</blockquote><blockquote>// Somut metot</blockquote><blockquote>public void displayInfo() {</blockquote><blockquote>System.out.println(“This is a shape.”);</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Soyut sınıflar, nesne yönelimli programlama (OOP) kavramlarını uygularken çok kullanışlıdır çünkü alt sınıfların belirli davranışları uygulamalarına olanak tanır.</p><p><strong>43.</strong> <strong>Abstract class larda constructor oluşturabilir miyiz?</strong></p><p>Evet, soyut sınıflarda da constructor oluşturabiliriz. Derleme hatası vermez. Ancak soyut sınıfların kendileri doğrudan örneklendirilemeyeceği (yani instantiate edilemeyeceği) için soyut bir sınıfın kendi constructor metodu, soyut sınıfın alt sınıfları için kullanılacaktır. Soyut sınıfın alt sınıfları bu constructor metodu çağırdığında, alt sınıfların başlatılmasına yardımcı olur.</p><p>Soyut sınıfların constructor metotları, alt sınıfların başlatılmasını ve inşa edilmesini sağlamak amacıyla kullanışlıdır. Bu constructor metotlar, alt sınıfın kendisine özgü inşa sürecini başlatmak için soyut sınıfın özelliklerine erişebilir.</p><p>Örneğin, aşağıdaki Java kodunda soyut bir sınıfın constructor metodu örneklendirilemeyen bir soyut sınıfın alt sınıfı tarafından çağrılmaktadır:</p><blockquote>abstract class Animal {</blockquote><blockquote>private String name;</blockquote><blockquote>public Animal(String name) {</blockquote><blockquote>this.name = name;</blockquote><blockquote>}</blockquote><blockquote>public String getName() {</blockquote><blockquote>return name;</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><blockquote>class Dog extends Animal {</blockquote><blockquote>public Dog(String name) {</blockquote><blockquote>super(name); // Soyut sınıfın kurucu metodu çağrılıyor</blockquote><blockquote>}</blockquote><blockquote>// Dog sınıfının kendi davranışları burada tanımlanabilir.</blockquote><blockquote>}</blockquote><p>Soyut sınıfın constructor metodu, alt sınıfın başlangıç durumunu ayarlamak için kullanıldığı için soyut sınıfların constructor metotları önemli bir işleve sahip olabilir. Ancak doğrudan bir soyut sınıf örneği oluşturamazsınız. Soyut sınıfın alt sınıflarını oluşturarak bu sınıfları kullanabilirsiniz.</p><p><strong>44.</strong> <strong>Java’da abstract methodlar nelerdir?</strong></p><p>Java’da soyut metodlar (abstract methods), herhangi bir işlem gövdesine sahip olmayan metodlardır. Soyut metodlar, “abstract” anahtar kelimesi kullanılarak ve metodun gövdesi yerine noktalı virgül (;) ile tanımlanır. Bir soyut metodun imzası şu şekildedir:</p><p>public abstract void &lt;metod adı&gt;();</p><p>Örnek olarak:</p><p>public abstract void getDetails();</p><p>Soyut metodların en önemli özelliği, soyut sınıflarda tanımlanmış olmalarıdır. Bir soyut sınıfta tanımlanan soyut metodlar, bu sınıfı genişleten alt sınıflar tarafından uygulama sağlanması gereken metotlardır. Soyut sınıfta tanımlanan soyut metodlar, alt sınıfların bu metodları kendi özel ihtiyaçlarına ve mantığına göre uygulamalarına olanak tanır.</p><p>Soyut metodlar, soyut sınıfın kalıtım yoluyla türetilen alt sınıflarının davranışını belirlemek için kullanılır ve bu şekilde soyut sınıfın davranışının şekillenmesine katkıda bulunurlar. Soyut sınıflar ve soyut metodlar, nesne yönelimli programlama (OOP) konseptlerinin uygulanmasına yardımcı olur.</p><p><strong>45.</strong> <strong>Java’da exception nedir?</strong></p><p>Java’da exception bir nesnedir. Exception, programımızda anormal durumlar ortaya çıktığında oluşturulurlar. Bu anormal durumlar, JVM (Java Sanal Makinesi) veya uygulama kodumuz tarafından oluşturulabilir. Tüm exception sınıfları “java.lang” paketi içinde tanımlanır. Başka bir deyişle, exception ları çalışma zamanı hataları olarak düşünebiliriz.</p><p>Exception, bir programın düzgün çalışmasını engelleyebilecek veya beklenmeyen bir durumu belirlemek için kullanılır. Örneğin, bir dosya okuma hatası, bir diziye erişim hatası veya sıfıra bölme hatası gibi durumlar istisnalara örnektir. Exception, bu tür hataların işlenmesine ve programın çalışmaya devam etmesine olanak tanır. Java’da, istisna işleme için try, catch, ve throw gibi anahtar kelimeler kullanılır.</p><p><strong>46.</strong> <strong>Java’da exceptionların çıkabileceği bazı durumları söyleyiniz?</strong></p><p>Java’da exceptionlar, programın normal akışının dışında ortaya çıkan ve işlenmesi gereken hatalı durumları temsil eder. İşte Java’da exceptionların ortaya çıkabileceği bazı durumlar ve bu durumların kısa açıklamaları:</p><p>Dizide Var Olmayan Bir Elemana Erişme: Bir dizinin belirli bir dizini veya elemanı bulunmuyorsa ve bu elemana erişmeye çalışırsanız<strong>, ArrayIndexOutOfBoundsException</strong> ortaya çıkabilir.</p><p>Sayıyı Dizeye veya Dizeden Sayıya Hatalı Dönüştürme: Bir sayıyı dize olarak temsil eden bir metin veya tam tersini dönüştürmeye çalışırken hatalı bir biçim kullanırsanız, <strong>NumberFormatException</strong> ortaya çıkabilir.</p><p>Geçersiz Sınıf Türü Dönüşümü: Bir sınıfın bir nesnesini başka bir sınıf türüne dönüştürmeye çalışırken uyumsuz bir tür dönüşüm yapmaya çalışırsanız, <strong>ClassCastException</strong> ortaya çıkabilir.</p><p>Arayüz veya Soyut Sınıf İçin Nesne Oluşturma: Java’da doğrudan bir arayüz veya soyut sınıf için bir nesne oluşturulamaz. Bu durumda, <strong>InstantiationException</strong> ortaya çıkabilir.</p><p>Bu exceptionlar, Java programlarının çalışma zamanında hatalarla başa çıkmasına yardımcı olur. Exception işleme mekanizması, bu tür hataları ele almak için try-catch blokları veya exceptionın yukarı yönlendirilmesini (throwing) içerir. Java programcıları, bu tür exceptionları tanımlayabilir, işleyebilir ve uygun şekilde yanıt verebilir.</p><p><strong>47.</strong> <strong>Java’da exception handle etme nedir?</strong></p><p>Java’da exception handling, bir programın çalışması sırasında normalden sapma veya hata durumlarının nasıl ele alınacağını belirleyen bir mekanizmadır. Programın normal akışı, bir hata durumu ortaya çıktığında kesintiye uğramamalıdır.</p><p>Programların çalışması sırasında birçok hata veya özel durum (exception) ortaya çıkabilir. Bu exceptionlar, veritabanına bağlanma hatası, dosya bulunamama hatası, dizi sınırının aşılması, matematiksel işlemlerde bölme sıfıra bölme hatası gibi çeşitli nedenlerle ortaya çıkabilir. Bu tür exceptionların programın çalışmasını durdurmasını veya çökmesini önlemek için exception handling kullanılır.</p><p>Exception işleme, programcılara hata durumlarını tanımlama, ele alma ve uygun bir şekilde yanıtlama olanağı sunar. Bu, programın daha güvenli ve daha düzenli bir şekilde çalışmasını sağlar. Java’da exception handling, try, catch, finally, ve throw anahtar kelimeleri gibi özgül yapılar kullanılarak gerçekleştirilir.</p><p>Örneğin, bir dosyanın okunmaya çalışıldığı bir programda, dosya bulunamazsa veya okuma hatası olursa, bu tür exceptionları yakalayarak programın düzgün bir şekilde çalışmasını sağlamak için exception handling kullanılabilir.</p><p>Java’da exception handling, programlarınızın daha güvenilir ve kullanıcı dostu olmasına yardımcı olur ve istenmeyen çökme durumlarını önler.</p><p><strong>48.</strong> <strong>Java’da error nedir?</strong></p><p>Java’da “hata” (error), Throwable sınıfının bir alt sınıfıdır. Hatalar, programın normal akışını durduran ve genellikle geri dönülemez olan ciddi sorunları temsil eder. Hataların programın akışını durdurmasının nedeni, genellikle bu hataların programın kontrolünün dışında olması veya programın düzeltemeyeceği kritik sorunlar olmasıdır. Hatalar programın çalışmasını sonlandırabilir.</p><p>Hatalar genellikle çeşitli çevresel faktörler veya sistem sorunları nedeniyle ortaya çıkar. Örnek olarak, bellek tükenmesi hatası (OutOfMemoryError), programın kullanılabilir belleği aşması nedeniyle ortaya çıkar. Bu tür hataların program tarafından düzeltilmesi veya ele alınması mümkün değildir çünkü programın kontrolü dışındaki faktörlerden kaynaklanır.</p><p>Bu nedenle, hatalar genellikle programlar tarafından ele alınmaz ve programın çalışmasını sonlandırır. İstisnalar (exceptions) genellikle program tarafından ele alınabilen ve düzeltilebilen hata durumlarını temsil ederken, hatalar genellikle programın kontrolünün dışında olan ve müdahale edilemeyen sorunları ifade eder. Özetle, hatalar programın çalışmasını sonlandırır ve çoğunlukla programcılar tarafından düzeltilmesi veya ele alınması gerekmeyen sorunlardır.</p><p><strong>49.</strong> <strong>Java’da exceptionı handle etmenin avantajları nelerdir?</strong></p><p>Java’da exception handle etmenin avantajları şunlar olabilir:</p><p>Normal Kodu İstisna İşleme Kodundan Ayırma: Java’da exception handle etme, programın normal akışını, hata durumlarını ele almak için ayrılmış kod bloklarından ayırmanıza olanak tanır. Bu, hata durumlarında programın ani ve abur-cubur şekilde sonlandırılmasını önler. Programın normal işlevselliği, istisna durumlarının kontrolünde etkilenmez.</p><p>Exception Türlerini Kategorize Etme: Java’da farklı türde exception durumları için özel exception sınıfları bulunur. Bu, programcıların her exception türüne özgü hata işleme kodları yazmasını sağlar. Bu, hataları daha spesifik ve anlamlı bir şekilde ele almayı mümkün kılar. Örneğin, bir dosya bulunamadığında “FileNotFoundException” gibi belirli bir exception türünü ele almak, daha açıklayıcı ve düzgün hata işleme sağlar.</p><p>Çağrı Yığını Mekanizması(Call stack mechanism): Bir metot bir exception fırlattığında ve bu exception hemen ele alınmazsa, exception çağrıldığı metodu çağıran yere (çağrı yığını) geri gönderilir. Bu, exception handle etme hiyerarşisini ve işlemeyi kolaylaştırır. Exception bir uygun işleyici buluncaya kadar yukarı doğru taşınır. Bu, programın exceptionları düzgün bir şekilde ele almasını sağlar ve programın ani bir şekilde sonlandırılmasını önler.</p><p>Bu avantajlar, Java’da exception handle etmenin programların daha güvenli, düzenli ve hata durumlarına karşı daha dirençli hale gelmesine yardımcı olduğu nedenleri içerir. Exception handle etme, hata durumlarını açıkça tanımlayabilir, izole edebilir ve uygun bir şekilde ele alabilir. Bu da yazılımın daha güvenilir ve bakımı daha kolay olmasını sağlar.</p><p><strong>50.</strong> <strong>Java’da kaç yolla exeptionları handle edebiliriz?</strong></p><p>Java’da exception handling yapmanın iki ana yolu vardır:</p><p>try-catch Bloğu Kullanarak exception handling: Bir try-catch bloğu, belirli bir kod bloğunu çevreler ve bu kod bloğunda ortaya çıkabilecek exceptionları yakalamak ve işlemek için kullanılır. İşte bu yöntemin kullanımı:</p><p>try: Exception fırlatabilecek kodun bu bloğun içine yerleştirilir.</p><p>catch: try bloğunda ortaya çıkan belirli bir exception türünü yakalamak ve işlemek için kullanılır.</p><p>Örnek bir try-catch bloğu:</p><blockquote>try {</blockquote><blockquote>// İstisna fırlatabilecek kod</blockquote><blockquote>} catch (ExceptionType e) {</blockquote><blockquote>// İstisna yakalandığında yapılacak işlemler</blockquote><blockquote>}</blockquote><p>try-catch bloğu, belirli bir exception türünü belirterek exceptionların yakalanmasını ve uygun bir şekilde işlenmesini sağlar.</p><p>throws Bildirimi Kullanarak exception handling: Bir metot, içinde exception fırlatabileceğini belirten bir throws bildirimi kullanabilir. Bu yöntem, bir metotun içindeki kod, exception fırlatabilir, ancak exceptionları yakalamak veya işlemek yerine, bu metodu çağıran kodun sorumlu olmasını bekler.</p><p>Örnek bir throws bildirimi:</p><blockquote>public void someMethod() throws SomeException {</blockquote><blockquote>// İstisna fırlatabilecek kod</blockquote><blockquote>}</blockquote><p>Bu yaklaşım, exception handlingi metot seviyesinde taşır ve exception yakalama sorumluluğunu çağıran kodun üzerine bırakır.</p><p>Her iki yaklaşımın da kendine özgü kullanım alanları vardır, ve hangi yöntemin tercih edileceği, işlemek istenen exception türüne, programın tasarımına ve gereksinimlerine bağlı olarak değişebilir.</p><p>Bu çalışma buraya kadar, umarım okuyanlara faydalı olmuştur. Devamı da gelecek diyelim…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e795c3595b51" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>