<?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 Furkan Tatar on Medium]]></title>
        <description><![CDATA[Stories by Furkan Tatar on Medium]]></description>
        <link>https://medium.com/@furkn.ttr?source=rss-ea362949a1b7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KPX3Btd_fyQlfmMNwGJQpQ.jpeg</url>
            <title>Stories by Furkan Tatar on Medium</title>
            <link>https://medium.com/@furkn.ttr?source=rss-ea362949a1b7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:04:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@furkn.ttr/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[Tomcat ve Servlet Nedir?]]></title>
            <link>https://medium.com/@furkn.ttr/tomcat-ve-servlet-nedir-7f9e7edfe8ed?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f9e7edfe8ed</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[tomcat]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[servlet]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Fri, 08 May 2026 22:51:16 GMT</pubDate>
            <atom:updated>2026-05-08T22:51:16.480Z</atom:updated>
            <content:encoded><![CDATA[<p>Başlamadan belirtmekte fayda var, burada derinlemesine bakmayacağım,</p><p>zaten bunu yazdığım tarih için derinleme bir bilgim olduğunu düşünmüyorum bu konu hakkında ancak aklımda boşluk olmasındansa kendimce soruya verdiğim bir cevap bu.</p><p>Öncelikle belirtelim Tomcat ve Servlet yapıları Java’ya ait yapılardır,</p><p>Bu yapıları şu şekil kabaca tanımlayalım:</p><p><strong>TOMCAT:</strong> Dışarı ile ilgilenen kısmımızdır. Sunucumuzu ayağa kaldıran (8080 portunu tutan) ayrıca buraya gelen çirkin HTTP isteklerini parçalayıp uygun hale getirerek, ilgili servlet metoduna yönlendiren kişidir.</p><p><strong>SERVLET:</strong> İç işleyişle ilgilidir, kendisine gelen request nesnelerini Business Logic ile işleyip geriye bir response nesnesi döner.</p><p>Bu ikisini verdikten sonra şu cümleyi kurmak da doğru olacaktır, Tomcat bir Servlet Container’ıdır.</p><p>Şimdi ilkel bir sunucu ayağa kaldırıp bu işlemi temel seviyede de olsa gözümüzle görelim.</p><ol><li>Tomcat için ilk işlemimiz bir port tutmak;<br>ServerSocket server = new ServerSocket(8080);</li></ol><blockquote>Bu noktada artık cihazımız bir sunucudur, yani bizim bu kodu çalıştırdığımız cihazdaki bu porta gelen her istek artık bilgisayarımız tarafından karşılanır.</blockquote><p>yine cihazımızda <a href="http://localhost:8080/">http://localhost:8080</a> yazarsak istek bu socket’e gider (zaten bu noktada hâlâ kendi cihazımızın içindeyiz)</p><p>Çirkin Http isteklerini parçalayıp uygun hale getirir demiştik, ne o http istekleri ki nasıl parçalayalım?</p><pre>GET / HTTP/1.1<br>Host: localhost:8080<br>User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)<br>Content-Type: application/json<br>Content-Length: 45<br>Accept: */*<br>Cookie: sessionId=abc123xyz; userToken=f4782<br>Connection: keep-alive<br>...</pre><p>Kabaca yukarıdaki gibi bi istek gelicektir bize, biz ilkel Tomcat kodumuzda detaylarla ilgilenmeyeceğiz (çünkü o kadar yetkinliğim yok şu anda :D) bizim işimiz ilk satırla;</p><p>“GET / HTTP/1.1”</p><p>Yani atılan istek ‘GET’ ve yolu ‘/’, biz bu bilgiyi string manipülasyonla parçalarsak artık hangi endpoint’e istek atmış bulabiliriz.</p><pre>// 1. ADIM: Gelen satırı parçala (Örn: &quot;GET /haberler HTTP/1.1&quot;)<br>String[] parts = line.split(&quot; &quot;);<br>String method = parts[0]; // GET<br>String path = parts[1];   // İstenen yol (/) veya (/yazilar)</pre><p>3. Artık endpoint yolunu biliyorsak parçalama ile bundan sonra ilgili servlet’e yönlendirebiliriz ki bu işlem if-else işlemlerinden ibaret.</p><p>Bundan sonra yönlendirdiğimiz servlet işini yapar ve bize cevabı döner, Servlet’i netleştirmeden örnek bir server kaldıralım.</p><pre>import java.io.*;<br>import java.net.ServerSocket;<br>import java.net.Socket;<br><br>public class PrimitiveServer {<br>    public static void main(String[] args) throws IOException {<br>        ServerSocket server = new ServerSocket(8080);<br>        System.out.println(&quot;Server 8080 portunda hazır...&quot;);<br><br>        while (true) {<br>            try (Socket client = server.accept()) {<br>                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));<br>                String line = in.readLine();<br>                if (line == null) continue;<br><br><br><br>                // 1. ADIM: Gelen satırı parçala (Örn: &quot;GET /haberler HTTP/1.1&quot;)<br>                String[] parts = line.split(&quot; &quot;);<br>                String method = parts[0]; // GET<br>                String path = parts[1];   // İstenen yol<br><br>                System.out.println(method + &quot; isteği geldi: &quot; + path);<br><br>                // 2. ADIM: Basit bir If-Else ile Yönlendirme (Primitive Router)<br>                String responseBody;<br>                String status = &quot;200 OK&quot;;<br><br>                if (path.equals(&quot;/&quot;)) {<br>                    responseBody = &quot;&lt;html&gt;&lt;body&gt;&lt;h1&gt;Ana Sayfaya Hos Geldin!&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;&quot;;<br>                } else if (path.equals(&quot;/yazilar&quot;)) {<br>                    responseBody = &quot;&lt;html&gt;&lt;body&gt;&lt;h1&gt;Ders Listesi: Java, OS, Network&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;&quot;;<br>                } else {<br>                    // Tanımlı olmayan her şey için 404 dönüyoruz<br>                    status = &quot;404 Not Found&quot;;<br>                    responseBody = &quot;&lt;html&gt;&lt;body&gt;&lt;h1&gt;404 - Boyle Bir Sayfa Yok Kanka&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;&quot;;<br>                }<br><br>                // 3. ADIM: Yanıtı HTTP formatında paketle<br>                String httpResponse = &quot;HTTP/1.1 &quot; + status + &quot;\r\n&quot; +<br>                        &quot;Content-Type: text/html; charset=UTF-8\r\n&quot; +<br>                        &quot;Content-Length: &quot; + responseBody.getBytes(&quot;UTF-8&quot;).length + &quot;\r\n&quot; +<br>                        &quot;Connection: close\r\n&quot; +<br>                        &quot;\r\n&quot; +<br>                        responseBody;<br><br>                OutputStream out = client.getOutputStream();<br>                out.write(httpResponse.getBytes(&quot;UTF-8&quot;));<br>                out.flush();<br>            }<br>        }<br>    }<br>}</pre><blockquote>Koda bakarsak tomcat kaldırılmış, yönlendirme yapılmış ve ilgili servlet’e (burada olmasa da) yönlendirilmiş, en son ise tabii ki cevabımızı da tekrar http nesnesine çevirip yollamışız.</blockquote><p>Bu kodu Java’da yazıp çalıştırdığınızda artık bilgisayarınızda<br>http://localhost:8080 ile erişebilirsiniz veya<br>http://localhost:8080/dersler ile erişebilirsiniz.</p><blockquote>EGLENMEK İSTEYENLER İÇİN AŞAĞISI</blockquote><p>Dahası şu anda cihazınızın ip:port şeklinde açıkta bir sunucu halinde yani siz AYNI AĞDA olduğunuz bir telefonda bu kodu kaldırdığınız cihazın ip adresi ile erişebilirsiniz.</p><p>Mesela 176.16.0.0 agında hem bilgisayarınız hem telefonunuz var.<br>Bilgisayarınızın (sunucunuz) ip’si 176.16.0.5 diyelim,<br>telefonunuz da 176.16.0.x ip’sinde,</p><p>Telefonunuzdan <a href="http://176.16.0.5:8080/">http://176.16.0.5:8080</a> veya <a href="http://176.16.0.5:8080/dersler">http://176.16.0.5:8080/dersler</a> isteği attığınızda sizin bilgisayarınız (sunucu) isteği karşılayacaktır.</p><blockquote>EĞER BURADAN SONRASINI OKUMAK İSTEMEZSENİZ “GÜNÜMÜZ” KISMINA ATLAYIN.</blockquote><p>Peki şimdi bunu biraz daha modernleştirsek? Hem görevleri iyice ayrıştırırız hem de bir servlet tasarımını görmüş oluruz.<br>sistemimiz “Primitive+” olsun :p</p><p>Öncelikli işimiz bu gelen response ve request için veri aktarım objeleri(dto) tasarlamak ki sistemimiz olsun, ayrıca ana kodun içinden ayrılsın.</p><pre>// Sadece gelen path&#39;i tutan basit bir sınıf<br>class MyRequest {<br>    public String path;<br>    public MyRequest(String path) { this.path = path; }<br>}<br><br>// Yanıtı biriktirdiğimiz sınıf<br>class MyResponse {<br>    private StringBuilder body = new StringBuilder();<br>    public void write(String content) { body.append(content); }<br>    public String getBody() { return body.toString(); }<br>}</pre><p>MyRequest isteği constructor’ında bize parçalanıp gelen endpoint yolunu alıyor ve direkt olarak isteğe basıyor.</p><p>MyResponse ise şöyle kurgulayalım; bu bize boş tepsi verir, kodun yol üstünde biz bulduğumuz/lazım olanları buna veririz ve uç uca biriktirerek ilerletir.<br><strong>write</strong> fonksiyonu istenileni alıp içerdeki “body” degişkeninin ucuna ekleyerek gider;<br><strong>getBody</strong> fonksiyonu ise tepsi hazır demektir, tepsinin bütününü String olarak geriye döner<br>(Detaylı öğrenmek isterseniz bu bir builder tipi sınıftır)</p><p>Diğer Servlet’lerimizin kullanacağı ve onu implement edenlerin, bahsedilenleri kullanmakta sözleştiği interface sınıfını yazalım:</p><pre>interface MyServlet {<br>    void service(MyRequest req, MyResponse res);<br>}</pre><p>(böylece demin yazdığımız dto’larımızla işlem yapılacağını ayrıca <strong>service </strong>metodunun herkeste varolacağını garantiliyoruz)</p><p>Daha sonra bunu implement eden ve asıl işi yapıp cevabı dönecek olan servletlerimizi yazalım:</p><pre>class HomeServlet implements MyServlet {<br>    public void service(MyRequest req, MyResponse res) {<br>        res.write(&quot;&lt;h1&gt;Ana Sayfadasın&lt;/h1&gt;&lt;p&gt;Tomcat ilkel router calisiyor.&lt;/p&gt;&quot;);<br>    }<br>}<br><br>class AboutServlet implements MyServlet {<br>    public void service(MyRequest req, MyResponse res) {<br>        res.write(&quot;&lt;h1&gt;Hakkımızda&lt;/h1&gt;&lt;p&gt;Ben bir baska servletim!&lt;/p&gt;&quot;);<br>    }<br>}</pre><p>Tamamdır artık servletlerimiz hazır ve içlerindekileri write yapıyor, en son cevabımız ise zaten o yazılanı dönüyor response olarak. artık MyServlet interface’i ile diğer servletlerden hizmet alabiliriz ancak son olarak bir router sistemi kuralım.</p><pre>class MyRouter {<br>    private Map&lt;String, MyServlet&gt; routes = new HashMap&lt;&gt;();<br><br>    // Yeni rotalar eklemek için<br>    public void addRoute(String path, MyServlet servlet) {<br>        routes.put(path, servlet);<br>    }<br><br>    // Gelen isteği ilgili Servlet&#39;e paslamak için (Dispatch işlemi)<br>    public void dispatch(MyRequest req, MyResponse res) {<br>        MyServlet servlet = routes.get(req.path);<br>        <br>        if (servlet != null) {<br>            servlet.service(req, res);<br>        } else {<br>            res.write(&quot;&lt;h1&gt;404&lt;/h1&gt;&lt;p&gt;Router bu yolu bulamadi. &lt;/p&gt;&quot;);<br>        }<br>    }<br>}</pre><p>Burası içeriğinde String Key alıp, MyServlet tipinde Value veren bir hashmap tutuyor,</p><p>addRoute metodu parametresine key ve value değerini alıp hashmap’e ekliyor,</p><p>dispatch metodu ise req’den (içinde endpoint var sadece dedik) path’i alıyor ve bunu hashmap’e key olarak verip servlet degişkenine ilgili servleti alıyor;</p><p>servlet null degilse ilgili servlet’in service metodunu çalıştırıyor,<br>servlet null ise bu yol yok bilgisini cevabı oluşturacak tepsiye yazıyor.</p><p>Artık her şey tamam olduğuna göre şimdi sunucumuzu ayağa kaldırabiliriz:</p><pre>public class PrimitiveServerPlus {<br><br>    public static void main(String[] args) throws IOException {<br>        // Rotaları Kaydet<br>        MyRouter router = new MyRouter();<br>        router.addRoute(&quot;/&quot;, new HomeServlet());<br>        router.addRoute(&quot;/about&quot;, new AboutServlet());<br><br>        //8080 portunu al<br>        ServerSocket server = new ServerSocket(8080);<br>        System.out.println(&quot;Sistem Hazir! Tarayicidan http://localhost:8080/ veya /about yaz...&quot;);<br><br>        while (true) {<br>            try (Socket client = server.accept()) {<br>                // ISTEGI OKUMA (Parsing)<br>                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));<br>                String firstLine = in.readLine(); // &quot;GET /about HTTP/1.1&quot;<br><br>                if (firstLine == null || firstLine.isEmpty()) continue;<br><br>                // Path&#39;i ayıkla<br>                String path = firstLine.split(&quot; &quot;)[1];<br>                System.out.println(&quot;Gelen İstek Yolu: &quot; + path);<br><br>                // NESNELERI OLUSTUR (Request &amp; Response)<br>                MyRequest req = new MyRequest(path);<br>                MyResponse res = new MyResponse();<br><br>                // YONLENDIRME (Routing)<br>                router.dispatch(req, res);<br><br>                // YANITI PAKETLE VE GONDER (The Final Response)<br>                String responseBody = res.getBody();<br>                String fullResponse = &quot;HTTP/1.1 200 OK\r\n&quot; +<br>                        &quot;Content-Type: text/html; charset=UTF-8\r\n&quot; +<br>                        &quot;Content-Length: &quot; + responseBody.getBytes().length + &quot;\r\n&quot; +<br>                        &quot;\r\n&quot; +<br>                        responseBody;<br><br>                OutputStream out = client.getOutputStream();<br>                out.write(fullResponse.getBytes(&quot;UTF-8&quot;));<br>                out.flush();<br><br>            } catch (Exception e) {<br>                System.err.println(&quot;Bir hata olustu: &quot; + e.getMessage());<br>            }<br>        }<br>    }<br>}</pre><p>Sunucu 8080 portunu aldı ve işleri yapması için kişileri organize etti, en sonunda ise response’u http formatına çevirip yolladı.</p><p>Servlet’lerin amacı ise kendilerine yönlendirilmiş olan bu istekleri alıp kendi içlerinde Business Sınıfının işini yapar gibi işleyip veriyi, yollamak oldu; her ne kadar bu kodda doğrudan düz cevap döndürsek de.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YjJh_guyhIZFywnUdRZrGQ.png" /></figure><h3>GÜNÜMÜZ</h3><ol><li>Günümüzde Tomcat hiçbir rota vs bilmez, çünkü artık tek bir servlet vardır. Tomcat artık sunucuyu (8080) kaldırır ve dinler, gelen request’i alıp paketleyip direkt o tek servlet’e verir.</li><li>Günümüzde Servlet olarak sadece DispatcherServlet isimli servlet vardır, gelen her istek buraya gelir ve DispatcherServlet elindeki HandlerMapping bakar ve “Bu isteği hangi Controller’ın hangi metodu çözebilir?” diyerek bulur.</li><li>Günümüzde artık bu HomeServlet, AboutServlet sınıfları aslında birer Controller oldu, @RestController yazarız ve o halleder.<br>Aynı şekilde içeriğindeki ağır business logic’ler ise Business package’ına devredilmiş oldu.</li></ol><h3>Günümüzdeki Akışın Özeti</h3><ol><li><strong>İstek Gelir:</strong> Tomcat isteği karşılar.</li><li><strong>Kime Gidecek?</strong> -&gt; Tomcat doğrudan DispatcherServlet&#39;e paslar.</li><li><strong>Yönlendirme (Routing):</strong> DispatcherServlet @GetMapping etiketlerine bakarak ilgili Controller metodunu bulur.</li><li><strong>İş Mantığı (Business):</strong> O metot çalışır, veriyi hazırlar.</li><li><strong>Yanıt:</strong> Spring, senin döndüğün objeyi (veya String’i) otomatik olarak HTTP Response formatına sokar ve Tomcat üzerinden kullanıcıya gönderir.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f9e7edfe8ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2) Polymorphism (Çok Biçimlilik)]]></title>
            <link>https://medium.com/@furkn.ttr/2-polymorphism-%C3%A7ok-bi%C3%A7imlilik-d07ace1e06a5?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d07ace1e06a5</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[polymorphism]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Wed, 29 Apr 2026 09:02:52 GMT</pubDate>
            <atom:updated>2026-04-29T09:02:52.187Z</atom:updated>
            <content:encoded><![CDATA[<h4>Genelleyici (Universal) vs. Durumsal (Ad-hoc) Yaklaşım</h4><p>Daha önceki yazımızda Polymorphism’i <strong>“Ne Zaman?”</strong> ve <strong>“Nasıl?”</strong> diye iki ana kutuba ayırmıştık.</p><p>Ve gene önceki yazımızda “Ne Zaman?” kısmını içeriğiyle anlatmıştık.</p><p>Bu yazımızda ise “Nasıl?” kısmına geleceğiz.</p><p>Nasıl kısmı kendi içinde iki alt başlığı tutuyor:<br>- Durumsal (Ad-hoc)<br>-Genelleyici (Universal) yaklaşım.</p><h4><strong>1. Ad-hoc Polymorphism (Özel / Geçici Çok Biçimlilik)</strong></h4><p>Bu türde, farklı veri tipleri için <strong>ayrı ayrı</strong> tanımlanmış davranışlar söz konusudur. Yani sistem, sınırlı sayıdaki tip için “özel” çözümler üretir.</p><ul><li><strong>Method Overloading (Metot Aşırı Yükleme):</strong> Aynı isimli fakat farklı imzalara (parametre tipi/sayısı) sahip metotların tanımlanmasıdır. Derleyici, hangi metodun çağrılacağını parametrelere bakarak seçer.<br>(Önceki Yazımızda zaten anlatmıştık, gene de örnek verelim basitinden)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*OeqOBLp2iRuUk8QIH6julA.png" /></figure><ul><li><strong>Operator Overloading (Operatör Aşırı Yükleme):</strong> + veya * gibi operatörlerin, farklı nesne türleri üzerinde (örneğin iki karmaşık sayıyı toplamak gibi) farklı görevler üstlenmesidir.<br>(Mesela aşağıdaki örnekte ‘+’ işaretinin farklı kullanımı var)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*KUmfxp_vJH56SHicz6GQVA.png" /></figure><blockquote>‘+’ işareti burada operator overloading’e uğradığı açıkca gözüküyor. ilki “Toplama İşlemi” iken ikincisi “String Birleştirme” işlemi şeklinde.</blockquote><blockquote>Mesela sout içine yazılmış olan ‘+’ işareti kendi ve sonrasında string birleştirme yapar.</blockquote><blockquote>Çıktılar şöyle olur:<br>1. Toplama Sonucu:13<br>2. Toplama Sonucu:58 (Devamını tamamen String birleştirme olarak görür)<br>3. Toplama Sonucu:13 (işlemi paranteze almak, sistemin string birleştirme moduna geçmeden önce içerdeki işlemi yapmasını önceliklendirir yani izin verir)</blockquote><ul><li><strong>Coercion (Zorlamalı Dönüşüm):</strong> Bir veri tipinin, dil tarafından otomatik olarak başka bir tipe dönüştürülmesidir. <br>Örneğin, bir fonksiyon double beklerken ona int göndermeniz ve dilin bunu sessizce kabul etmesi bir çok biçimlilik örneğidir.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rnMIyOCbfvwS5oDbattajQ.png" /></figure><blockquote>Buradaki ilişki, nesnelerdeki gibi sınıf tabanlı bir is-a ilişkisi değil; ilkel tipler arasındaki hafıza boyutuna dayalı bir <strong>otomatik genetik uyumluluk (widening)</strong> ilişkisidir. Derleyici, int’in kapasitesinin double’ın içine sığabileceğini bilir ve bir veri kaybı olmayacağı için bu dönüşümü sessizce onaylar.</blockquote><h4><strong>2. Universal Polymorphism (Evrensel Çok Biçimlilik)</strong></h4><p>Bu türde, tek bir kod bloğu veya yapı, <strong>sonsuz sayıda</strong> farklı veri tipi için aynı şekilde çalışabilir. Daha genel ve kapsayıcıdır.</p><ul><li><strong>Inclusion Polymorphism (Subtyping / Kapsama):</strong> OOP’nin kalbidir. Bir üst sınıfın (veya arayüzün), tüm alt sınıflarını temsil edebilme yeteneğidir.</li></ul><p><strong>Uygulama Araçları:</strong> <em>Inheritance (Kalıtım/ is-a ilişki )</em>, <em>Interfaces (Arayüzler/can-do ilişki ) </em>bu başlığın altındaki pratik uygulamalardır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C6Zz7qLFZpf9sZYhDNd6zQ.png" /></figure><p>Bu UML’de Meyveler is-a ilişkisinde Meyveler Referansının altına Elma/Muz/Cilek konabilir.</p><p>Aynı Şekilde can-do ilişkisi ile IBeslenebilir Referansının altına da İnsan konabilir.</p><blockquote>IBeslenebilir beslenebilir = new İnsan(); kullanılabilir ancak bu is-a degil, can-do ilişkisidir.(Interface ile onu Uygulayan sınıfın ilişkisi)</blockquote><blockquote>Yani IBeslenebilir bir çeşit İnsan değildir, sadece İnsan bunları yapabilir.</blockquote><blockquote>Bir interface’i bir sınıf implement ederse: Can-do<br>Bir interface’i bir sınıf field’ına eklerse: Has-a<br>Bir Sınıfı başka sınıf extends ederse: Is-a</blockquote><ul><li><strong>Parametric Polymorphism (Parametrik / Generics):</strong> Bir fonksiyonun veya sınıfın, tipini bilmediği bir “T” parametresi ile yazılmasıdır. Kod, içine hangi tip girerse girsin (int, string, User nesnesi vb.) algoritmasını değiştirmeden çalışır.</li></ul><blockquote>Genericler konusu için şu yazıyı: yaziLinki okumanızı şiddetle tavsiye ederim</blockquote><p>Burada T type’dan geliyor ve “ne tip olursa olsun” anlamında. Bunun avantajı şöyle gösterelim.</p><p>Mesela Aşagıdaki kutumuz her tip veri için çalışır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kuG-58iMr5dU7GTRgn1Rlg.png" /></figure><p>Bu kodda Bir kere String gelirse Kutuya hep String koyabiliriz.</p><p>Bir kere Integer gelirse (referansı olmak zorunda) kutuya hep Integer koyabiliriz.</p><p>Eğer T olmasaydı her tip için ayrı ayrı yazmamız gerekirdi.</p><p>Bu işleme Parametric Polymorphism denir.</p><ul><li>List&lt;T&gt; yapısı da bir Parametric Polymorphism örneğidir.</li></ul><p>OOP’mizin Son Yazısıydı, Yeni yazılar veya serilerde görüşmek üzere :)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d07ace1e06a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[1) Polymorphism (Çok Biçimlilik)]]></title>
            <link>https://medium.com/@furkn.ttr/1-polymorphism-%C3%A7ok-bi%C3%A7imlilik-9136ad90b37c?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9136ad90b37c</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[polymorphism]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Sat, 25 Apr 2026 03:26:18 GMT</pubDate>
            <atom:updated>2026-04-25T03:26:18.435Z</atom:updated>
            <content:encoded><![CDATA[<p>En baştan söylemeliyim ki Polymorphism’le ilgili asıl önemli olan yazının bu olduğunu düşünüyorum.<br>Ancak belirtmek gerekir ki polymorphism “Method Overriding ve MethotOverloading” den ibaret değildir.</p><p>Ve önden söyleyelim, eğer Inheritance’daki “<a href="https://medium.com/@furkn.ttr/3-kal%C4%B1t%C4%B1m-inheritance-c6d368946255">Java’da bellek akışı ve new() ile ne olur?</a>” yazısını okuduysanız buradaki alt mekaniği haliyle kastedilenin ne olduğunu daha iyi anlayacaksınızdır.</p><p>Her zamanki gibi basitten başlayıp her yazımda yaptığım gibi derinleştirerek (deep diving) ilerlemeye çalışıcam, Bu yazıdaki “BASİT” ifadesi ise biraz daha “yaygın anlatılan” olacaktır.</p><p>Polymorphism, Tek bir arayüzün (isim, sembol veya ortak yapı) farklı veri tipleri için farklı davranışlar sergileyebilme yeteneğidir.</p><p>Burada Polymorphism’i kategorilerini vererek başlamayı açıkça tercih ederim.</p><p>Aslında 2 ana kısım var; <strong>Ne Zaman?</strong> ve <strong>Nasıl?</strong> iki ana kutuptur.</p><p>Ne Zaman? (Uygulama Zamanı) ==&gt; Static ile Dynamic Polymorphism<br>Nasıl? ==&gt; Universal ile Ad-hoc Polymorphism</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dmBBWB9tXdtqtAFFuxK04Q.png" /></figure><p>Biz bu yazımızda Çalışma Zamanına bakıcaz, yani Static ve Dynamic Polymorphism’i inceleyeceğiz.</p><h3>1. Static Polymorphism (Statik Çok Biçimlilik)</h3><p>Buna <strong>“Compile-time Polymorphism”</strong> veya <strong>“Early Binding” (Erken Bağlanma)</strong> de denir. Derleyici daha program çalışmaya başlamadan hangi metodun çağrılacağını “imzasına” (parametre yapısına) bakarak kesin olarak bilir.</p><ul><li><strong>Method Overloading (Metot Aşırı Yükleme):</strong> Aynı isimli metotların farklı parametre listeleriyle tanımlanmasıdır.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*urlT9bKDhkkTTa8oAE_nqw.png" /></figure><ul><li><em>Örnek:</em> <strong>yazdir(int sayi)</strong> ile <strong>yazdir(String metin)</strong>. Derleyici, main’de gönderdiğin değere bakıp hangi &quot;yazdir&quot;ı çalıştıracağına kod henüz YAZILIRKEN karar verir.</li><li><strong>Operator Overloading:</strong> Operatörlerin farklı tipler için derleme aşamasında farklı anlamlar kazanmasıdır.<br>(Java’da bu desteklenmiyor, Java gizlice arkaplanda kullansa bile)</li></ul><blockquote>Yukarıdaki kodda gördügümüz gibi parametreleri degişerek Methotd Overloading yapariz, derleyici sadece main’de imzasından gönderdiğimiz değer ile karar verir direkt ve static binding ile bağlar bu ikiliyi.</blockquote><h3>2. Dynamic Polymorphism (Dinamik Çok Biçimlilik)</h3><p>Buna <strong>“Runtime Polymorphism”</strong> veya <strong>“Late Binding” (Geç Bağlanma)</strong> denir. Hangi metodun çalışacağı, programın akışı sırasında, yani <strong>nesne bellekte oluştuğu anda</strong> belli olur.</p><ul><li><strong>Method Overriding (Metot Ezme):</strong> Alt sınıfın, üst sınıftaki metodu kendi mantığıyla yeniden yazmasıdır.</li><li><strong>Mekanizma:</strong> Bir referans (pointer/reference), çalışma anında hangi nesneyi işaret ediyorsa (örneğin “Hayvan” referansının “Kedi” nesnesini işaret etmesi), o nesneye ait metot çağrılır.</li><li><strong>Araçlar:</strong> Kalıtım (Inheritance), Soyut Sınıflar (Abstract Classes) ve Arayüzler (Interfaces).</li></ul><p>— — — — — — — — — — — — —</p><p>Hatırlarsak bizim bir abstract Hayvan ve onu miras alan Kedi sınıfımız vardı:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n8pLqHTxPM0xZmx7sCrl0g.png" /></figure><p>Yukarıda bu Kedi ve Hayvan sınıflarımızı verdik.</p><p>Şimdi Main’de şu şekilde bir sesCikar çalıştırması yaparsak.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0075Veuso4rFEnA5tS4xDg.png" /></figure><p>Kedi’nin sesCikar() metodu mu yoksa,<br>Hayvan’ın sesCikar metodu mu çalışır?</p><blockquote>Eğer Inheritance Bellek konusunu okuduysanız çok kolay olucak burası.</blockquote><p>CEVAP: Kedi çünkü:</p><ul><li>Öncelikle bir kodun nesnesi oluşmadan belleğin neresine bakılacak bilgisi oluşmaz, o yüzden sistem henüz derlemedeyken Hayvan mı yoksa Kedi mi çalışacak bilemez</li><li>new Kedi() dediğimizde heap’te Kedi nesnesi oluşur yani nesnenin gerçeği kedi’dir, Bellek yazısından hatırlarsak o halde vptr’miz Kedi şablonuna gider, haliyle Kedi bytecode’u yani Kedi nesnesi çalışır.</li></ul><p>— — — — — — — — — — — —</p><p><strong>Peki ya o hâlde referans burada neden farklı? ne değiştiriyor?</strong></p><p>Aslında referans olarak <br>Hayvan hayvan = new Kedi();<br>Kedi kedi = new Kedi();<br>İfadesinin ikisi de Heap’te aynı gerçek Kedi nesnesini gösterir.</p><p>Burada o referans tipi ise bir FİLTRE’dir yani<br>“<strong>NESNEMİ NE OLARAK BİLİYORUM?”</strong> Sorusunun cevabını verir.</p><blockquote>Yukarıdaki <strong>“NESNEMİ NE OLARAK BİLİYORUM?”</strong> Sorusu çok önemli, tekrar tekrar düşünücez bu noktayı.</blockquote><p>Şimdi şöyle bir çalıştırma daha yapalım ve <br><strong>hayvan.fareYakala();</strong> diyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ArRKGC2Y5JrcYVpOaKkJZw.png" /></figure><p><strong>hayvan.fareYakala(); </strong>çalışmaz.</p><p>Çünkü nesnemizi derleyici “Hayvan” olarak bilir ve her ne kadar bu static binding olmasa bile neyin çalışmayacağı belirlenmiş olur.</p><blockquote>Aslında bu kararın alınma sebebi de şudur. Tamam, şu an sağ tarafta <em>new Kedi()</em> yazıyor olabilir. Ama yarın bir gün bu kod değişir de <em>hayvan = new Kopek();</em> olursa ne olacak? Köpek fare yakalayamazsa program çöker. O yüzden ben en baştan, sadece &#39;Hayvan&#39; olan ortak yeteneklere izin vereyim ki risk olmasın şeklinde düşünüldüğü için daha en baştan bu mantıklı kısıtlama yapılır</blockquote><p>Yani olasılığa bile katmaz Kedinin metotlarını, bu noktada sadece Hayvan sınıfının metotları kadarını kullanabiliriz<br>(Kedi Sınıfı zaten hayvandan miras aldığı için Hayvan’ın tüm metotlarına kesinlikle sahip)</p><p>— — — — — — — — — — — —</p><p>Burada şunu sorabilirsiniz, iyi de madem Hayvan hayvan bizi kısıtlıyor, neden onu kullanalım? (Ki bu güzel bir soru)</p><blockquote>Buraya başlamadan <a href="https://medium.com/@furkn.ttr/1-kalitim-inheritance-f4ab42813298">Inheritance’ın ilk yazısının</a> is-a kısmını okumanızı tavsiye ederim.</blockquote><blockquote>Hızlı cevaplarsak bize muazzam bir esneklik katıyor ve bir şeyleri kodumuza, eski koda dokunmadan ekleme fırsatı veriyor.</blockquote><p>Hatırlarsak şu sorunun cevabını veriyor demiştik referans farkı:</p><p><strong>Nesnemi Ne Olarak Biliyorum?</strong></p><p>Şimdi Hayvan hayvan = new Kedi() diyince nesnemizi Hayvan olarak biliyoruz.</p><p>Peki is-a ilişkisiyle düşünmeye başlayalım şimdi;<br>Kedi bir Hayvan mıdır? EVET<br>Köpek bir Hayvan mıdır? EVET<br>Köpek bir Kedi midir? HAYIR<br>Kedi bir Köpek midir? HAYIR</p><p>yani:<br>Hayvan hayvan = new Kedi();<br>Hayvan hayvan=new Köpek(); <strong>mümkündür</strong></p><p>Kedi kedi = new Kopek();<br>Kopek kopek = new Kedi(); ifadeleri <strong>mümkün değildir.</strong></p><p>Dikkat edersek burada is-a ilişkisi varken bu değişmeyi yapabiliyorum buna göre şunda hemfikiriz ben bugün <strong>Hayvan hayvan = new Kedi();</strong> derken yarın <strong>hayvan = new Kopek();</strong> dersem sorun yaşamam</p><p>Bu şu demek ki esneklik de buradadır. Nesneyi ne kadar genel biliyorsam, kodum o kadar farklı tür ile çalışabilir.</p><p>Peki biz bunu nasıl daha etkili kullanıyoruz?</p><p>— — — — — — — — — — — —</p><blockquote>Bu senaryo <a href="https://www.linkedin.com/in/akinkaldiroglu/">Akın Kaldıroğlu</a> Hocamdan öğrendiğim bir senaryodur,<br>Kendisine sevgiler :D</blockquote><p>Şimdi bir senaryo üzerinden bu esnekliği dibine kadar kullanalım :)</p><p>Bir Worker abstract sınıfımız olsun (Diğer nesnelerin ortak kısımları)</p><pre>abstract class Worker {<br>    String name;<br>    <br>    public Worker(String name) {<br>        this.name = name;<br>    }<br><br>    // Her çalışanın maaşı farklı hesaplanır ama hepsi &quot;hesaplanabilir&quot;dir.<br>    public abstract double calculateSalary();<br>}</pre><p>Bir de ofisimizde gerçekten çalışan kişiler olsun; <strong>SeniorDev, HR, Boss</strong></p><pre>class SeniorDev extends Worker {<br>    public SeniorDev(String name) { super(name); }<br>    @Override<br>    public double calculateSalary() { return 100000; }<br>}<br><br>class HR extends Worker {<br>    public HR(String name) { super(name); }<br>    @Override<br>    public double calculateSalary() { return 60000; }<br>}<br><br>class Boss extends Worker {<br>    public Boss(String name) { super(name); }<br>    @Override<br>    public double calculateSalary() { <br>        return 250000 + 50000; // Maaş + Sabit Bonus<br>    }<br>}</pre><p>Herkes kendi maaş hesaplanma şeklini biliyor.</p><p>Peki maaşları ödeme vakti geldiğinde ne yapacağız? Herkesin nesnesini oluşturup tek tek “<strong>bilmemKacinciNesne.calculateSalary()” </strong>Metotlarını mı çalıştıracağız? yani şu</p><pre>public class Main {<br>    public static void main(String[] args) {<br>        // Nesneleri kendi tiplerinde oluşturuyoruz (Filtre yok!)<br>        SeniorDev senior = new SeniorDev(&quot;Ahmet&quot;);<br>        HR ik = new HR(&quot;Ayşe&quot;);<br>        Boss patron = new Boss(&quot;Mehmet&quot;);<br><br>        // Maaşları ödeme vakti geldiğinde...<br>        // TEK TEK her nesnenin ismini ve metodunu yazmak zorundayız:<br>        System.out.println(senior.name + &quot; maaşı: &quot; + senior.calculateSalary());<br>        System.out.println(ik.name + &quot; maaşı: &quot; + ik.calculateSalary());<br>        System.out.println(patron.name + &quot; maaşı: &quot; + patron.calculateSalary());<br><br>        // Yarın 100 tane daha çalışan gelirse, buraya 100 satır daha <br>        // &quot;bilmemKacinciNesne.calculateSalary()&quot; yazman gerekecek. <br>        // İşte &quot;Kötü Kod&quot; budur; değişime kapalıdır, hamallık yaptırır.<br>    }<br>}</pre><p>Hayır yukarıdakini tabii ki yapmayacağız, büyümeye açık değil zaten yani sürdürülemez yukarıdaki.</p><p>Biz burada herkesin bir çeşit Worker olduğunu ve bu Worker’da calculateSalary olduğunu biliyoruz, bunu kullanacağız.</p><p>Bir PayOffice oluşturalım.</p><pre>class PayOffice {<br>    // Bu metodun dünyadan haberi yok! <br>    // İçeri Senior mu girdi, Stajyer mi girdi umursamaz.<br>    // Sadece &quot;Gelen her kimse bir Worker&#39;dır ve maaşı vardır&quot; der.<br>    public void pay(Worker w) {<br>        System.out.println(w.name + &quot; kişisine &quot; + w.calculateSalary() + &quot; TL ödeme yapıldı.&quot;);<br>    }<br>}</pre><blockquote><strong>Yukarıdaki Koddaki yorum satırlarını okuyun!!!!</strong></blockquote><p>Buradan sonra mainde ödemelere başlayalım.</p><pre>public class Main {<br>    public static void main(String[] args) {<br>        PayOffice office = new PayOffice();<br><br>        // Herkesi &quot;Worker&quot; ortak listesine koyabiliyoruz (Çünkü hepsi is-a Worker)<br>        List&lt;Worker&gt; employees = new ArrayList&lt;&gt;();<br>        employees.add(new SeniorDev(&quot;Ahmet&quot;)); //Henüz Furkan Değil :D<br>        employees.add(new HR(&quot;Ayşe&quot;));<br>        employees.add(new Boss(&quot;Mehmet&quot;));<br><br>        // Yeni bir çalışan mı geldi? Sadece listeye ekle, aşağıya dokunma.<br>        employees.add(new SeniorDev(&quot;Caner&quot;)); <br><br>        // Ödeme vakti: Tek bir döngüyle binlerce kişiye ödeme yapabiliriz.<br>        for (Worker w : employees) {<br>            office.pay(w); // Filtre (Worker) sayesinde PayOffice hepsini kabul eder.<br>        }<br>    }<br>}</pre><p>Artık yeni çalışan geldiğinde tek yapılması gereken listeye eklenmek, bu kadar istediğin kadar büyüt kadroyu, her yeri kurcalamaya gerek kalmadı ve sürdürebilir hâle geldi</p><p>sonuçta PayOffice şu anda kim gelse alıyor, gelen Bir çeşit Worker olduğu sürece, yani PayOffice oldukça esnek yapıda</p><blockquote>Aslında burada bir ÇalışanListesi sınıfı oluşturup içine singleton Worker tutan bir Liste versek, Sonra Worker Constructor’ına bu listeye direkt ekleme kodunu koyarsak, artık new’lenen her nesnemiz yani tüm çalışanlarımız otomatik o listede olur.<br>Bilmiyorum bu düşüncem ne kadar doğru ama denemeye değer, her neyse yazıyı daha fazla uzatmaya gerek yok.</blockquote><p>Bu yazıda işin zamansal kısmına (ne zaman?) değindik ve içeriğini anlattım. Bundan sonraki yazıda ise <strong>Nasıl? </strong>kısmına gireceğim.</p><ol><li>Nasıl? (Genelleyici (Universal) vs. Durumsal (Ad-hoc) Yaklaşım)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9136ad90b37c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Abstract Class ve Interface Class]]></title>
            <link>https://medium.com/@furkn.ttr/abstract-class-ve-interface-class-124cb4500def?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/124cb4500def</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[abstract-class]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 22:39:16 GMT</pubDate>
            <atom:updated>2026-04-21T22:39:16.809Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu konu aslında Abstraction (Soyutlamanın Son konusu ancak Polymorphism’e girmeden önce anlatmayı uygun gördüm)</p><p>Anlatım Olarak Sınıfın niyetini verip o niyete uygun olacak şekilde özelliklerin çıkarımını yapacağımı baştan belirtmeliyim.</p><p>Öncelikle Bu sınıfların niyetlerini tanımlayacak olursak;</p><ul><li><strong>Abstract Class (Soyut Sınıf): </strong>Amacı kendinden türetilecek olan sınıfların ortak olan kısımlarını kendine toplamaktır.</li><li><strong>Interface Class(Arayüz Sınıfı):</strong> Bu sınıf ise kendini implemente eden sınıfın neleri kesin olarak yapabildiğini tanımlar.</li></ul><h4>Abstract Class (Soyut Sınıf)</h4><p>Bu sınıf diğer sınıflar tarafından miras alınır ve kendisini miras alan sınıfların ortak alanlarını kendinde toplama görevi vardır.</p><p>Yani biz bu Sınıftan nesne oluşturmaya çalışmayız, diğer Sınıfların ortak alanları için binevi dağıtım noktası oluştururuz.</p><p>Mesela <strong>Meyve Sınıfı</strong> ile <strong>Elma, Armut, Portakal… Sınıfları</strong> arasındaki ilişkiyi kurgulayacak olursak:</p><ul><li>Meyve Soyut Sınıfına Meyvelerdeki ortak alanları veririz, meyveler bu sınıfı extends ederek kendilerine alır ve kirliliğin önüne geçmiş oluruz.</li></ul><p><strong>Meyvelerimizde neler ortak olabilir?</strong></p><ol><li>Meyvelerin ortak alanları(fields) olabilir.</li><li>Meyvelerin ortak çalışma biçimine sahip metotları olabilir.</li><li>Meyvelerin farklı çalışma biçimi ancak benzer konsept olan metotları olabilir.</li></ol><ul><li>Meyve Soyut Sınıfına dikkat edersek bu Soyut Sınıftan nesne oluşturmayı hedeflemeyiz tek amaç ortak kısımları toplaması ve dağıtıcı olmasıdır (yani bu soyut sınıfa new atarsak derleyici hata verir.)</li><li>Meyve sınıfında ortak alanlar olabilir yani Meyve Sınıfının alanları olabilir.(Mesela “meyveAdi” ve “meyveFiyati” alanları)</li></ul><pre>abstract class Meyve {<br>  protected String meyveAdi;<br>  protected int meyveFiyati;<br>  //Burada biz aktarılabilsin diye protected kullandık,<br>  //Amacı ortak noktaları toplayıp aktarmak olan bir şey için private gerekir mi?<br>  //Eğer ortak alan herkeste en başta sabit olucak veya en baştan belirlenecek<br>  //daha sonra ise degişmemeliyse evet, bu private ile halledilebilir.<br>}</pre><ul><li>Meyve Sınıfının nesnesi oluşturulmasa bile kurucusu olabilir ki genelde olur çünkü:<br>Meyve Sınıfında ortak alan oluyorsa bu alanların başlatma sorumluluğu da ortak olacaktır yani constructor’ın da bi kısmı ortak olacağı için bu da burada halledilir.</li></ul><pre>abstract class Meyve {<br>  protected String meyveAdi;<br>  protected int meyveFiyati;<br><br>  public Meyve (String meyveAdi, int meyveFiyati){<br>    this.meyveAdi = meyveAdi;<br>    this.meyveFiyati = meyveFiyati;<br>  }<br><br>}</pre><ul><li>Meyve Sınıfında Ortak çalışma biçimine sahip metotlar olabilir.<br>(yikan metodu, hepsi su ile yıkanır diyebiliriz)</li></ul><pre>abstract class Meyve {<br>  protected String meyveAdi;<br>  protected int meyveFiyati;<br><br>  public Meyve (String meyveAdi, int meyveFiyati){<br>    this.meyveAdi = meyveAdi;<br>    this.meyveFiyati = meyveFiyati;<br>  }<br>  <br>  public void yikan() {<br>    System.out.println(this.meyveAdi + &quot; temiz su ile yıkanıyor...&quot;);<br>  }<br>}</pre><ul><li>Meyve Sınıfında farklı çalışma biçimi ancak benzer Konsept olan metotlar olabilir(mesela soy metodu, her biri için soyma şekli farklıdır.)</li></ul><pre>abstract class Meyve {<br>  protected String meyveAdi;<br>  protected int meyveFiyati;<br><br>  public Meyve (String meyveAdi, int meyveFiyati){<br>    this.meyveAdi = meyveAdi;<br>    this.meyveFiyati = meyveFiyati;<br>  }<br>  <br>  //concrete method<br>  public void yikan() {<br>    System.out.println(this.meyveAdi + &quot; temiz su ile yıkanıyor...&quot;);<br>  }<br><br>  //abstract method<br>  public void soy();<br>}</pre><p>— — — — — — — — — — — — — — —</p><p>Hatırlarsak bizim kedi ve köpek nesnemiz vardı ve bunların miras aldığı bir Hayvan sınıfı vardı, şu ana kadar verip üstüne durmadık ancak o Hayvan sınıfı bir abstract class’dı, tekrar koyarsak buraya:</p><pre>abstract class Hayvan {<br>    private String ad; // Sadece bu sınıfa özel (Encapsulation)<br>    protected int yas; // Alt sınıflar (Kedi/Köpek) doğrudan erişebilir<br><br>    public Hayvan(String ad, int yas) {<br>        this.ad = ad;<br>        this.yas = yas;<br>        System.out.println(ad + &quot; için bellekten yer ayrıldı ve Hayvan kısmı ilklendirildi.&quot;);<br>    }<br><br>    // Concrete Method: Her hayvanın nefes alması aynıdır (Kod tekrarını önler)<br>    public void nefesAl() {<br>        System.out.println(ad + &quot; nefes alıyor...&quot;);<br>    }<br><br>    // Metot imzası: &quot;Neyin&quot; yapılacağını söyler ama &quot;nasıl&quot; yapılacağını Child&#39;a bırakır<br>    public abstract void sesCikar();<br><br>    // Getter (Private alana erişim için)<br>    public String getAd() { return ad; }<br>}</pre><p>İçinde ortak alanlar, ortak metotlar(concrete veya abstract metotlar) ve ortak alanları başlatmak için ortak constructor vardır.</p><h4>Interface Class (Arayüz)</h4><p>Ben arayüzü kendimce bir A sınıfının ne yaptığı ile nasıl yaptığını birbirinden ayırır diye düşünüyorum.</p><p>Eğer A, B, C gibi aynı şeyi yapan ancak aralarında is-a ilişkisi olmayan sınıflar varsa bunların bu ortak işi yapacağını söyleme yolu Interface sınıfını implement etmeleridir,</p><p>Yani bu sınıflar Interface’deki işi yapacaklarına dair Sözleşirler/Taahhüt verirler.</p><p>Mesela: Yikanabilir (Washable) diye bir interface düşünelim.</p><ul><li>Bir Elma da yıkanabilir, bir Araba da yıkanabilir.</li><li>Ama bir Elma ile Araba arasında bir &quot;is-a&quot; (miras) ilişkisi yoktur. Elma bir meyvedir, araba bir araçtır.</li><li>İşte burada “miras” (Abstract Class) tıkanır, “yetenek” (Interface) devreye girer.</li></ul><blockquote>üzerine ek başlık açmayacağım ancak yazmakta fayda var; bu miras veya bir tür ondan olma ilişkisine is-a denirken; ortak eylem birliğine ise can-do ilişkisi denir</blockquote><p>— — — — — — — — — — —</p><p>Diyelim ki bir <strong>OdemeSistemi </strong>interface’imiz var ve içinde <strong>odemeYap()</strong> diye bir metot imzası var.</p><ul><li><strong>Kredi Kartı</strong> sınıfı bu ödemeyi bir API üzerinden yapar.</li><li><strong>Nakit</strong> sınıfı bu ödemeyi kasayı açarak yapar.</li><li><strong>Kripto</strong> sınıfı ise blockchain üzerinden yapar.</li></ul><p>Üçü de birer ‘Ödeme Yöntemi’dir ama birbirlerinden tamamen farklı dünyaların insanlarıdır (sınıflarıdır).</p><p>Ortak bir atadan gelmelerine gerek yoktur; sadece aynı işi (Ödeme Yapmak) yapabiliyor olmaları onları bu arayüzde birleştirir.</p><ul><li>Yani interface’in amacı kendini implement’e eden sınıfların ne yapabileceğini dışarıya söylemektir, ancak nasıl yapacaklarını sınıfın kendilerine bırakır.</li><li>Yani içeriği tamamen abstract metot’lardan oluşur.</li><li>Hatta interface’deki tüm metotlar varsayılan olarak “<strong>public abstract</strong>” idir. sen yazmasan bile derleyici öyle kabul eder.</li><li>Bir Sınıf bir interface’i implemente ettiğinde, onları yapacağını taahhüt eder.</li><li>Yani o <strong>interface’i uygulamak zorundadır</strong></li><li>Bir interface sınıftan <strong>nesne oluşturma hedefimiz yoktur</strong> ki oluşturulamaz.</li><li>Ana amacı (can-do) eylem/metotları tanıtmak olduğundan <strong>alanları yoktur</strong>.</li><li>Alanları olmadığı için onları kuracak <strong>kurucusu</strong> da yoktur.</li></ul><blockquote>Aslında interface içinde değişken tanımlayabilirsin ama bu bildiğimiz anlamda bir “nesne alanı” (instance field) değildir.</blockquote><blockquote>Interface içindeki her değişken otomatik olarak public static final&#39;dır.</blockquote><blockquote>Yani bunlar aslında <strong>Sabitlerdir (Constants)</strong>.</blockquote><blockquote><strong>Örnek:</strong> “double PI = 3.14;” yazabilirsin ama “int elmaAgirligi”yazıp içini boş bırakamazsın. Çünkü nesne oluşturulamadığı için bu alana daha sonra değer atayacak bir this referansı olmayacaktır.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OXU6cdTdZ8eSw8uo2gplGQ.png" /></figure><h4>JAVA 8 SONRASI</h4><p>Buradan sonra interfaceler için değişiklikler oldu:</p><ul><li>Artık interface’lere gövdesi olan metotlar (concrete method) yazabilir hâle geldik.<br>(<strong>default</strong> anahtar kelimesi ile)</li><li>Interface içine static method yazabilme imkanı geldi ki o arayüzle ilgili yardımcı metotları bir helper(utility) sınıfına yazmak yerine doğrudan interface içine gömebilelim.</li><li>FONKSIYONEL PROGRAMLAMA ile ilgili olarak FONKSIYONEL INTERFACE gelmiş oldu:<br>yani Eğer bir Interface içinde sadece <strong>bir tane</strong> abstract metot varsa, buna artık “Functional Interface” diyoruz. Bu da bizi o meşhur <strong>Lambda</strong> ifadelerine götürüyor.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=124cb4500def" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3)Kalıtım(Inheritance)]]></title>
            <link>https://medium.com/@furkn.ttr/3-kal%C4%B1t%C4%B1m-inheritance-c6d368946255?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/c6d368946255</guid>
            <category><![CDATA[jvm]]></category>
            <category><![CDATA[memory-management]]></category>
            <category><![CDATA[software-developer]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Sun, 19 Apr 2026 16:24:02 GMT</pubDate>
            <atom:updated>2026-04-19T16:24:02.881Z</atom:updated>
            <content:encoded><![CDATA[<p>3.3)Java’da bellek akışı ve new() ile ne olur?</p><p>Java’da bellek akışı ve new ile olacaklar kısmı benim için de yazısını yazmaya başlayınca araştırdığım ve henüz öğrendiğim bir konu.</p><p>Ayrıca bu kısım özellikle Java’yı ilgilendiriyor, bu yazının nesne konusuyla ilgili genel bilginize katkı saglayacak bir yazı olacağını pek sanmıyorum, eğer Java’ya meraklıysanız okumanızı daha çok tavsiye ederim.</p><p>Neleri Aktardık? kısmında bellek ile ilgili atıflarda bulunmuştuk, burada ise daha teknik olucak ve bu yazıyı nasıl basitleştirebilirim açıkçası bilmiyorum. O yüzden daha teknik ve çabalanması gereken şekilde kalması daha olası.</p><p>Teknik olarak boğmadan önce Analojiyle bir tasvirde bulunmanın, anlama sürecini yumuşatacağını düşünüyorum buradaki analojimiz ise şu:</p><ul><li>Kütüphaneye girerken elimizde bir kimlik kartı vardır ve içinde sadece temel bilgilerimiz yazar, adımız, yaşımız ve geçerlilik tarihi ve kütüphanenin konumu gibi daha başka ekstra bilgiler bulunmaz.</li><li>Kütüphanenin kendisi ise bizim ana noktamızdır burada tüm kitaplar bulunur ve biz istediğimizi alırız, kütüphanenin içindeki kitap miktarı artıp azalabilir ama bu bizim kimliğimiz üzerinde değişiklik yapmaz.</li><li>Ayrıca aldığımız ve okuduğumuz kitaplarla ilgili nerede kaldığımızı veya diyelim anlamını bilmediğimiz ve sonrasında araştırmak istediğimiz kelimeleri bir not kağıdına geçici olarak notlayabiliriz.</li></ul><blockquote>Bu kısmı doğrudan verince şu an havada kalmış olabilir ama okumanın devamında benzer biçimde kafanızda parçaları oturtmalar yapacağınızı düşünüyorum.</blockquote><p>Bu noktada tanıtmam gereken bazı bellek bölgeleri var, bunların en temeli Heap/Method Area/Stack üçlüsü:</p><ol><li><strong>Heap:</strong> “new A()” ile nesnemizi oluşturduğumuz yer, burada nesnenin kendisi oluşur, bu bizim kimlik kartımızdır, vptr (VPointer) ve alanlar bu nesnede saklanır.<br>(İçeriğin nasıl olduğu detaylandırılacak.)</li><li><strong>Method Area: </strong>Burada ise Sınıfımızda yazdığımız kodun kendisi bulunur, yanında VTable denilen ekstra bir tablo ile bulunur, burası bizim kütüphanemizdir.<br>(İçeriğin nasıl olduğu detaylandırılacak.)</li><li><strong>Stack: </strong>Burada bir fonksiyon çalışırken onunla ilgili tutulması gereken geçici bilgiler ile fonksiyonun çalışması bitince geri dönülecek satır bilgisi tutulur.</li><li><strong>Constant Pool (Construction Pool):</strong> Bu bölgede biz bir sınıfı yazınca o sınıfın Constructor’ı otomatik olarak Constructor Pool’da bellek konumu önceden belli şekilde durur. (Constant Pool’un Bu kadarı bize yeterli)</li></ol><p>Buradan sonra parça parça akışı kurmaya ve detaylara başlarsak.</p><p>Biz bir Sınıf’ın nesnesi oluşturunca ( new Kedi(); ) Heap’te o nesne oluşur ancak içinde ne vardır? bizim Sınıfımızın alanları(fields), header’ları ve bir adet vptr(VPointer) bulunur.</p><ul><li>Yani sınıfın içine yazdığımız metotlar heap’teki nesnemizin boyutu arttırmaz veya azaltmaz, her zaman header + alanlar + vptr kadar yer tutar heap’te.</li><li>Peki “vptr” nereyi gösterir? Bu bizim Method Area’da Bulunan Kedi() sınıf şablonumuzun en baş adresini gösterir (mesela Kedi method area’da 0x4000&#39; de ise Kedi nesnesinin vptr’si 0x4000&#39;i gösterir)</li></ul><blockquote>(Aslında header dediğimiz şeyin içinde Mark Word ile vptr bulunur ancak hem anlatımın devamında araya header katmadan vptr diyebilmek için hem de header’ı detaylı bilmediğim için her zaman ayrıymış gibi değerlendirip, yazarken de doğrudan vptr diyerek bahsedeceğim)</blockquote><p>Peki Kedi nesnemiz Method Area’daki bu yeri gösteriyor ancak bu yerde tam olarak ne var?(Burası sınıfımızın bytecode halini tutar, tüm kodumuz vardır)</p><ul><li>En başta Kedi şablonunun Field ve header’larının boyut bilgisi var (yani String ad gibi bir şey yok), VTable var, ve methodlar var.</li><li>Mesela bu kısmın başındaki bilgi şu, “Benim 12 byte alanım ve 8 byte header’ım var” gibi bir info bulunur.</li><li>VTable ise gene Sınıf şablonun içinde bulunur ve VTable o sınıfın methodları ile bellek konumlarını eşleştirir (offset ile) yani mesela der ki Kedi sınıfının A method’u için Bu şablondan itibaren +60 kaydır, o hâlde A metodu 0x403C (16&#39;lık sistem dikkat) konumunda demektir.</li><li>Hemen aşağısında ise method’ların kendileri vardır, VTable bu metotlardan ilgili metotun konumuna yönlendirir ve o metot return edene kadar çalışır.</li></ul><blockquote>VTable’ın Şablon içindeki konumu sabittir, genelde sonda veya en başta olur veya bi hesaplama ile çıkar diye geçse de kendi kafamda sabit bi nokta diye tasarladığım için mesela +64&#39;te bulunur diyorum ve kendimi de okuyucuyu da yormuyorum.</blockquote><blockquote>En doğru ifadesi ise VTable Konumu = vptr + Klass_Header_Size</blockquote><p>Peki Return edilince nereye döner? O bilgiyi tutan stack, main’deki bir sonraki satırın bilgisini tutmuştur aslında yani return ile belleğin okuma konumu bir sonraki satıra dönüş yapar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WKcnKninwm0oBU4axIqLLQ.png" /></figure><h3>Çalışma Akışı (PİPELİNE)</h3><p>Şimdi Tüm Bu parçaları birleştirip verinin nasıl aktığını, bellekte o esnada neler olduğunu pipeline şeklinde görmeye çalışalım:</p><blockquote><strong>Ön bilgi 1:</strong> Main Sınıfının da diğer sınıflardan farkı yoktur yani onun da tüm bytecode hâli Methot Area’da bulunur.</blockquote><blockquote><strong>Ön bilgi 2:</strong> Adresleri ise 0x1000 şeklinde 16 lık gösterimle yazıcam ama hesaplarıyla uğraşmamak için burada doğrudan toplayacagım mesela 0x1000&#39;i +10 kaydırırsam 0x1010&#39;a gider gibi sanki Onluk sistemmiş gibi ilerleticem.</blockquote><p>Senaryomuz şu: “main” kodumuz Method Area&#39;da <strong>0x1000</strong> adresinden itibaren çalışıyor olsun.</p><ul><li>main kodunun 433. satırında “ new Kedi();” ifadesi olsun.</li><li>hemen sonraki 434. satırda ise kediNesnesi.sesCikar(); metodu olsun.</li></ul><p>Main metodu 433. satıra gelince new Kedi() ile ne olur?<br>(Aslında bu ifade ile toplu işler gerçekleşir)</p><ol><li>Main 0x1000 den 433. satıra yani 0x1433&#39;e gelir ve orayı çalıştırmaya başlar. (new Kedi(); )</li><li>Öncelikle new ifadesini görünce heap’te bi alan oluşturulur Peki bu alanın boyutu ne olacak?</li><li>Kedi() bilgisi de gelince burada jvm bakar Kedi diye bir şey method areada var mı? (Var ise Kedi yi bilir zaten ve bulup getirir direkt) Eğer yoksa onun .class dosyasını method area’ya yükler, rastgele bi noktaya mesela 0x4000 noktasından itibaren yükler.</li><li>Yüklediği konumdaki şablona gider ve yüklediği kodun başını okur, “Benim 12byte field’ım, 8 byte header’ım var”.</li><li>Okuduktan sonra heap’e döner ve 20byte’lık yer açar, 0x4000 bilgisini de vptr’ye geçer (yani nesne artık kim olduğunu biliyor.)</li><li>Buradan sonra ise Constructor Pool’dan Kedinin sabit olarak bildiği constructor’ına gider ve ona Kedi’nin Heap’teki yerini verir.</li><li>Constructor Bu Kedi nesnesine Alanların kendisi ile başlangıç değerlerini “Burası böyleymiş, şura şöyleymiş” diyerek doldurur.</li><li>Artık nesnemiz oluştu; boyutu tamam, alanları tamam, initalize edildi ve 0x4000 yani kendini tanıyor. buradan sonra return edilir.</li><li>Return adresi ise 433. Satırdan 434. Satıra yani 1434. Adrese geçer.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d8R-MFN8l8tr_w-qsskwlg.png" /></figure><p>— — — — — — — — — — — — — —</p><p>Peki bu nesnenin oluşumu bitti, buradan 434. satıra da geçti ve 434. satırda kediNesnesi.sesCikar() metodu var demiştik, Burası nasıl çalışıcak?</p><ol><li>Main 0x1434&#39;ü çalıştırmaya başlar (kediNesnesi.sesCikar() )</li><li>Heap’teki kediNesnesi nesnesine gider ve içindeki vptr’den Kedi şablonuna (0x4000) gider.</li><li>Burada +64 sabit noktasından VTable’a yani 0x4064&#39;e gider ve sesCikar()’ın sırasına gider (mesela 3. sıra ise 2. indis’e gider, yani aslında VTable’da bir dizidir/listedir)</li><li>Burada 2. indis’e bakar içinde Şablonun başından itibaren (0x4000) kaç satır kayması gerektiği bilgisi vardır. mesela +139 olsun o halde 0x4139&#39;da sesCikar()’ın gerçek bytecode’u vardır.</li><li>burada 0x4000 + 139 hesaplaması yapılır ve 0x4139&#39;a atlanıp(JUMP) Method area’daki bu bytecode return’e kadar çalıştırılır.</li><li>Return satırına gelince ise Stack’imizin sakladığı sonraki main adresi olan 435. satıra yani 1435. Adrese geçiş yapılır.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nV6bwC5Er6B0EMIQrnB0Xw.png" /></figure><blockquote>Bu anlattıklarım aslında <strong>Polimorfizm (Çok Biçimlilik)</strong> konusunun neden çalıştığının cevabıdır. Çünkü bir nesnenin tipi ne olursa olsun, vptrher zaman gerçekte ne olduğunu (Kedi mi, Köpek mi) gösterir.</blockquote><p>Bundan Sonraki Kavramlarımız:</p><ol><li>ÇOK BİÇİMLİLİK (POLYMORPHISM)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6d368946255" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2) KALITIM(INHERITANCE)]]></title>
            <link>https://medium.com/@furkn.ttr/2-kalitim-inheritance-c6ecd367c37f?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/c6ecd367c37f</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[inheritance]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Fri, 17 Apr 2026 03:51:27 GMT</pubDate>
            <atom:updated>2026-04-17T04:05:20.425Z</atom:updated>
            <content:encoded><![CDATA[<h3>2)KALITIM(INHERITANCE)</h3><p>3.2) NELERİ AKTARIRIZ?</p><p>Daha önce hatırlarsak Hayvan Sınıfımızı oluşturmuştuk,<br>Tekrar vermek gerekirse:</p><pre>abstract class Hayvan {<br>    private String ad; // Sadece bu sınıfa özel (Encapsulation)<br>    protected int yas; // Alt sınıflar (Kedi/Köpek) doğrudan erişebilir<br><br>    public Hayvan(String ad, int yas) {<br>        this.ad = ad;<br>        this.yas = yas;<br>        System.out.println(ad + &quot; için bellekten yer ayrıldı ve Hayvan kısmı ilklendirildi.&quot;);<br>    }<br><br>    // Concrete Method: Her hayvanın nefes alması aynıdır (Kod tekrarını önler)<br>    public void nefesAl() {<br>        System.out.println(ad + &quot; nefes alıyor...&quot;);<br>    }<br><br>    // Metot imzası: &quot;Neyin&quot; yapılacağını söyler ama &quot;nasıl&quot; yapılacağını Child&#39;a bırakır<br>    public abstract void sesCikar();<br><br>    // Getter (Private alana erişim için)<br>    public String getAd() { return ad; }<br>}</pre><p>Daha sonra ise Kedi ve Köpege Miras verdirmiştik, şimdilik sadece Kediye verdirelim:</p><pre>public class Kedi extends Hayvan {<br>    public Kedi(String ad, int yas) {<br>        super(ad, yas);<br>    }<br><br>    @Override<br>    public void sesCikar() {<br>        System.out.println(getAd() + &quot;: Miyav!&quot;);<br>    }<br>}</pre><p>Şimdi Kedi sınıfımız Hayvan’ı miras aldı ama yani? Kendine neleri aldı tam olarak? Neler Aktarıldı?</p><p>Kalıtım yoluyla “Child” sınıfa temelde iki ana unsur geçer:</p><ul><li><strong>Alanlar (Fields):</strong> Üst sınıfta tanımlanmış olan değişkenler alt sınıfa aktarılır. Nesne “new” ile oluşturulduğunda, Child nesnesi bu alanları kendi bünyesinde barındırır.</li><li><strong>Metotlar (Behaviors):</strong> Üst sınıfın sahip olduğu fonksiyonel yetenekler Child sınıf tarafından kullanılabilir hale gelir. Child sınıf bu metotları olduğu gibi kullanabilir veya override ederek davranışını değiştirebilir.</li><li>Static metot/alanlar ile Constructorlar <strong>yapısı geregi </strong>aktarılmaz çünkü:<br>-Static alan/metotlar sınıfa ait demektir, hâliyle aktarmak mantıksızdır.<br>-Constructor’lar gene o sınıfın kurucusudur ve aktarılması mantıksızdır.</li></ul><blockquote><em>Unutmayalım üst sınıfta var olan tüm metotlar ve alanlar aktarılır, en azından Child için ayrılan bellek alanında private bile olsa HEPSİNİN YERİ OLUŞUR. (static ve constructor’lar hariç)</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sSnwFHZmPNEnf8x3XVYh9Q.png" /></figure><p>Bu iki Kedi nesnesi teknik olarak birbirinin ikizidir, biz miras ile sağdaki kod tekrarından kurtulduk, daha şu an bahsetmesek de yönetim olarak yeni yöntemlere kapı da araladık.</p><p>Şimdi Hem Kedi hem de Köpek’e miras aldırırsak:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IcAQGqtC3ZOoR_KkXc_yCQ.png" /></figure><blockquote><em>Şu anda “neleri aktarıyoruz?” sorusunun cevabında güzel ilerledik ancak eksik hatta yetersiz çünkü şartları ve durumları pek incelemedik, aşağıda bu sorunun cevaplarını vermeye başlayalım.</em></blockquote><h4>!!!YETERSİZLİKLERİ GİDERELİM!!!</h4><p>Bu aktarılan temel iki unsurumuz (alanlar ve behaviorlar) Child’a birebir aktarılır ve hepsinin bellekte yeri açılır, Child’ın bellekte kapladığı alanda yeri vardır yani, ancak:</p><ol><li>Bu aktarılan iki unsurdan aktarım gerçekleşse bile erişim yetkisi sebebiyle KULLANAMAYACAGI şeyler vardır (örn: private alanlar veya metotlar).</li></ol><p>Burada demiştik ki private alanlar da aktarılıyor ve child için bellekte yeri açılıyor ama erişemiyorsak ne için açılıyor bu yer, israf değil mi?</p><p>Cevap HAYIR, Bu Java’nın kalıtımı nasıl yönettiğini anlatıyor aslında, durum şu mesela hayvandaki <em>“private ad;”</em> alanı child için (kedi/köpek) erişilemez durumda yani kedi sınıfındayken this.ad dersem compiler bana oraya erişimim olmadığını söylecektir.</p><p>Fakat ya benim miras aldığım public veya protected bir method bu alanı kullanıyorsa?</p><ul><li>Bu durumda o metodu Child’da çalıştırdığımda Child kendi üstünde ona özel açtığı alandan bunu kullanacak.</li></ul><p>Ya da mesela Parent’ta bir private ve bir public method var ve public olan kendi içinde private method’u kullanıyor, bu durumda biz public olanı kalıtım ile aldıktan sonra kullanırsak ne olacak?</p><ul><li>Her ne kadar belleği child’da da açılmış olan o private method’a doğrudan erişimimiz olmasa da bu durumda o public method aracılığı ile private method çatır çatır çalışacaktır.</li></ul><h4>2. Kurucunun Durumu</h4><blockquote>Başlamadan şu bilgileri vermekte/hatırlatmakta fayda var:</blockquote><blockquote>Java’da her değişkenin bir değeri mutlaka atanmak zorundadır, initialize yapılmamış bi değer olmamalıdır.</blockquote><blockquote>Yukarıdaki sebeple her Sınıfın Mutlaka bir kurucusu (constructor) olmak zorundadır, eğer açıkça yazılmazsa java tarafından varsayılan/boş kurucu atanır.</blockquote><p>Kurucu ile ilgili aktarımdaki duruma gelirsek Child belleğinde biz bunun yerini açmıyoruz yani kurucu method (constructor) aktarılmıyor, zaten bu yüzden super() diye bir ekstra anahtar kelimemiz var.</p><p>Peki şimdi biz Parent’tan alanlar alıyoruz ve onları başlatmamız (initialize) gerek çünkü başlangıç değeri olmadan olamaz değişkenler.</p><p>Bunun sonucu olarak bizim Child’ın gidip Parent’ın Constructor’ını çağırması bi zorunluluktur yani ondan aldığı alanların başlatıldığını böylece garanti eder.</p><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p>3.3) Java’da bellek akışı ve new() ile ne olur?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6ecd367c37f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[1) KALITIM(INHERITANCE)]]></title>
            <link>https://medium.com/@furkn.ttr/1-kalitim-inheritance-f4ab42813298?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4ab42813298</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[inheritance]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 13:25:12 GMT</pubDate>
            <atom:updated>2026-04-15T13:25:12.902Z</atom:updated>
            <content:encoded><![CDATA[<h3>1)KALITIM(INHERITANCE)</h3><h4>3.1) extends, super, method override, is-a/has-a ilişkiler.</h4><blockquote>Bu noktada şunu söylemek doğru olacaktır diye düşünüyorum, <br>An itibariyle nesneyi koda geçirme noktasından tamamen çıktığımızı artık bu nesne ile ilgili (doğru tabirse eğer) stratejik kararlar aldığımız noktadayız.</blockquote><p>Ayrıca Kalıtım konusunu birden fazla yazı olarak yazmayı düşünüyorum ve şimdilik şu şekilde işlemeyi düşünüyorum:</p><p>KALITIM:</p><ol><li>Extends, Method Override, Super, is-a/has-a</li><li>Kalıtım ile neler aktarılır?</li><li>Java’da bellek akışı ve new() ile ne olur?</li></ol><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><blockquote>Kalıtımın bu yazısında daha çok kavramsal yer oturtma odaklı anlatım yapılacak.</blockquote><p>Peki yazdığımız en az iki nesneyi düşünelim mesela bir Kedi ile bir Köpek bu iki nesnemiz Köpek(havla, nefes Al…); Kedi (miyavla, nefesAl…) metotlarına sahip olabilir.</p><p>İyi de ikisi de aynı şekilde nefes almaz mı? bunları ayrı ayrı iki sefer yazmak mantıklı mı? <br>Peki biraz daha düşünürsek miyavla ile havla da ses çıkarmak olamaz mı direkt, aslında doğru aynı sesleri çıkartmıyorlar, “miyav” ile “hav” asla aynı değil ancak konsept olarak da farklı değiller, o halde biz bunları daha sonra bir şekilde özelleştirsek?<br>Bu durumda “ses çıkar” diyebiliriz bu ikiliye.</p><pre>abstract class Hayvan {<br>    private String ad; // Sadece bu sınıfa özel (Encapsulation)<br>    protected int yas; // Alt sınıflar (Kedi/Köpek) doğrudan erişebilir<br><br>    public Hayvan(String ad, int yas) {<br>        this.ad = ad;<br>        this.yas = yas;<br>        System.out.println(ad + &quot; için bellekten yer ayrıldı ve Hayvan kısmı ilklendirildi.&quot;);<br>    }<br><br>    // Concrete Method: Her hayvanın nefes alması aynıdır (Kod tekrarını önler)<br>    public void nefesAl() {<br>        System.out.println(ad + &quot; nefes alıyor...&quot;);<br>    }<br><br>    // Metot imzası: &quot;Neyin&quot; yapılacağını söyler ama &quot;nasıl&quot; yapılacağını Child&#39;a bırakır<br>    public abstract void sesCikar();<br><br>    // Getter (Private alana erişim için)<br>    public String getAd() { return ad; }<br>}</pre><p>Peki bu sınıfı kedimize veya köpeğimize nasıl miras aldıracağız?</p><ol><li>Extends:<br>Bu anahtar kelimeyi kullanarak bir sınıfa diğer sınıftan miras aldırırız.</li></ol><p>Kedimize miras aldırırsak:</p><pre>public class Kedi extends Hayvan {<br>    public Kedi(String ad, int yas) {<br>        super(ad, yas);<br>    }<br><br>    @Override<br>    public void sesCikar() {<br>        System.out.println(getAd() + &quot;: Miyav!&quot;);<br>    }<br>}</pre><p>Köpek için de miras aldırırsak:</p><pre>class Kopek extends Hayvan {<br>    public Kopek(String ad, int yas) {<br>        super(ad, yas);<br>    }<br><br>    @Override<br>    public void sesCikar() {<br>        System.out.println(getAd() + &quot;: Hav Hav!&quot;);<br>    }<br>}</pre><p>Artık ikisi de Hayvan sınıfından miraslarını aldılar ayrıca burada artık kod ile ilgili değinmemiz gereken noktalar var:</p><ul><li><em>Daha önce “Ya bunları özelleştirsek?” demiştik</em></li></ul><ol><li><strong>Metot Ezme (Metod Override)</strong><br>Bu bizim o özelleştirmeyi yapmaya verdigimiz isimdir. <br>Bize kalıtım ile gelen bir metodu kendimiz için daha farklı çalışmasını istiyorsak kullanırız.<br>Miras aldığımız metotun üzerine <strong>@Override</strong> annotasyonunu geçeriz ve içeriğini normalde nasıl metot yazıyor isek o şekilde yazarız.<br><em>(örn: Yukarıdaki Kedi ve Köpek Sınıflarımız bunu yapmış)</em></li><li><strong>Super Anahtar Kelimesi</strong><br>“super” anahtar kelimesi üst sınıfın constructor’ına erişmemizi sağlar yani koddaki super(ad, yas) ifadesi Hayvan sınıfının constructor’ını çağırıyor.</li></ol><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><h3>1. “is-a” İlişkisi (Kalıtım / Inheritance)</h3><p>Bu ilişki <strong>kimlik (identity)</strong> ile ilgilidir. Bir sınıfın, başka bir sınıfın daha özelleşmiş bir versiyonu olduğunu söyler.</p><p>Kedi bir hayvandır, Köpek bir Hayvandır ya da mesela;<br>Önünüze bir meyve tabağı konulsa ve size sorsam hangisi meyve?<br>neyi “meyve” olarak gösterirsiniz? elmayı mı, armutu mu?</p><p>Bunların hepsi birer meyvedir, meyve ismi onların en generic adıdır ama özeldeki adı elmadır veya armuttur günün sonunda ise bir is-a ilişkisi vardır yani elma bir çeşit meyvedir, bir tür meyve işte is-a yani.</p><ul><li><strong>BELLEK AÇISINDAN: </strong>Bellek perspektifinden bakarsak; is-a ilişkisinde Child nesnesi, Parent nesnesini fiziksel olarak kendi içinde barındırır. Heap&#39;te ayrılan tek bir blok vardır ve bu blok hem atanın hem de çocuğun verilerini içerir. VTable (Sanal Metot Tablosu) bu hiyerarşiyi birbirine bağlar.</li></ul><h3>2. “has-a” İlişkisi</h3><p>Bu ilişki <strong>sahiplik (ownership)</strong> veya <strong>üyelik</strong> ile ilgilidir. Bir sınıfın, başka bir</p><p>Mesela insan nesnemiz olsun, nesnemizin alanlarından biri şu olsa:<br><strong>Hayvan evcilHayvan;<br> </strong><br>bu durumda ne olur?İnsan nesnemiz artık bir evcilHayvan sahibidir, biz ona kedi veya köpek de verebiliriz<br><strong>evcilHayvan = new Kedi();<br>evcilHayvan=new Köpek();</strong></p><p>İşte bu bir sahiplik ilişkisidir (has-a) ikinci bir örnek verirsek,</p><p>Bir bilgisayar nesnem alan olarak bir monitor ile bir klavye nesnesi alabilir ancak bunun aksine gidip Bilgisayar bir çeşit klavyedir demek yanlış olacaktır.</p><ul><li><strong>BELLEK AÇISINDAN: </strong>Bellekte genellikle iki ayrı blok vardır (veya iç içe). Bir ana nesne (Araba), heap’teki başka bir nesnenin (Motor) adresini (pointer/reference) tutar. Yani nesneler birbirine sıkı sıkıya bağlı olmak zorunda değildir; motoru çıkarıp başka bir arabaya takabilirsin</li></ul><p>— — — — — — — — — — — — — — — — — — — — — — — — — — — — —</p><p>3.2)Kalıtım ile neler aktarılır?</p><p>3.3)Java’da bellek akışı ve new() ile ne olur?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wlAvdHdDCycZo7qHvYuvw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4ab42813298" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KAPSÜLLEME (ENCAPSULATION)]]></title>
            <link>https://medium.com/@furkn.ttr/kaps%C3%BClleme-encapsulation-9ecbca9d2d30?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ecbca9d2d30</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[encapsulation]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[oop-concepts]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Sun, 12 Apr 2026 03:01:01 GMT</pubDate>
            <atom:updated>2026-04-12T03:01:01.439Z</atom:updated>
            <content:encoded><![CDATA[<p>Daha önce Soyutlama (Abstraction) ile bir nesneyi koda aktarmıştık<br>Artık yazılım sahasındayız ve nesne yönelimli felsefeye göre biz nesnelerimizin birbiriyle etkileşimini isteriz.</p><p>Yazılım noktasında olduğumuza göre bu bağlamda artık nesneleri yönetmeli, yazılımdan kaynaklı düşünülmesi gereken gereklilikleri yerine getirmeli ve bazı kararları almalıyız.<br> — — — — — — — — — — — — — — — — — — — — — — — — — — <br>Peki ilk etkileşimimizi kurgulayıp olası sorunları çözelim.</p><p>Hatırlarsak koda aktardığımız bir su şişemiz vardı, peki bir başka nesne daha olsa sistemde, mesela insan.</p><p>İnsanımız farklı bir sayfada ve su şişemiz ile insanımızı main’de buluşturuyoruz ancak bir sorun var, insan nesnemiz su şişesi nesnemizden su içmek için kapağının açık olup olmadığını ve dolu olup olmadığını bilmek istiyor, hatta eğer su nesnemiz boş ise doldurmak istiyor.</p><p>Öncelikle buna göre insanımızı soyutlayalım:</p><pre>public class Insan {<br>    public String isim;<br><br>    public void suIc(SuSisesi sise) {<br>        if (sise.kapak == false) {<br>            System.out.println(isim + &quot;: Kapak kapalıymış, kapağı açıyorum.&quot;);<br>            sise.kapak = true;<br>        }<br><br>        // Suyu içti 150 birim kadar!?<br>        sise.doluluk -= 150; <br>        System.out.println(isim + &quot; 150 birim su içti. Güncel doluluk: &quot; + sise.doluluk);<br>    }<br><br>    public void suDoldur(SuSisesi sise) {<br>        if (sise.kapak == false) {<br>            System.out.println(isim + &quot;: kapalı kapağı açıyorum.&quot;);<br>            sise.kapak = true;<br>        }<br>        <br>        //100 birimlik suya 5000 birim doldurmak!?<br>        sise.doluluk = 5000; <br>        <br>        System.out.println(&quot;İşlem tamam. Şişenin yeni hali: &quot; + sise.doluluk);<br>    }<br>}</pre><p>Şimdi duruma bi bakalım:</p><ol><li>İnsan nesnemiz kapağın mevcut durumunu doğrudan erişerek kontrol ediyor (sise.kapak)</li><li>gözünüze çarpmış olmalı ki insan nesnemiz suyu içtiği taktirde tam dolu (100 birim) bile olsa 150 birim içiyor yani -50 birim kalıyor, -50 birim su kalabilir mi?</li><li>İnsan nesnemiz suyu doldurursa hacminden daha fazla (5000 birim) dolduruyor bu da gene tutarlı bi durum değil.</li></ol><p>Yani kısaca bu durumdaki temel soruna baktığımızda su nesnemizin kendi alanları (doluluk, kapak…) herhangi bir korumaya sahip değil,<br>yani bizim su şişesinin bu alanlarını daha güvenli hale getirmemiz lazım.</p><blockquote>Bu güvenli hale getirme işini kimin erişip, kimin erişemeyeceğini belirleyerek yani <strong>KAPSÜLLEME</strong> yaparak sağlarız.</blockquote><p>Kapsülleme kapsamında bizim kullanabileceğimiz erişim belirleyici anahtar kelimeler 4 tanedir:</p><ol><li><strong>public:</strong> Herkesin erişimine açık. Her yerden erişilebilir.</li><li><strong>private:</strong> Kapsüllemenin kalbidir, en sık kullanılır. Sadece tanımlandığı sınıf içinden erişilebilir.</li></ol><p><strong><em>protected</em></strong><em> ve </em><strong><em>default</em></strong><em> erişim belirleyicilerini atlıyorum, çok kısalar istenirse hızlıca bakılabilir, bu konuşmada o kadar gerekli değiller.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1ScHBXEHyAZa8IBE.png" /></figure><p>Şimdi su şişemize kapsüllersek:</p><pre>public class SuSisesi {<br>    private String marka;  <br>    private String sekil;<br>    private double doluluk;<br>    private boolean kapak;<br>}</pre><p>şu anda su şişemizin alanlarını diğer sayfalardan sakladık, artık kimse kafasına göre veri yaz sil yapamaz.</p><p><strong>ANCAK</strong> bir sorunumuz var, nesnelerimizin birbiriyle etkileşimini isteriz dedik ve görüyoruz ki insan nesnemiz hâlâ bizden kapağın durumunu ve kapalı ise açabilmeyi istiyor ayrıca suyu içmek için de doluluk bilgisini istiyor, bu durumda ne yapacağız?</p><p>İşte bu durumda getter/setter’lar ile erişimlerin nasıl olacağına biz karar vereceğiz.</p><p>su şişemizin getter/setterlarını yazalım:</p><pre>public class SuSisesi {<br>    private String marka;  <br>    private String sekil;<br>    private double doluluk;<br>    private boolean kapak;<br><br>    // GETTER: Bilgi alma kapısı (Read-only)<br>    public double getDoluluk() {<br>        return doluluk;<br>    }<br><br>    public boolean isKapak() { // Boolean&#39;larda &#39;get&#39; yerine &#39;is&#39; kullanılır<br>        return kapak;<br>    }<br><br>    // SETTER: Veri yazma kapısı (Write-only)<br>    public void setDoluluk(double yeniDoluluk) {<br>        // setlerken bize setlememiz istenen veriyi kontrol ediyoruz.<br>        if (yeniDoluluk &gt;= 0 &amp;&amp; yeniDoluluk &lt;= 100) { <br>            this.doluluk = yeniDoluluk;<br>        } else {<br>            System.out.println(&quot;Hata: Fizik kurallarına aykırı dolum! (0-100 arası olmalı)&quot;);<br>        }<br>    }<br><br>    public void setKapak(boolean durum) {<br>        this.kapak = durum;<br>    }<br>}</pre><p>İnsanımıza bu yeni hâli ile şişeyi kullandırtırsak:</p><pre>public class Insan {<br>    public String isim;<br><br>    public void suIc(SuSisesi sise) {<br>        // Doğrudan &#39;sise.kapak&#39; diyemeyiz, kapıdan sormamız lazım:<br>        if (!sise.isKapak()) {<br>            System.out.println(isim + &quot;: Kapak kapalıymış, açılmasını talep ediyorum.&quot;);<br>            sise.setKapak(true); <br>        }<br><br>        // Suyu azaltırken bile kontrol şişede!<br>        double mevcutSu = sise.getDoluluk();<br>        sise.setDoluluk(mevcutSu - 20); <br>    }<br>}</pre><p>Artık insan nesnemiz private erişim belirleyiciden ötürü doğrudan erişemez yani kapsülledik, onun yerine bizim ona sunduğumuz getter/setter’lar ile erişim sağlar ki biz orada girilen veriyi kontrol ediyoruz yani tutarsız davranma şansı kalmadı.</p><p>— — — — — — — — — — — — — — — — — — — — — — — — — —</p><h3>ŞİMDİ GERÇEKLERİ YÜZÜMÜZE VURALIM</h3><p>Harika nesneyi oluşturduk ve iki nesneyi yönettik gibi duruyor ancak sorun şu ki gerçekte setter/getter’lar içerisinde bu kadar logic olmaz, daha çok veriyi olduğu gibi alır ve geri verir yapıda olurlar yani:</p><pre>public class SuSisesi {<br>    private String marka;<br>    private String sekil;<br>    private double doluluk;<br>    private boolean kapak;<br><br>    // Marka için Getter ve Setter<br>    public String getMarka() {<br>        return marka;<br>    }<br><br>    public void setMarka(String marka) {<br>        this.marka = marka;<br>    }<br><br>    // Şekil için Getter ve Setter<br>    public String getSekil() {<br>        return sekil;<br>    }<br><br>    public void setSekil(String sekil) {<br>        this.sekil = sekil;<br>    }<br><br>    // Doluluk için Getter ve Setter<br>    public double getDoluluk() {<br>        return doluluk;<br>    }<br><br>    public void setDoluluk(double doluluk) {<br>        this.doluluk = doluluk;<br>    }<br><br>    // Kapak için Getter ve Setter<br>    public boolean isKapak() {<br>        return kapak;<br>    }<br><br>    public void setKapak(boolean kapak) {<br>        this.kapak = kapak;<br>    }<br>}</pre><p>Şu anda aklınıza ilk gelen soruyu tahmin ediyorum:</p><blockquote>“Eee bu durumda private’in ne anlamı kaldı?, gene setter/getter ile public’miş gibi erişilebilir oldu. ayrıca şu anda yine mantık yönetimi kayboldu yani tutarsız girişler olabilir hâle gelmedi mi?”</blockquote><p>Bu soruya iki parça şeklinde bakalım:</p><ol><li>Tutarsız giriş konusuna bakalım.</li></ol><p>Hatırlarsak Soyutlama(Abstraction) anlatımımızda suyuAzalt ve suyuArttır şeklinde iki davranış(behavior) tanımlamıştık, biz genelde etkileşimler için bu davranışları kullanırız yani “Tell, Don’t Ask” şeklinde gideriz aslında ve bu davranışlar içerisinde veri ile ilgili mantık üretiriz veya mantığı yönetiriz. yani biz o kadar da getter/setter kullanmayız bu durum için.</p><blockquote>(Bu 2 numaralı soru/başlık yazının geri kalanına göre ileri kalabilir, eğer giriş seviyesinde isen anlamamanda bi sorun yok, yazma sebebim ise bu soru her aklınıza geldiginde kafanızda büsbütün bir boşluk yerine en azından şöyle bir şey duymuştum diyebilmeniz)</blockquote><p>2. Sorunun ilk kısmına gelirsek yani “Private’in ne anlamı kaldı?…”</p><p><strong>(Spring’i bize hizmet veren geniş çaplı bir nesne olarak düşünün, bizim diğer nesnelerimizi tanımak adına getter/setterları kullanıyorlar, Konuyu çok saptırmamak adına bu kadarla bırakıyorum) yani:</strong></p><p><strong>Framework Zorunluluğu (Spring/Hibernate):</strong> Spring gibi kütüphaneler bizim nesnelerimizi “yönetmek” için bu getter/setter standartlarına bakar. Yani biz aslında bu kapıları <strong>kendi kodumuz</strong> için değil, <strong>kullandığımız araçlar</strong> için açık bırakıyoruz.</p><p><strong>Bundan Sonraki Kavramlarımız</strong>:</p><ol><li>KALITIM/MİRAS (INHERITANCE)</li><li>ÇOK BİÇİMLİLİK (POLYMORPHISM)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ULt00DmxkL3BsIPe.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ecbca9d2d30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bir düşünce olarak OOP nedir?]]></title>
            <link>https://medium.com/@furkn.ttr/bir-d%C3%BC%C5%9F%C3%BCnce-olarak-oop-nedir-dadf14af31bf?source=rss-ea362949a1b7------2</link>
            <guid isPermaLink="false">https://medium.com/p/dadf14af31bf</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[abstraction]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Furkan Tatar]]></dc:creator>
            <pubDate>Thu, 09 Apr 2026 00:53:14 GMT</pubDate>
            <atom:updated>2026-04-13T01:33:44.154Z</atom:updated>
            <content:encoded><![CDATA[<p>Her fikrin olduğu gibi tabii ki bu fikir de bir sorunun çözümü için düşünülmüştür, her ne kadar kesin sorunu bilmesem de burada tahminim olan olası bi durumu anlatacağım.</p><p>Biz geçmişi düşünürsek C gibi bir dilde her şeyi yazabileceğimize karar verdik ancak gerçekten her şeyi yazabilir miydik? Cevap açıkça hayır çünkü o kod tek sayfada dolup şiştikçe hem okunamaz hem de üzerinde karar almanın zorlaşması ile yönetilemez hale gelecekti. Buna karşılık her şeyi kodlayabilme amaçlı ortaya atılan fikir ise basit ve akıllıcaydı. <br>Madem hepsini aynı anda yapamıyoruz o zaman gerçek hayattaki gibi sadece nesneleri kodlayalım, günün sonunda nesnelerin bütünü ile her şey elde edilecektir.</p><p>Fikir bulunduktan sonraki sorun ise peki bir Nesne nasıl kodlanır?</p><p>Mesela önünüze bir su şişesi alın ve inceleyin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LeYmmSiqTPgKdn3q" /></figure><p>Daha sonra bu su şişesini gözünüzün önünden kaldırın.</p><p>Şimdi ise su şişesini “düşünün”.</p><p>Şu anda aklınızda su şişesinin bi görseli canlandı:<br>bir markası, şekli, kapağı, rengi ve daha nice özellikleri, beynimiz su şişesinin bi temsilini çoktan belirli özellikleri ile birlikte sakladı.</p><p>Bizim de bir nesneyi kodlarken yapacağımız budur, ilgili nesneyi temsil eden özelliklerine bakarız.</p><blockquote><strong>Buna ABSTRACTION (SOYUTLAMA) deriz.</strong></blockquote><p>Su Şişesi nesnemizi kodlamaya başlarsak:</p><ol><li><strong>Nesnemizin özellikleri(durumları) neler?<br></strong>Bir kapağı var, markası var, şekli var, doluluk oranı var…</li></ol><p>Bunları Koda geçirirsek:</p><pre>public class SuSisesi {<br>    String marka;<br>    boolean kapak;<br>    String sekil;<br>    double doluluk;<br>}</pre><p>Peki bu yeterli mi? aslında hayır çünkü madem bi nesneden bahsediyoruz, o zaman nesnelerin davranışlarını (behavior) da düşünmeliyiz.</p><p><strong>2. Nesnemizin davranışları neler?<br> </strong>Kapağı aç, Suyu azalt(dök), Suyu arttır(doldur)…</p><pre>public class SuSisesi {<br>    String marka;<br>    boolean kapak;<br>    String sekil;<br>    double doluluk;<br><br>    // Nesnemizin eylemleri (Metotlar)<br>    void kapagiAc() {<br>        // ...<br>    }<br><br>    void suyuAzalt() {<br>        // ...<br>    }<br><br>    void suyuArttir() {<br>        // ...<br>    }<br>}</pre><p>Şu anki son sorunumuz ise gerçek hayatta bi su şişesi aldığımızda varsayılan olarak bi şekli, doluluk miktarı, kapak durumu ve markası varken bizim kodumuzun bu başlangıç durumunun bulunmaması.</p><p><strong>3. Bunu çözmek içinse bir (Kurucu) Constructor tanımlayacağız ki bu nesnemizi initialize edicek:</strong></p><p>Mesela su şişemizin; markası A, kapağı kapalı, Şekli silindir, doluluğu 100 olsun:</p><pre>public class SuSisesi {<br>    String marka;<br>    boolean kapak;<br>    String sekil;<br>    double doluluk;<br><br>    // Nesnemizi initialize eden (başlatan) kurucu metot<br>    public SuSisesi() {<br>        this.marka = &quot;A&quot;;<br>        this.kapak = false;       // false: kapalı durumu<br>        this.sekil = &quot;silindir&quot;;<br>        this.doluluk = 100.0;     // Tam Dolu<br>    }<br>  <br>    // Nesnemizin eylemleri (Metotlar)<br>    void kapagiAc() {<br>        // ...<br>    }<br><br>    void suyuAzalt() {<br>        // ...<br>    }<br><br>    void suyuArttir() {<br>        // ...<br>    }<br>}</pre><p>Sonunda nesnemiz ile ilgili Soyutlama işlemi yaptık ve Su Şişemizi Koda aktardık.</p><blockquote>NOT: Aslında bu nesne özelinde vermemiz gereken son ‘tasarım’ kararları <strong>Interface (Arayüz)</strong> ve <strong>Abstract Class (Soyut Sınıf)</strong> yapılarıdır. Ancak yolculuğumuzu çok dallandırmamak adına, şimdilik Abstraction (Soyutlama) sürecini bu temel seviyede tamamladığımızı varsayıyoruz. Artık elimizdeki bu ham tasarımı korumaya, geliştirmeye ve canlandırmaya hazırız.</blockquote><p>Abstraction’ı bitirdik ancak işimiz bitmedi çünkü koda aktardığımız bu nesne için artık bulunduğu bu yazılım bölgesinde gerekli ayarlamalar yapmalı veya kendisiyle ilgili yönetim kararları almalıyız.</p><p><strong>Bundan sonraki kavramlarımız:</strong></p><ol><li><a href="https://medium.com/@furkn.ttr/kaps%C3%BClleme-encapsulation-9ecbca9d2d30">KAPSÜLLEME (ENCAPSULATION)</a></li><li>KALITIM/MİRAS (INHERITANCE)</li><li>ÇOK BİÇİMLİLİK (POLYMORPHISM)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4WJdvR9dZq-TFQrQsnBRzw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dadf14af31bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>