<?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 Aphar Magaramova on Medium]]></title>
        <description><![CDATA[Stories by Aphar Magaramova on Medium]]></description>
        <link>https://medium.com/@aphar?source=rss-c49a575daee8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*LEXrNN59alv5ZWB2Iy3zfA.jpeg</url>
            <title>Stories by Aphar Magaramova on Medium</title>
            <link>https://medium.com/@aphar?source=rss-c49a575daee8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:07:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aphar/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[First Level Cache — Insert və Cache]]></title>
            <link>https://medium.com/@aphar/first-level-cache-insert-v%C9%99-cache-eca2c5d0a5ed?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/eca2c5d0a5ed</guid>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[first-level-cache]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Mon, 23 Jun 2025 12:24:50 GMT</pubDate>
            <atom:updated>2025-06-25T23:26:20.730Z</atom:updated>
            <content:encoded><![CDATA[<h3>First Level Cache — Insert və Cache</h3><p>Bugünkü məqalədə <strong>First Level Cache</strong> və <strong>JPA-nın insert metodu</strong> arasındakı əlaqədən danışacağıq.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/0*wbKe2VVCnv5XQG2w.png" /></figure><p><strong>First Level Cache</strong>, digər adı ilə <strong>Hibernate Sessiyası</strong> və ya <strong>Persistence Context</strong>, application və database arasındakı keçid qatıdır. Göndərdiyimiz query nəticələrinin persistence contextdə saxlanılması application-un performansını artırır və onu daha sürətli edir.</p><p>Insert əməliyyatı zamanı isə First Level Cache ilə bağlı müəyyən problemlərlə qarşılaşa bilərik. Belə hallardan biri də odur ki, persist() metodu ilə EntityManager-ə əlavə edilən obyekt dərhal database-ə yazılmır. Bu obyekt əvvəlcə Persistence Context-də (First Level Cache) saxlanılır və yalnız <strong>flush() </strong>əməliyyatı baş verdikdə, növbəti <strong>query icra olunduqda</strong> və ya <strong>tranzaksiya commit edildikdə</strong> database-ə INSERT əmri ilə yazılır.</p><p>Bu iki halda baş verə bilər:</p><ol><li>İstifadə etdiyimiz id generation strategy SEQUENCE olduqda</li><li>id manual olaraq mənimsədildikdə</li></ol><p>İndi isə hər bir case-ə ayrıca baxaq və bunun səbəbini aydınlaşdıraq.</p><p>Bildiyiniz kimi SEQUENCE və ya TABLE generation strategy əlavə bir sequence table yaradılmasını və hər yeni data insert etdikdə bu sequence table-dakı datanın oxunmasını və update olunmasını tələb edir.</p><p>Gəlin buna nümunə ilə baxaq. Güman edək ki, bizim Person deyə belə bir classımız var.</p><pre>@Entity<br>public class Person {<br><br>    @Id<br>    @GeneratedValue(strategy = GenerationType.SEQUENCE)<br>    private Long id;<br><br>    private String firstName;<br><br>    private String lastName;<br><br>    // getter setter and constructors<br>}</pre><p>Nəticənin yoxlamaq üçün belə bir kod run edəcəyik:</p><pre>public class FirstLevelCacheMain {<br>    static EntityManagerFactory emf = Persistence.createEntityManagerFactory(&quot;com.aphar.hibernate_course&quot;);<br><br>     private void persist() {<br>          EntityManager em = emf.createEntityManager();<br>          em.getTransaction().begin();<br>          Person p=new Person(&quot;Aphar&quot;, &quot;Magaramova&quot;);<br>          System.out.println(&quot;1......&quot;);<br>          em.persist(p);<br>          System.out.println(&quot;2......&quot;);<br>          em.getTransaction().commit();<br>          System.out.println(&quot;3......&quot;);<br>          em.close();<br>      }<br>      public static void main(String[] args) {<br>          FirstLevelCacheMain main = new FirstLevelCacheMain();<br>          main.persist();<br>          emf.close();<br>      }<br>}</pre><p>Kodun nəticəsinə baxaq:</p><pre>1......<br>Hibernate: <br>    select<br>        next_val as id_val <br>    from<br>        hibernate_sequence for update<br>            <br>Hibernate: <br>    update<br>        hibernate_sequence <br>    set<br>        next_val= ? <br>    where<br>        next_val=?<br>2......<br>Hibernate: <br>    insert <br>    into<br>        Person<br>        (firstName, lastName, id) <br>    values<br>        (?, ?, ?)<br>3......</pre><p>Gördüyünüz kimi, GenerationType.SEQUENCE strategiyası istifadə olunduğu üçün hibernate_sequence adlı əlavə cədvəl yaradılır. Bu cədvəldən növbəti id alınır və Person obyektinə təyin olunur. Daha sonra indeks artırılaraq cədvəl yenilənir. Amma insert əməliyyatı yalnız commit əməliyyatından sonra icra olunur. Yəni obyekt həmin vaxta qədər first level cachedə saxlanılır.</p><p>Eyni hall manual generated id istifadə edildikdə də baş verir:</p><p>Person classını manual id generation istifadə edəcək şəkildə dəyişirik:</p><pre>@Entity<br>public class Person {<br>    <br>    @Id<br>    private Long id;<br>    <br>    ......<br>}</pre><p>persist() metodumuzu da update edirik:</p><pre>private void persist() {<br>        EntityManager em = emf.createEntityManager();<br>        em.getTransaction().begin();<br>        <br>        Person p=new Person(1L, &quot;Aphar&quot;, &quot;Magaramova&quot;);<br>        System.out.println(&quot;1......&quot;);<br>        em.persist(p);<br>        System.out.println(&quot;2......&quot;);<br>        em.getTransaction().commit();<br>        System.out.println(&quot;3......&quot;);<br>        <br>        em.close();<br>}</pre><p>Kodumuzun nəticəsinə baxaq:</p><pre>1......<br>2......<br>Hibernate: <br>    insert <br>    into<br>        Person<br>        (firstName, lastName, id) <br>    values<br>        (?, ?, ?)<br>3......</pre><p>Gördüyünz kimi manual id generation istifadə edildikdə də insert edilən data transaksiya commit edilənədək first level cahch-də saxlanılır. Commitdən sonra isə database-ə save edilir.</p><p>Insert zamani cache-də saxlanılan data retrival zamanı da cache-dən alınır. Yəni heç bir database hit baş vermir, bu səbəbdən də query icra olunmur. Bunu aşağıdakı nümunədən də görə bilərik.</p><pre>private void persist() {<br>        EntityManager em = emf.createEntityManager();<br>        em.getTransaction().begin();<br><br>        Person p = new Person(1L, &quot;Aphar&quot;, &quot;Magaramova&quot;);<br>        System.out.println(&quot;1......&quot;);<br>        em.persist(p);<br>        System.out.println(&quot;2......&quot;);<br><br>        Person person = em.find(Person.class, 1L);<br>        System.out.println(&quot;3......&quot; + person.getFirstName() + &quot; &quot; + person.getLastName());<br><br>        em.getTransaction().commit();<br>        System.out.println(&quot;4......&quot;);<br>        em.close();<br>    }</pre><p>Kodun nəticəsindən də gördüyünüz kimi heç bir select query run olunmadı. Çünki persist() metodu çağırılan zaman data persistence context-də saxlanıldı. find metodu isə eyni datanı persistence context-də tapdığı üçün database-ə müraciət etmədi.</p><p>Yalnız tranzaksiya commit edildikdən sonra insert query icra edildi.</p><pre>1......<br>2......<br>3......Aphar Magaramova<br>Hibernate: <br>    insert <br>    into<br>        Person<br>        (firstName, lastName, id) <br>    values<br>        (?, ?, ?)<br>4......</pre><p>Generation strategy IDENTITY olduqda isə bu tip first level cache-də gözləmə halı ilə qarşılaşmırıq. persist() metodu çağırılan anda insert əməliyyatı birbaşa icra olunur.</p><p>Person class-ın id generation strategy IDENTITY dəyişdikdən sonra nümunəmizə baxaq:</p><pre>@Entity<br>public class Person {<br>    <br>    @Id<br>    @GeneratedValue(strategy = GenerationType.IDENTITY)<br>    private Long id;<br>    <br>    ....<br>}</pre><p>Yuxarıdakı main proqramı run etdikdən sonra loglara baxsaq görərik ki, insert query birinci logdan həmən sonra run olub bu da onu göstərir ki, id generation strategy IDENTITY olduqda insert olunan data cache-də qalmır.</p><pre>1......<br>Hibernate: <br>    insert <br>    into<br>        Person<br>        (firstName, lastName) <br>    values<br>        (?, ?)<br>2......<br>3......</pre><p>Mənbə: <a href="https://www.youtube.com/watch?v=bro30ke0kq4">First-Level Cache Issues: Retrievals use cache</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eca2c5d0a5ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JPA və Hibernate-də entity statusları]]></title>
            <link>https://medium.com/@aphar/jpa-v%C9%99-hibernate-d%C9%99-entity-statuslar%C4%B1-19a7411b4a34?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/19a7411b4a34</guid>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[entitymanager]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Thu, 19 Jun 2025 21:40:43 GMT</pubDate>
            <atom:updated>2025-06-19T21:40:43.970Z</atom:updated>
            <content:encoded><![CDATA[<p>Hibernate-də yaratdılan entitilərin 4 state olur:<br><strong>1. New (Transient)</strong></p><p>Yeni yaradılan obyektlər Hibernate Session (Persistence Context) və verilənlər bazası ilə heç bir əlaqəyə malik olmurlar. Bu obyektlər <strong>Transient</strong> vəziyyətində olurlar.</p><p><strong>2. Persistent (Managed)</strong></p><p>.persist() və ya .merge() metodları vasitəsilə database-ə yazılan entitilər <strong>Transient</strong> vəziyyətindən <strong>Persistent</strong> vəziyyətinə keçirlər. Bu entitilər artıq verilənlər bazasında mövcuddur və açıq Hibernate Session və ya Persistence Context tərəfindən idarə olunurlar.</p><p>Persistent vəziyyətində olan entitiyə session açıq ikən edilən bütün dəyişikliklər, session bağlandıqdan sonra database-ə commit olunaraq yadda saxlanılır.</p><p><strong>3. Detached</strong></p><p>Session bağlandıqdan sonra əvvəlcə <strong>Persistent</strong> vəziyyətində olan entitilər artıq Persistent Context tərəfindən idarə olunmur və <strong>Detached</strong> vəziyyətinə keçir.</p><p><strong>Detached</strong> vəziyyətində olan entitiyə edilən dəyişikliklər databasada əks olunmur.</p><p>Entitini yenidən <strong>Persistent</strong> vəziyyətinə gətirmək üçün .merge() metodundan istifadə edə bilərik.</p><p>.merge() metodu vasitəsilə detached entitinin state-i, session-da eyni id-yə malik entitiyə <strong>copy</strong> olunur. Əgər session-da bu id-yə uyğun entiti yoxdursa, Hibernate yeni bir entiti yaradaraq detached entitinin state-i ona kopyalayır.</p><p><strong>4. Removed</strong></p><p><strong>Persistent</strong> vəziyyətində olan entitilər .remove() metodu ilə silindikdə <strong>Removed</strong> vəziyyətinə keçirlər.</p><p>Session bağlandıqda, bu statusdakı entitilər verilənlər bazasından silinir.</p><p>JPA-da entitilərin statuslarını dəyişmək üçün EntityManager-in aşağıdakı metodlarından istifadə edə bilərik:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/0*wCIsxcGMo937i0LQ.png" /></figure><p>Hibernate Session EntityManager-in child class olduğu üçün əlavə metodlara sahibdir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*-rIG1H3Ei0qIOGm2.png" /></figure><p>Daha ətraflı oxumaq üçün: <a href="https://vladmihalcea.com/a-beginners-guide-to-jpa-hibernate-entity-state-transitions/">A Beginner’s Guide to JPA/Hibernate Entity State Transitions — Vlad Mihalcea</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=19a7411b4a34" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JPA find və getReference EntityManager metodları]]></title>
            <link>https://medium.com/@aphar/jpa-find-v%C9%99-getreference-entitymanager-metodlar%C4%B1-e8a356a42d06?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8a356a42d06</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Wed, 18 Jun 2025 20:14:41 GMT</pubDate>
            <atom:updated>2025-06-21T17:06:03.929Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu məqalədə Persistance API-ın find() və getReference() metodlarının fərqinə baxacağıq.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yqCCsXZQSvo3WT1Sqn8cRQ.png" /></figure><p>Hər iki metod datanın fetch olunması üçün istifadə edilir. Ancaq bu metodların davranışları fərqlidir və bu fərq <strong>performansa</strong> ciddi təsir göstərə bilər, xüsusilə də böyük həcmli enterprise tətbiqlərində.</p><h3>1. find()</h3><p>Belə ki, find() metodu çağırılan zaman əgər həmin entity <strong>Persistence Context</strong>-də yoxdursa(ilk sorğuda), <strong>verilənlər bazasına</strong> SQL sorğusu göndərilir. SQL sorğusundan aldığımız nəticə first-level cache (persistence context) yazılır və find() metodunun nəticəsi kimi geri qaytarılır.</p><p>Növbəti dəfə isə eyni sorğu göndərildikdə, artıq database deyil də persistence contextə müraciət edərək datanı ordan çəkir.</p><p>İlk müraciət:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jpk1lvfVRR1cWYJrIRr0PQ.png" /></figure><p>Növbəti müraciətlərdə artıq data persistence context-də olduğu üçün DB müraciət olmur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*giDlx6Zvnw2KHrakXPJzVQ.png" /></figure><h3><strong>2. getReference()</strong></h3><p>getReference() methodu ise find() metodundan fərqli davranır.</p><p>getReference metodu çağırıldıqda, hibernate həmin entity-nin Id özündə saxlayan proxy qaytarır. Proxy sadəcə obyektin id saxlayır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NpP0NNQSm2uOiYFu7p8-hQ.png" /></figure><p>Proxy-ə müraciət etdikdə isə (məsələn getName()) artıq database sorğu göndərilir və gələn datanı persistence contextə yazır.</p><p>Yəni data ilə id xaric bir interaksiya olmadığı müddətdə sql query run etmir.</p><p>Aşağıda da gördüyünüz kimi title access etdiyim üçün artıq database müraciət edir və sql query run olunur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rYB5hDnWbzJodjJuYwaJ5g.png" /></figure><p>Belə bir nəticəyə gəlirik ki, əgər bizə obyketin bütün datası lazımdırsa, bu halda find() metodu, sadəcə id-i lazımdırsa, getReference() metodu istifadə etməliyik.</p><blockquote><strong>getReference() </strong>metodu JPA EntityManager interfeysinin .remove() metodu ilə birlikdə istifadə edildikdə, database-ə select query göndərilir ki, proxy-də id saxlanılan obyektin həqiqətən də database-də mövcud olub olmadığı dəqiqləşdirilsin.</blockquote><p>Data ətraflı oxumaq üçün: <a href="https://vladmihalcea.com/entitymanager-find-getreference-jpa/">https://vladmihalcea.com/entitymanager-find-getreference-jpa/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8a356a42d06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JDBC vs Spring JDBC vs JPA vs Spring Data JPA vs Hibernate]]></title>
            <link>https://medium.com/@aphar/jdbc-vs-spring-jdbc-vs-jpa-vs-spring-data-jpa-vs-hibernate-1a9d866f01c5?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a9d866f01c5</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[jdbc]]></category>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[hibernate]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Wed, 30 Apr 2025 05:02:37 GMT</pubDate>
            <atom:updated>2025-04-30T05:02:37.548Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu günkü mövzumuz yeni başalayan çox şəxsdə çaşqınlığa səbəb olan mövzudur. Bu məqalədə biz Spring proqramının database ilə necə “danışdığını” müzakirə edəcəyik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/0*n24wqllBp-5p4NvL" /></figure><p>Bu movzunu hər kəs üçün tam aydın etmək məqsədilə biz birinci JDBC-dən başalayacağıq. ardından digər anlayışları kod nümunələri ilə birlikdə izah edəcəyik.</p><p>1. JDBC (Java Database Connectivity) and Spring JDBC</p><p>adından da göründüyü kimi JDBC databse connection yaratmaq və sql query-ləri icra etmək üçün istifadə edilən bir Java API-dır. jdbc çox kod yazmağı tələb edir, mələsən database ilə connection qurulmasi üçün yazılan kod, sql query-lər yamaq, onlari execute etmək, exceptionlari handle etmək, prosesin sonunda connection bağlamaq və s. Belə kiçik bir kod nümunəsi daha aydın olacaqdır.</p><pre>import java.sql.Connection;<br>import java.sql.PreparedStatement;<br>import java.sql.ResultSet;<br>import java.sql.SQLException;<br>import java.sql.Statement;<br><br>import javax.sql.DataSource;<br><br>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.stereotype.Component;<br><br>import com.aphar.springboot.learn_jpa_and_hibernate.course.Course;<br><br>@Component<br>public class CourseJDBC {<br> <br> @Autowired<br> DataSource ds;<br> <br> public int getCount() throws SQLException {<br><br>        final Connection connection = ds.getConnection();<br>        try {<br>            final Statement statement = connection.createStatement();<br>            try {<br>                final ResultSet resultSet = statement.executeQuery(&quot;SELECT COUNT(*) FROM Course&quot;);<br>                try {<br>                    resultSet.next();<br>                    return resultSet.getInt(1);<br>                } finally {<br>                    resultSet.close();<br>                }<br>            } finally {<br>                statement.close();<br>            }<br>        } catch (SQLException e) {<br>            System.err.println(&quot;SQL error: &quot; + e.getMessage());<br>        } finally {<br>            connection.close();<br>        }<br>        <br>        return -1;<br><br>    }<br> <br> public void insert(Course course) {<br>     String sql = &quot;INSERT INTO Course (id, name, author) VALUES (?, ?, ?)&quot;;<br><br>     try (<br>         Connection connection = ds.getConnection();<br>         PreparedStatement preparedStatement = connection.prepareStatement(sql);<br>     ) {<br>         preparedStatement.setLong(1, course.getId());<br>         preparedStatement.setString(2, course.getName());<br>         preparedStatement.setString(3, course.getAuthor());<br><br>         int rowsAffected = preparedStatement.executeUpdate();<br>         System.out.println(&quot;Inserted rows: &quot; + rowsAffected);<br><br>     } catch (SQLException e) {<br>         System.err.println(&quot;Insert error: &quot; + e.getMessage());<br>     }<br> }<br>}</pre><p>gorduyunuz kimi importlar hamisi Java API.</p><p>commandRunner vasitesile run edib neticeye baxa bilerik.</p><pre>@Component<br>public class CourseCommandLineRunner implements CommandLineRunner{<br> <br> @Autowired<br> CourseJDBC repository;<br> <br> @Override<br> public void run(String… args) throws Exception {<br><br>   repository.insert(new Course(1, &quot;Spring&quot;, &quot;Aphar&quot;));<br>   repository.insert(new Course(2, &quot;Java&quot;, &quot;Aphar&quot;));<br>   repository.insert(new Course(3, &quot;Hibernate&quot;, &quot;Aphar&quot;));<br>   repository.insert(new Course(4, &quot;JPA&quot;, &quot;Aphar&quot;));<br>   <br>   System.out.println(repository.getCount()); <br> }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*GvGw5c1uPco36TjB6STrIw.png" /><figcaption>JDBC query result</figcaption></figure><p>nəticə isə budur. gördüyünüz kimi jdbc istifadə etdiyimiz zaman yazdığımız kod da olduqca çoxdur.</p><p>2. Spring JDBC isə Spring framework vasitəsilə JDBC-nin sadələşdirilmiş, daha yüngül formasıdır. Bu halda bizim databse ilə connection üçün xüsusi bir kod yazmağımıza ehtiyac yoxdur. Databse ilə connection, exceptionlar spring tərəfindən manage edilir. Bütün bu prosesi manage edən isə ```org.springframework.jdbc.core``` package-den olan JdbcTemplate class-dır.</p><p>indi isə insert, delete, findById üçün Spring JDBC-de istifadə etməli olduğumuz koda baxaq. Gördüyünüz kimi kod Java API istifadəsinə nisbətən çox qısadır.</p><pre>import org.springframework.beans.factory.annotation.Autowired;<br>import org.springframework.jdbc.core.BeanPropertyRowMapper;<br>import org.springframework.jdbc.core.JdbcTemplate;<br>import org.springframework.stereotype.Repository;<br><br>import com.aphar.springboot.learn_jpa_and_hibernate.course.Course;<br><br><br>@Repository<br>public class CourseJdbcRepository {<br> <br> @Autowired<br> private JdbcTemplate springJdbcTemplate;<br> <br> <br> public void save(Course course) {<br>  springJdbcTemplate.update(<br>     &quot;&quot;&quot;<br>      insert into course (id, name, author)<br>      values(?, ?, ?);<br>     &quot;&quot;&quot;, <br>     course.getId(), <br>     course.getName(), <br>     course.getAuthor()<br>    );<br> }<br> <br> public void deleteById(long id) {<br>  springJdbcTemplate.update(<br>     &quot;delete from course where id=?&quot;, <br>     id<br>    );<br> }<br> <br> public Course findById(long id) {<br>  return springJdbcTemplate.queryForObject(<br>     &quot;select * from course where id=?&quot;, <br>     new BeanPropertyRowMapper&lt;&gt;(Course.class), <br>     id<br>    );<br> }<br> <br>}</pre><p>importlara baxdıqda isə görə bilirik ki, org.springframework.jdbc.core spring framework jdbc istifadə edilib. Burada önəmli məsələlərdən biri də obyektlərin map olunmasıdır. Spring JDBC, object mapping üçün BeanPropertyRowMapper adlı utility class-dan istifadə edir. Bu class vasitəsilə SQL query-dən (ResultSet) gələn hər bir sıra bizim Course obyektimizə map olunur. Bu class Java Reflection mexanizmini istifadə edərək, sütun adlarını Course class-ındakı property-lərlə uyğunlaşdırır və onları avtomatik olaraq map edir.</p><p>3. <strong>JPA (Java Persistence API)</strong> bir framework deyil də, sadəcə bir <strong>standart </strong>və<strong> API</strong>-dır.</p><p>JPA obyeklətin database cədvəllərinə map olunması(<strong>ORM</strong>) üçün istifadə edilir.</p><p>@Entity @Column annotasiyaları vasitəsilə biz class-larımızı entity kimi təyin edirik və propertiləri təyin etdiyimiz ad ilə cədvəl sütünlarına map edirik.</p><p>Database-də müəyyən əməliyyatları həyata keçirmək üçün isə EntityManager API-dan istifadə edirik. EntityManager isə <strong>persistence context</strong> ilə işləyən bir interface-dir və obyektlərin idarə olunmasını həyata keçirir.</p><p>Gəlin bunu kod nümunəsi ilə də aydınlaşdıraq.</p><p>Bu bizim @Entity annotasiyası vasitəsilə Object Relational Mapping həyata keçirdiyimiz entity clasımızdır.</p><pre>import jakarta.persistence.Entity;<br>import jakarta.persistence.Id;<br><br>@Entity<br>public class Course {<br> <br>   @Id<br>   private long id;<br>   <br>   @Column(name=&quot;name&quot;)<br>   private String name;<br>   <br>   private String author;<br><br>}</pre><blockquote><strong><em>Qeyd:</em></strong><em> @Entity, @Id, @Column annotasiyalarını import edərkən, adətən iki fərqli seçimlə qarşılaşa bilərsiniz: biri </em><em>jakarta.persistence paketindən, digəri isə </em><em>org.hibernate.annotations paketindən gəlir.</em></blockquote><blockquote><em>Biz jakarta.persistence-den gələn importu qəbul etməliyik. Çünki Hibernate bir framework-dür, JPA-in xüsusi implementasiyasıdır və ona birbaşa bağlı olmaq </em><strong><em>JPA-nın standartlıq üstünlüyünü</em></strong><em> itirə bilər.</em></blockquote><blockquote><em>Ona görə də, mümkün qədər jakarta.persistence annotasiyalarından istifadə edilməlidir — bu, sizi Hibernate-ə deyil, </em><strong><em>JPA spesifikasiyasına bağlı saxlayır</em></strong><em>. Bu da kodu çox dəyişmədən digər </em><strong><em>ORM frameworklərə </em></strong><em>(</em>EclipseLink, and OpenJPA)<em> keçidi asanlaşdırır.</em></blockquote><pre>import jakarta.persistence.EntityManager;<br>import jakarta.persistence.PersistenceContext;<br>import jakarta.transaction.Transactional;<br><br>@Repository<br>@Transactional<br>public class CourseJpaRepository {<br> <br>   @PersistenceContext<br>   EntityManager entitymanager;<br>   <br>   <br>   public void save(Course course) {<br>    entitymanager.merge(course);<br>   }<br>   <br>   public Course findById(long id) {<br>    return entitymanager.find(Course.class, id);<br>   }<br>   <br>   public void deleteById(long id) {<br>    Course course=entitymanager.find(Course.class, 1);<br>    entitymanager.remove(course);<br>   }<br>  <br>}</pre><p>EntityManager inject etmək üçün @Autowired da istifadə edilə bilərdi, lakin @PersistenceContext daha spesifik və uyğun annotasiyadır. Onun əsas məqsədi <strong>container-managed EntityManager</strong> və onunla əlaqəli <strong>persistence context</strong>-i inject etməkdir.</p><p>Class açıqlamasından da bunu daha aydın görə bilərik:</p><blockquote>PersistenceContext — Expresses a dependency on a container-managed EntityManager and its associated persistence context.</blockquote><p>JPA implementasiyası istifadə etdiyimiz zaman @Transactional annotasiyası vacibdir. Çünki bir çox JPA əməliyyatları (persist, merge, remove) <strong>aktiv tranzaksiya</strong> tələb edir.</p><p>İstifadə etmədikdə isə belə bir error alırıq: javax.persistence.TransactionRequiredException: No EntityManager with actual transaction available</p><p>Bu o deməkdir ki, siz database-də dəyişiklik etməyə çalışırsınız amma heç bir <strong>açıq tranzaksiya yoxdur.</strong></p><p>Yəni JPA nə vaxt dəyişiklikləri “commit” etməli olduğunu anlamır.</p><p><strong>JPA spesifikasiyasına</strong> görə, bütün dəyişikliklər bir transaction daxilində həyata keçirilməlidir. Ona görə də @Transactional annotasiyasını istifadə olunmalıdır.</p><p>CommandLineRunner ile nəticəyə baxaq.</p><pre>@Component<br>public class CourseCommandLineRunner implements CommandLineRunner{<br><br> @Autowired<br> CourseJpaRepository repository;<br> <br> @Override<br> public void run(String... args) throws Exception {<br><br>  repository.save(new Course(1, &quot;Spring&quot;, &quot;Aphar&quot;));<br>  repository.save(new Course(2, &quot;Java&quot;, &quot;Aphar&quot;));<br>  repository.save(new Course(3, &quot;Hibernate&quot;, &quot;Aphar&quot;));<br>  repository.save(new Course(4, &quot;JPA&quot;, &quot;Aphar&quot;));<br>  <br>  <br>  repository.deleteById(1L);<br>  <br>  System.out.println(repository.findById(2L));<br>  System.out.println(repository.findById(3L));<br> }<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YX-6ZA_Xa5VCBRngFo8v1A.png" /><figcaption>JPA query result</figcaption></figure><p>Gördüyünüz kimi JPA implementasiyası kodu çox daha qısaltdı, daha oxunaqlı etdi. Amma arxada yenə eyni əməliyyatlar gedir, yəni run olunan querylər eynidir. Sadəcə JPA implementasiyası vasitəsilə biz artıq queryləri yazmırıq. JPA bizim üçün bu hissəni avtomatlaşdırır.</p><p>4. Spring Data JPA</p><p><strong>Spring Data JPA</strong> — Spring framework-ün JPA ilə işləmək üçün mövcud olan bir API-dır. JPA-ı daha da sadələşdirir, EntityManager olan ehtiyacı aradan qaldırır. Avtomatik olaraq istifadəyə hazır repository interface(<strong>JPA repository</strong> implementasiyası) təqdim edir hansı ki hazır save, delete, findById, findAll methodlarına sahibdir.</p><p>Spring Data JPA vasitəsilə yazılan kod daha da qısalır.</p><pre>public interface CourseSpringDataJpaRepository extends JpaRepository&lt;Course, Long&gt; {<br> <br> List&lt;Course&gt; findByAuthor(String author);<br> <br> List&lt;Course&gt; findByName(String author);<br><br>}</pre><p>Bu nümunədə findByAuthor və findByName metodları <strong>naming convention</strong>-a əsaslanır. Spring Data JPA bu metod adlarına baxaraq avtomatik olaraq uyğun SQL sorğularını generasiya edir.</p><p>Yəni findBy-dan sonra gələn property adı (Author, Name və s.) entity class-ınızda (Course) olan field-ə uyğun olmalıdır və arqument olaraq həmin field-in dəyəri ötürülməlidir.</p><p>5. Hibernate</p><p>Hibernate — <strong>Object-Relational Mapping (ORM)</strong> framework-dür və JPA-nın ən məşhur implementasiyalarından biridir.</p><p>Hibernate yalnız JPA-nı implementasiya etməklə kifayətlənmir, eyni zamanda <strong>özünəməxsus əlavə funksionallıqlara</strong> da malikdir.</p><p>Hibernate-in “framework” adlandırılmasının əsas səbəbi — onun <strong>ayrı şəkildə yüklənə və istifadə edilə bilməsidir</strong>.</p><p>Spring Boot istifadə etdikdə isə Hibernate aşağıdakı dependency vasitəsilə <strong>avtomatik əlavə olunur</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*jEhx4ifkRkmec0SZ5t7WSg.png" /></figure><pre>&lt;dependency&gt;<br>   &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>   &lt;artifactId&gt;spring-boot-starter-data-jpa&lt;/artifactId&gt;<br> &lt;/dependency&gt;</pre><p>spring-boot-starter-data-jpa dependency vasitesile hibernate də atomatik əlave edilir.</p><p>Hibernate istənilən <strong>verilənlər bazası ilə işləyə bilir</strong>, çünki o <strong>HQL (Hibernate Query Language)</strong> adlı özünəməxsus sorğu dilinə malikdir. HQL adi SQL-ə bənzəyir, lakin <strong>obyektlər üzərindən işləyir</strong> və <strong>database-dən asılı deyil</strong>.</p><p>Hibernate eyni zamanda aşağıdakı <strong>əlavə funksionallıqları</strong> dəstəkləyir:</p><ul><li><strong>Lazy Loading</strong> — əlaqəli obyektlərə yalnız ehtiyac olduqda sorğu göndərilir.</li><li><strong>Batch Processing</strong> — çoxlu sayda əməliyyatlar bir arada effektiv şəkildə icra olunur.</li><li><strong>Caching</strong> — performansı artırmaq üçün Hibernate məlumatları <strong>keş yaddaşında saxlayır</strong> (First-level və Second-level Cache).</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a9d866f01c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exception Handling in C#]]></title>
            <link>https://towardsdev.com/handling-exceptions-in-c-6ebc9eee0d74?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ebc9eee0d74</guid>
            <category><![CDATA[exception-handling]]></category>
            <category><![CDATA[finally]]></category>
            <category><![CDATA[try-catch]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[exception]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Sat, 09 Sep 2023 09:11:18 GMT</pubDate>
            <atom:updated>2023-09-14T10:20:29.688Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, we will discuss exceptions, how and where to catch them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*n_ACwPO4MSK2LOuTZx_Ong.png" /></figure><p><strong>An Exception</strong> is an unwanted event that occurs during the execution of the program. It is like trying to get an element of an array on the given index that does not exist, which will throw an <strong>IndexOutOfBoundException</strong>. This is the simplest example.</p><p>Programmer should handle with the exceptions using <em>try, catch, </em>and <em>finally </em>keywords.</p><blockquote>Try — used to define a try block, which surrounds the code that may throw an exception.</blockquote><blockquote>Catch — used to define a catch block, and catchs the exception which thrown by try block.</blockquote><blockquote>Finally — used to define the finally block. This block executes its code whether a try block throws an exception or not.</blockquote><p>A <em>throw </em>keyword is used to throw an exception manually. Let’s look at an example.</p><pre>using System;<br> <br>class ExceptionDemo {<br> <br>    static void Main(string[] args)<br>    {<br>        int[] arr = { 1, 2, 3, 4, 5 };<br><br>        // Try to access invalid index of array<br>        Console.WriteLine(arr[7]); // this line will throw an exception<br>        <br>    }<br>}</pre><p>Try block should surround the code which may throw an exception.</p><pre>using System;<br> <br>class ExceptionDemo {<br> <br>    static void Main(string[] args)<br>    {<br>        int[] arr = { 1, 2, 3, 4, 5 };<br><br>        try {<br> <br>            // Try to access invalid index of array<br>            Console.WriteLine(arr[7]); // this line will throw an exception<br>        }<br>        catch (IndexOutOfRangeException e) {<br><br>            Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>        }        <br>        catch (Exception e) {<br><br>            Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>        }<br>    }<br>}</pre><p>If you expect your code may throw a specific exception, then you should catch that exception first. Like IndexOutOfRangeException in our example.</p><p>Now we know what is an exception and how to handle the exception. But what we should learn is where to handle the exception. As we write complex codes, catching an exception will be more complex. But one thing we should keep in mind that catching exception should happen in the highest level of the code. By this way, you will have a full history from the root call all the way through until the actual exception.</p><pre>using ExceptionApi;<br><br>namespace ConsoleUI;<br><br>public class Program<br>{<br>   static void Main(string[] args)<br>   { <br>      Example example = new Example();<br>    <br>        try<br>        {<br>           // Try to access invalid index of array<br>           int result = example.DatabaseCallMethod(7); <br>           Console.WriteLine($&quot;The value at the given position {result}&quot;);<br>        }<br>        catch (IndexOutOfRangeException e)<br>        {<br>           Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>           Console.WriteLine(e.StackTrace);<br>        }<br>        catch (Exception e)<br>        {<br>           Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>           Console.WriteLine(e.StackTrace);<br>        }<br>   }<br>}<br>namespace ExceptionApi;<br><br>public class Example<br>{<br>   public int DatabaseCallMethod(int index)<br>   {<br>      return DoSomethingMethod(index);<br>   }<br>   <br>   public int DoSomethingMethod(int index)<br>   {<br>      return GetNumber(index);<br>   }<br>  <br>   public int GetNumber(int index)<br>   {<br>      int[] arr = { 1, 2, 3, 4, 5 };<br>    <br>      // Try to access invalid index of array<br>      return arr[index]; // this line will throw an exception<br>   }<br>}</pre><p>In the above we have created two project, one is console (ConsoleUI), and other is class library (ExceptionApi). Added reference to ExceptionApi project in the ConsoleUI project. This will help us to use this project’s class and methods.</p><p>As you can see, the actual line which will throw an exception is return arr[index]; in the GetNumber method. Because we wrote this example, we know that an exception will be thrown in this line. But we cannot interact with users directly at the class library level. That’s why we should pass the exception until the user interface, so we can tell the user what is wrong. We cannot Console.WriteLine(e.Message) at the GetNumber method. Because if we call this class’s method in different type of project, for example, MVC project, we cannot show the problem to the user with console.</p><p>We have DatabaseCallMethod in the ExceptionApi project. If we assume that this method open a connection with database, and we should close connections after it respond.</p><pre>public int DatabaseCallMethod(int index)<br>{<br>    int output=0;<br>    <br>    Console.WriteLine(&quot;Open database connection&quot;);<br><br>    output = DoSomethingMethod(index); // an exception is thrown in here<br><br>    Console.WriteLine(&quot;Close database connection&quot;); // if program will crush, <br>                                            // this line will not be executed<br>    return output;<br>}</pre><p>If our program crushes, the database connection will not be closed. Because the exception is thrown in the output = DoSomethingMethod(index); line, code below it will not be executed. And that will cause an open connection. If many user experience an exception at the same time, that means many users will have an open connection. And this is not good. That is why we should use finally block here. A Finally block will execute, no mater the program will crush or not. That also means you shouldn’t put code which may cause an exception in here.</p><pre>public int DatabaseCallMethod(int index)<br> {<br>    int output = 0;<br>  <br>    Console.WriteLine(&quot;Open database connection&quot;);<br>  <br>    try<br>    {<br>       output = DoSomethingMethod(index); // an exception is thrown in here<br>    }<br>    catch (Exception e)<br>    {<br>       throw;<br>    }<br>    finally<br>    {<br>       Console.WriteLine(&quot;Close database connection&quot;);<br>    }<br>  <br>    return output;<br> }</pre><p>Cause DatabaseCallMethod is not on the UI layer, we cannot catch exceptions in here and tell the user about the problem. So we should pass the exception to the next chain, which is the Main method in this example.</p><p>Now let’s talk about throw part. You may think that you can throw the exception that passed as parameter.</p><pre>catch (Exception ex)<br>{<br>   throw ex;<br>}</pre><p>But this is the wrong idea. Because it will ignore the inner stack trace of the Exception. And only pass this line output = DoSomething(index); as Stack Trace. And this will give the programmer the wrong information. So we shouldn’t use that.</p><p>But if you want to pass a different type of exception, then you face this stack trace issue again.</p><pre>catch (Exception ex)<br>{<br>   throw new ArgumentException(&quot;Argument Exception&quot;, ex);<br>}</pre><p>Unless you change the Main method’s catch block. As you passed inner exception with argument exception, you will be able to get exception’s inner exception.</p><pre>using ExceptionApi;<br><br>namespace ConsoleUI;<br><br>public class Program<br>{<br>   static void Main(string[] args)<br>   {<br>      Example example = new Example();<br>    <br>      try<br>      {<br>         // Try to access invalid index of array<br>         int result = example.DatabaseCallMethod(7); // this line will throw an exception<br>      <br>         Console.WriteLine($&quot;The value at the given position {result}&quot;);<br>      }<br>      catch (ArgumentException e)<br>      {<br>         Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>         Console.WriteLine(e.StackTrace);<br>      <br>         var inner = e.InnerException;<br>      <br>         while (inner != null)<br>         {<br>            Console.WriteLine(inner.StackTrace);<br>            inner = inner.InnerException;<br>         }<br>      }<br>      catch (Exception e)<br>      {<br>         Console.WriteLine(&quot;An Exception has occurred : {0}&quot;, e.Message);<br>         Console.WriteLine(e.StackTrace);<br>      <br>         var inner = e.InnerException;<br>      <br>         while (inner != null)<br>         {<br>            Console.WriteLine(inner.StackTrace);<br>            inner = inner.InnerException;<br>         }<br>      }<br>   }<br>}</pre><p><strong>Reference</strong>:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FLSkbnpjCEkk%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DLSkbnpjCEkk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FLSkbnpjCEkk%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/b259b60d64863f3e136a9eaf2516e8cc/href">https://medium.com/media/b259b60d64863f3e136a9eaf2516e8cc/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ebc9eee0d74" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/handling-exceptions-in-c-6ebc9eee0d74">Exception Handling in C#</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Constructor nədir? this keyword, getter və setter metodları]]></title>
            <link>https://medium.com/@aphar/constructor-n%C9%99dir-this-keyword-getter-v%C9%99-setter-metodlar%C4%B1-c5c0f2c81760?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5c0f2c81760</guid>
            <category><![CDATA[oop]]></category>
            <category><![CDATA[constructor]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[konstruktor]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Mon, 05 Dec 2022 08:55:45 GMT</pubDate>
            <atom:updated>2022-12-05T08:55:45.882Z</atom:updated>
            <content:encoded><![CDATA[<p>Konstruktor xüsusi bir metod olub class-ın instance-larının yaradılması üçün istifadə edilir. Konstruktoru çağırarkən new keyword-ündən istifadə edilir. Bir class-ın birdən çox konstruktoru ola bilər, əgər konstruktor yaradılmayıbsa, onda class öz default konstruktordan, parametrsiz konstruktordan istifadə edəcək.</p><blockquote>Bu xüsusi metodun konstruktor adlandırılmasının səbəbi onun class-ın instance-ı yaradılarkən obyektə dəyərləri mənimsətməsidir. Yəni biz new keyword-ündən istifadə edib obyekt yaradırıq, ancaq istifadə etdiyimiz konstruktordan asılı olaraq obyektin field-lərinə müəyyən dəyərlər veriləcək.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*lib1oKwWjPIgs_uIVKzE_Q.png" /></figure><h3>Konstruktor vs Metod</h3><p>Yuxarıda qeyd etdik ki, konstruktor xüsusi bir metoddur. Gəlin bunun səbəbini aydınlaşdıraq. Bunun iki səbəbi var:</p><ol><li>Konstruktorun adı class-ın adı ilə eyni olmalıdır</li><li>Konstruktorun metoddan fərqli olaraq heç bir return tipi olmur, qeyd edilmir.</li></ol><p>Konstruktor sadəcə obyekt return edir və bu proses java runtime tərəfindən dolayı olaraq həyata keçirilir. Yəni java runtime zamanı özü obyekt type döndərməsini həyata keçirir, bizim bunun üçün kod yazıb return type declare (müəyyən etmək) etməyimizə ehtiyac qalmır. Əgər biz bunu özümüz etsək, yəni konstruktora return type versək, onda bu konstruktor yox, class üçün adi bir metod olacaq. Yəni bu java runtime-ın metod və konstruktoru fərqləndirməsi üçündür.</p><p>Gəlin nümunəyə baxaq:</p><pre>public class Employee {<br><br>  public Employee() {<br>    System.out.println(&quot;Employee Constructor&quot;);<br>  }<br><br><br>  public Employee Employee() {<br>    System.out.println(&quot;Employee Method&quot;);<br>    return new Employee();<br>  }<br><br>}</pre><p>Burda, birinci gördüyünüz kimi konstruktordur, çünki heç bir return type yoxdur, ikinci isə normal metoddur hansı ki, biz birinci new Employee() yazıb birinci konstruktoru çağırırıq və Employee class-ın instace-i alırıq, daha sonra return edirik.</p><blockquote>Class adı ilə eyni adda metod yaratmaq qarışıqlıq yarada biləcəyi üçün bu şəkildə istifadə etmək tövsiyə edilmir.</blockquote><h3>Konstruktorun tipləri</h3><p>Əvvəlcə də qeyd etdiyim kimi java runtime zamanı yaranan default konstruktoru nəzərə almasaq, iki tip konstruktor mövcuddur:</p><ol><li>Parametrsiz konstruktor</li><li>Parametrli konstruktor</li></ol><h4>Parametrsiz konstruktor</h4><p>Adından da göründüyü kimi heç bir arqumenti olmayan konstruktor parametrsiz konstruktordur. Bu tip konstruktorlar pre-initialization (obyekti yaradarkənki ilk mərhələ) zamanı mənbələrin, internet əlaqələrinin, girişlərin yoxlanılması və digər məqsədlər üçün istafdə edilir.</p><pre>public class Employee {<br>   //no-args constructor<br>   public Employee() {<br>     System.out.println(&quot;No-Args Constructor&quot;);<br>   }<br><br>   public static void main(String[] args) {<br>     Employee e = new Employee(); // console: No-Args Constructor<br>   }<br>}</pre><h4>Parametrli konstruktor</h4><p>Arqumentləri olan konstruktor parametrli konstruktor adlanır:</p><pre>public class Employee {<br><br>  private String name;<br><br>  public Employee(String name) {<br>    System.out.println(&quot;Parameterized Constructor&quot;);<br>    this.name = name;<br>  }<br><br>  public String getName() {<br>    return this.name;<br>  }<br><br>  public static void main(String[] args) {<br>    Employee e = new Employee (&quot;Java&quot;); <br>    System.out.println(e.getName());<br>    <br>    // console: Parameterized Constructor<br>    //          Java<br>  }<br><br>}</pre><p>Yuxarıdakı nümunədə gördüyünüz kimi konstruktorun içərisində, və getName()metodundathis.name = name ifadəsindən istifadə etmişik. Niyə this keyword-unu istifadə etmişik?</p><h4>this keywordu</h4><p>this keyword-u metodun və ya class-ın içindəki mövcud obyektə müraciət etmək üçün istifadə edilir.</p><pre>class Data {<br>    int instVar;<br><br>    Data(int instVar){<br>        this.instVar = instVar;<br>        System.out.println(&quot;this reference = &quot; + this);<br>    }<br><br>    public static void main(String[] args) {<br>        Data obj = new Data(8);<br>        System.out.println(&quot;object reference = &quot; + obj);<br>        <br>        // console: this reference = Main@23fc625e<br>        //          object reference = Main@23fc625e<br>    }<br>}</pre><p>Nümunədə biz obj obyekti yaratdıq və birbaşa onu print edərək reference-i aldıq. Data konstruktorunda da obyekti çap etmək üçün this keyword-ündən istifadə etmişik. Çünki dediyimiz kimi this class-ın və ya metodun içindəki obyektə müraciət edir. Bu sadəcə obj instance üçün keçərli deyil. Biz istənilən qədər instance yarada bilərik və hər dəfə this keywordu o an yaradılan instance-a müraciəet edəcək.</p><p>İndi bildik ki, this obyektə müraciət edir. Deməli this.instVar da obyektin field-ə müraciət edəcək. Yəni this.instVar ilə obj.instVar eyni nəticə geri döndərəcək.</p><p>Ona görə də konstruktorun içərisində class-ın field-lərinə dəyər mənimsətmək üçün this keyword-undən istifadə edilir. Gəlin Employee sinifindəki konstruktor nümunəsi üzərindən izaha davam edək.</p><pre>public class Employee {<br><br>  private String name;<br><br>  public Employee(String name) {<br>    System.out.println(&quot;Parameterized Constructor&quot;);<br>    this.name = name;<br>  }<br><br>}</pre><p>Employee sinifimizdə name field-i var. Və biz ona konstruktor vasitəsilə dəyər veririk. Konstruktora göndərdiyimiz arqument class-ın field-i ilə eyni adlı olduğu üçün biz nama = name; yaza bilmərik. Bu zaman Variable assigned to itself yəni dəyişkən özünə mənimsədilir xəbərdarlığı alacağıq. Bunun qarşısını almaq və sinifin field-ə müraciət etmək üçün biz this keyword-ü ilə class-ın obyektinə və this.name ilə onun name field-ə müraciət edirik.</p><p>Ola bilər ki, biz konstruktora name yerinə başqa adlı variable, məslən n göndərək və konstruktorda name = n; yazaq bu zaman xəbərdarlıq almarıq və kodumuz da düzgün işləyəcək. Sadəcə olaraq konstruktorun içərisinə field-lərlə eyni adlı arqumentlər göndərmək standart kimi qəbul edildiyi üçün bu tip bir yazılışla qarşılaşmağınız nadirdir. Ona görə siz də çalışın this keyword-ündən istifadə edərək standartlara uyğun yazın.</p><h4>getter və setter metodları</h4><p>Getter və setter metodları class-ın dəyişkənlərinə onun xaricindən müraciət etməyə, çağırmağa kömək edir. Əgər gettlər və ya setter metodları olmasa idi, biz class-ın fieldini o class-dan kənarda görə bilməz və ya dəyişikdirə bilməzdik. Bu əməliyyatlarını yerinə yetirmək üçün class-ın field-lərini public etməli olacaqdıq, ancaq bu class-mızın təhlükəsizliyi üçün zərərlidir. Təhlükəsizliyi <strong>encapsulation</strong> mövzusunda geniş izah edəcəyik.</p><p>Gəlin getter və setter olmadan kod yazaq və nəticəyə baxaq.</p><pre>public class Employee {<br><br>  private String name;<br><br>  public Employee(String name) {<br>    System.out.println(&quot;Parameterized Constructor&quot;);<br>    this.name = name;<br>  }<br><br>  public static void main(String[] args) {<br><br>    Employee e = new Employee (&quot;Java&quot;); <br>    System.out.println(e.name); // error çünki name private-dir.<br>   <br>  }<br><br>}</pre><p>Gördüyünüz kimi field-lər private olduğu üçün birbaşa müraciət edə bilmirik. Bu halda getterdən istifadə etmək lazımdır. Getter metodu dəyəri göstərir sadəcə. Setter metodları isə dəyərin dəyişdirilməsinə kömək edir.</p><p>Setter metodunun üstünlüyü ondadır ki, biz setter metodumuzun içərisində şərt qoyaraq dəyəri mənimsədə bilərik. Məsələn:</p><pre>public class Employee {<br><br>  private String name;<br>  private String password;<br><br>  public Employee(String name, String password) {<br>    System.out.println(&quot;Parameterized Constructor&quot;);<br>    this.name = name;<br>    this.password = password;<br>  }<br><br>  public String getName() {<br>    return this.name;<br>  }<br>  <br>  public String getPassword() {<br>    return this.name;<br>  }<br><br>  public void setName(name) {<br>    this.name = name;<br>  }<br>  <br>  public void setPassword(String password) {<br><br>    if(password.lenght &gt;= 8){<br>      this.password = password;<br><br>    }else{<br>      System.out.println(&quot;Password 8 xarakterdən ibarət olmalıdır.&quot;);<br><br>    }<br>  }<br><br>  public static void main(String[] args) {<br>    Employee e = new Employee (&quot;Java&quot;, &quot;Java1234&quot;); <br>    System.out.println(e.getName());<br>    <br>    e.setPassword(&quot;Java&quot;)<br>    <br>    // console: Parameterized Constructor<br>    //          Password 8 xarakterdən ibarət olmalıdır.<br>  }<br><br>}</pre><h3>Konstruktor Overloading, chaning</h3><p>Birdən çox konstruktorumuz olanda konstruktor overloading baş verir, Konstruktor əlaqələndirmə, chaning isə bir kontruktorun içərisində digər konstruktorun çağırılmasıdır.</p><pre>public class Employee {<br><br>    private int id;<br>    private String name;<br><br>    public Employee() {<br>        this(&quot;John Doe&quot;, 999);<br>        System.out.println(&quot;Default Employee Created&quot;);<br>    }<br><br>    public Employee(int i) {<br>        this(&quot;John Doe&quot;, i);<br>        System.out.println(&quot;Employee Created with Default Name&quot;);<br>    }<br><br>    public Employee(String s, int i) {<br>        this.id = i;<br>        this.name = s;<br>        System.out.println(&quot;Employee Created&quot;);<br>    }<br><br>    @Override<br>    public String toString() {<br>        return &quot;ID = &quot; + id + &quot;, Name = &quot; + name;<br>    }<br><br>    public int getId() {<br>        return id;<br>    }<br><br>    public void setId(int id) {<br>        this.id = id;<br>    }<br><br>    public String getName() {<br>        return name;<br>    }<br><br>    public void setName(String name) {<br>        this.name = name;<br>    }<br><br>    public static void main(String[] args) {<br><br>        Employee emp = new Employee();<br>        System.out.println(&quot;\n &quot; + emp);<br>        Employee emp1 = new Employee(10);<br>        System.out.println(&quot;\n &quot; + emp1);<br>        Employee emp2 = new Employee(&quot;Pankaj&quot;, 20);<br>        System.out.println(&quot;\n &quot; + emp2);<br><br>        // console: <br>        //           Employee Created<br>        //           Default Employee Created<br>        //           ID = 999, Name = John Doe<br><br>        //           Employee Created<br>        //           Employee Created with Default Name<br>        //           ID = 10, Name = John Doe<br><br>        //           Employee Created<br>        //           ID = 20, Name = Pankaj<br>    }<br><br>}</pre><p>Yuxarıdakı nümunədə gördüyünüz kimi 3 construktorumuz, yəni konstruktor overloading mövcuddur, eyni zamanda konstruktorları əlaqələndirmişik. Console-dakı nəticəmizdə ona uyğundur.</p><p>Deməli birinci default kontruktoru çağırırıq. this(&quot;John Doe&quot;, 999) dəyərlərini verərək iki parametrli konstruktoru çağırır. Iki parametrli konstruktorda employee-nin dəyərlərini veririr, daha sonra “Employee created” yazısı çap olunur, beləliklər this(&quot;John Doe&quot;, 999) sətrinin emalı bitir. Keçir növbəti sətirə və “Default Employee Created” yazısını consola çıxarır. Son olaraq System.out.println(emp) sətiri toString() metodunu çağırır, və dəyərləri çap edir.</p><p>Digər nümunlər də eyni bu şəkildə davam edir.</p><h3>Private Constructor</h3><p>Bəli, private construktor da mövcuddur. Soruşa bilərsinzi ki, nə funksiyası var? İstifadəsinin əsas səbəbi digər class-ların həmin class-ın obyektini yarada bilməməyini təmin etməkdir. Elə buna görə private konstruktorlar singleton dizayn-da istifadə edilir. Default konstruktor public olduğu üçün(package public) sadəcə boş konstruktor yaradılıb private olaraq müəyyən etmək lazımdır. Konstruktorun gövdəsi boş olur, bir şey yazmağa ehtiyac yoxdur. Çünki bu class-ın onsuz da obyekti yaradılmayacaq.</p><pre>// private constructor<br>private Data() {<br>	  //singleton dizaynın tətbiqi üçün boş gövdə<br>	  // getInstance() metodunun içərisində istifadə etmək üçün bəzi kodlar <br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5c0f2c81760" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Object-Oriented Programming]]></title>
            <link>https://medium.com/@aphar/object-oriented-programming-4c36f8ddb2c1?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c36f8ddb2c1</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[objects]]></category>
            <category><![CDATA[oop-concepts]]></category>
            <category><![CDATA[class]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Tue, 29 Nov 2022 20:30:27 GMT</pubDate>
            <atom:updated>2022-11-29T20:32:54.197Z</atom:updated>
            <content:encoded><![CDATA[<p>Bu məqalədə, obyekt yönümlü proqramlaşdırma haqqında ümumi məlumat verəcəyəm: Class nədir? Object nədir? Və OOP-un prinsipləri.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*NmoV3-Tq8OCgeXEr.png" /></figure><p>OOP proqramlaşdırmaya yeni başlayan hər kəs üçün ilk dəfədən anlaması çətin olan mövzulardan, daha doğrusu, bölmələrdən biridir. Ancaq bunu asanlaşdırmaq üçün edə biləcəyimiz əsas şey proqramlaşdırma ilə real həyatı əlaqələndirmək olar.</p><h3>Obyekt nədir?</h3><p>Class-lara keçmədən öncə obyekt anlayışını başa düşməliyik. Hər hansı xüsusiyyəti və funksionallığı olan şeylər obyektlətdir. Ətrafımızda da çoxlu obyektlər var. Onların bəziləri eyni tipdir, amma fərqli xüsusiyyətləri (state: rəngi, adı, yaşı və s. ) və funksiyaları (behavior: ütüləmək, qaçmaq, yazmaq və s. ) var. Məsələn, hazırda olduğunuz yerdə hansı obyektləri görürsünüz? Mən öz ətrafımda gördüklərimi sayım: noutbuk, söykənəcəksiz stul, söykənəcəkli stul, qələm, qapı və s. Gördüyünüz kimi fərqli obyektlər var, amma eyni obyektlər də var. Məsələn, stullar. Eyni tipdirlər, amma biri söykənəcəksiz, digəri söykənəcəklidir, fərqli xüsusiyyətləri var. Amma tipləri eynidir, ikisi də stuldur, buna görə də biz onları eyni sinifə aid edə bilərik.</p><blockquote>Bu da o deməkdir ki, obyektlət öz class-ın bir nümunəsidir.</blockquote><p>Proqramlaşdırmada da eyni ilə belədir. Bizim siniflərimiz və bu siniflərdən törəyən obyektlərimiz olur. Bu obyektlər fərqli xüsusiyyətlərə və funksionallıqlara sahib ola bilərlər.</p><h3>Class nədir?</h3><p>Class ortaq xassələri olan obyektlər qrupudur.</p><p>Java-da class-lar aşağıdakılardan təşkil oluna bilərlər:</p><ul><li><strong>Fields</strong></li><li><strong>Methods</strong></li><li><strong>Constructors</strong></li><li><strong>Blocks</strong></li><li><strong>Nested class and interface</strong></li></ul><p>Məsələn, “Car” class-ımız var. Onun təkərləri, rəngi, markası, mexanizmi bunlar <strong>field</strong>-lərə aiddir. Field-lər hər zaman private olaraq müəyyən edilir. Çünki class-ın xaricindən onları dəyişdirilə bilməsi class-ın, obyektin təhlükəsizliyi üçün yaxşı deyil. Maşının hərəkətə keçməsi, sürətini dəyişməsi, — bunlar <strong>method</strong>-lara aiddir. Digər xüsusiyyətləri növbəti məqalələrdə aydınlaşdıracağam, hələlik bilməsək, də olar.</p><pre>public class Car extends Vehicle {<br>    private int wheels;<br>    private String color;<br>    private String gears;<br>    private boolean isManual;<br><br>    public void changeGear(int currentGear) {<br>        System.out.println(&quot;Car has changed the gear&quot;);<br>    }<br><br>    public void changeVelocity(int speed, int direction) {<br>        System.out.println(&quot;Car has changed velocity&quot;);<br>    }<br>}</pre><blockquote>Class-lar blueprint-dir. Digər şəkildə desək, yeni yaradılacaq obyekt üçün bir template-dir.</blockquote><h3>New keyword-u</h3><p>Hər hansı class-ın instance-nı yaratmaq üçün istifadə edilir. New keyword-u vasitəsilə yaddaşda yeni yaradılacaq obyekt üçün yer ayrılır.</p><p>Məsələn, yuxarıdakı Car class-ımızın obyektini yaradaq. Obyekti yaradarkən onu initialize etməsək, default value primitiv type dəyərlər üçün 0, reference type dəyərlər üçün null, boolean üçün false, double və float üçün isə 0.0 olacaqdır.</p><pre>public class Main{<br>    public static void main(String[] args) {<br>        Car car = new Car();<br>        System.out.println(car.wheels);   // 0<br>        System.out.println(car.color);    // null<br>        System.out.println(car.isManual); // false<br>    }<br>}</pre><p>Buna görə də obyekt yaradarkən onu initialize etmək lazımdır, yəni dəyərlər mənimsətmək. Bunu 3 üsulla etmək olar:</p><ol><li><strong><em>reference variable-lar ilə: </em></strong>olduqca sadədir, sadəcə nöqtədən istifadə edərək properties müraciət edirik.</li></ol><pre>public class Car extends Vehicle {<br>    private int wheels;<br>    private String color;<br>    private boolean isManual;<br>}<br><br>public class Main{<br>    public static void main(String[] args) {<br><br>        Car car = new Car();<br>        car.wheels = 4;<br>        car.color = &quot;black&quot;;<br>        car.isManual = true;<br>   <br>    }<br>}</pre><p><strong><em>2. metod ilə: </em></strong>Class-ın içərisində metod yaradaraq ötürülən dəyərləri field-lara mənimsədirik:</p><pre>public class Car extends Vehicle {<br>    private int wheels;<br>    private String color;<br>    private boolean isManual;<br><br>    public void insertRecord(int w, String c, boolean m){ <br>         wheels = w;<br>         color = c;<br>         isManual = m;<br>    }<br>}<br><br>public class Main{<br>    public static void main(String[] args) {<br><br>        Car car = new Car();<br>        car.insertRecord(4, &quot;black&quot;, true);<br>        <br>    }<br>}</pre><p><strong><em>3. constructor ilə: </em></strong>bu üsul ikinci üsula bənzəyir. Ancaq fərq ondadır ki, constructor xüsusi bir metod-dur.</p><pre>public class Car extends Vehicle {<br>    private int wheels;<br>    private String color;<br>    private boolean isManual;<br><br>    public Car(int wheels, String color, boolean isManual){<br><br>        this.wheels = wheels;<br>        this.color = color;<br>        this.isManual = isManual;<br>    }<br>}<br><br>public class Main{<br>    public static void main(String[] args) {<br><br>        Car car1 = new Car(4, &quot;black&quot;, true);<br>        Car car2 = new Car(4, &quot;blue&quot;, true);<br>        <br>    }<br>}</pre><p>Gəlin, obyekti yaradarkən onun yaddaşda necə yerləşdiyini izah edək. Əvvəlcədən də qeyd etdiyimiz kimi, new keyword-u yaddaşda obyekt üçün yer ayırır. Obyektin özü heap-də yerləşir. Ona reference edən variable-lar car1 və car2 isə stack-da yerləşir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*RUJdJ3VeH-La86HAKWruVA.png" /></figure><h3>OOP prinsipləri</h3><p>OOP-un əsas 4 prinsipi var:</p><ol><li>Inheritance</li><li>Polymorphism</li><li>Encapsulation</li><li>Abstraction</li></ol><p>Bu prinsiplərə geniş şəkildə daha sonra toxunacağıq.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c36f8ddb2c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Depth First Search (or Traversal)]]></title>
            <link>https://medium.com/@aphar/java-da-depth-first-search-or-traversal-8da1fa20fa60?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8da1fa20fa60</guid>
            <category><![CDATA[dfs]]></category>
            <category><![CDATA[trees]]></category>
            <category><![CDATA[fb]]></category>
            <category><![CDATA[graph]]></category>
            <category><![CDATA[data-structure-algorithm]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Mon, 07 Nov 2022 07:56:06 GMT</pubDate>
            <atom:updated>2022-11-07T07:57:58.829Z</atom:updated>
            <content:encoded><![CDATA[<p>Bugünkü məqalədə Depth First Search alqoritmini haqqında danışacağıq.</p><p>DFS “graph”-ın “node”-larını gəzmək üçün istifadə edilən alqoritmlərdən biridir. BFS-da fərqli olaraq DFS “node”ları “level”lər üzrə deyil, sol “child node”lar üzrə gəzir, daha sonra yeni “path”a keçir və eyni şəkildə təkrar edərək bütün sol “child node”ları gəzir.</p><p>DFS alqoritmini təsvir etmək üçün biz “node”ları “visited”(keçilmiş) və “unvisited” (keçilməmiş) olaraq işarələyəcəyik. Bu şəkildə işarələməkdə məqsədimiz odur ki, “graph”da “cycle”ların qarşısını alaq. Bildiyiniz üzrə <strong>tree</strong> özü də <strong>graph</strong>-ın xüsusi bir formasıdır. Graph-dan fərqli olaraq tree-də “cycle”lar olmadığı üçün bizim belə bir işarələməyə ehtiyacımız olmur.</p><p>Yadınızdadırsa, BFS göstərmək üçün biz “queue data structure”dan istifadə etmişdik. DFS-da isə BFS-dan fərqli olaraq “stack data structure”dan istifadə edəcəyik.</p><h4>Stack istifadə edəndə “tree”lərdə proses aşağıdakı kimi baş verir:</h4><ol><li>“Source node”dan başlayaraq hər bir “node”un sol “child node”larını gəzirik, və bir bir gəzdikcə “stack”a əlavə edirik</li><li>“Leaf node”a (heç bir child-ı olmayan node) çatanda onu “stack”dan pop() edirik.</li><li>“Stack”da qalan “node”un sağ “node”u olub olmadığını yoxlayırıq. Əgər varsa, onu “stack”a əlavə edirik.<br>Sağ “node”u yoxdursa, onda sağ “node”u olan node tapana qədər bir-bir “node”ları stackdan pop() edirik, sağ “node”u olan node tapanda isə onun sağ “node”unu “stack”a əlavə edirik.</li><li>“Stack”da heç bir node qalmayan kimi <strong>mərhələ 1 </strong>-dən başlayaraq bütün mərhələləri təkrar edirik.</li></ol><p>Traverse ardıcıllığını göstərmək üçün nodeları stacka hər əlavə edəndə eyni zamanda əlavə etdiyimiz nodeu arrayə də əlavə edərək sonda göstərə bilərik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*mWssjio9ueyDMmmK.gif" /></figure><blockquote>Stack istifadə etməkdə məqsəd odur ki, biz DFS “traversal” edəndə birinci sol “child node”ları gəzirik, sonuncu “sol child node”a çatanda isə biz artıq yenidən “path”ın başına qayıtmırıq, elə sonuncu “child node”umuzun “parent node”una qayıdırıq.</blockquote><h4>DFS-a “tree” üzərindən aşağıdakı nümunə ilə baxaq.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/218/1*fNoaYEG4TuAHJYsc3S1hVQ.png" /></figure><p>Məsələn, yuxarıda gördüyünüz “tree”də əvvəlcə biz “source node”-dan başlayaraq bütün sol “child node”ları gəzdik. Daha sonra “leaf node”a (burda 3 “node”dur) çatanda artıq biz son “child node”un qonşu “node”u (burda 4 “node”dur) ilə əlaqələnməliyik. İkisini əlaqələndirən isə “parent node” (burda 2 “node”u) olduduğu üçün biz “stack data structure”undan istifadə edəcəyik.</p><blockquote>Stack LIFO (Last In First Out) , yəni son gələn ilk çıxar prinsipinə əsaslanır.</blockquote><p>Biz də yuxarıdakı “tree”də DFS zamanı sonuncu olaraq node 3-ü gəzirik. Əgər stack istifadə etsək, onda biz sonuncu əlavə etdiyimiz “node”u, yəni node 3 -ü pop() edərik, yəni silərik. Bu halda “stack”ımızda qalan sonuncu element node 2 olacaq. Nəticədə, biz rahatlıqla onun sağ noduna keçə biləcəyik. Daha sonra isə sol “child node”ları gəzərək, eyni prosesi DFS bitənə və stack boş olana qədər təkrar edəcəyik.</p><h4>Stack ilə təsviri:</h4><ol><li>Source node əlavə edirik.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/109/1*y7o3nH5RWL-DoaYKWTuJ7w.png" /></figure><p>2. Sol child “node”u əlavə edirik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/93/1*3396Kznnn4rLBiQl9jcsig.png" /></figure><p>3. Leaf nodea çatana qədər <strong>mərhələ 2</strong> təkrarlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/107/1*m_i8KUSRbisQMv70QpmIcw.png" /></figure><p>4. Leaf “node”a çatanda “stack”dan pop() edilir və “stack”da qalan “node”un sağ “node”u əlavə edilir və <strong>mərhələ 1</strong>-dən başlayaraq təkrar edilir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/164/1*XMAd88qOZ1CuVHJI6RnBoA.png" /></figure><p>5. “Stack”da heç bir node qalmayana qədər <strong>mərhələ 4</strong> təkrarlanır və nəticədə, DFS tamamlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/172/1*tfEudFXUR9Of2PKXiYkFcg.png" /><figcaption>Mərhələ 4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/1*LqQVTgqhj1u774w8X56u8g.png" /><figcaption>mərhələ 4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/165/1*HHNzYEYxfyMh2NHu77-zDg.png" /><figcaption>mərhələ 4</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/172/1*uj7Ayjn-1rUkKgFNTTNIHQ.png" /><figcaption>DFS tamamlandı</figcaption></figure><p>DFS {1, 2, 3, 4, 5}</p><blockquote>Graplarda da proses treelərdən bir az fərqli şəkildə baş verir. Deməli, bizim həm <em>visited</em> arraymiz həm də <em>stack</em>ımız olur.</blockquote><h4>Graphlarda DFS aşağıdakı kimi olur:</h4><ol><li>“Source node”u gəzib onu stacka əlavə edirik</li><li>Stackda node varsa onu pop() edib visited arrayə əlavə edirik. Onunla birbaşa əlaqələnən unvisited “node”ları isə stacka əlavə edirik.</li><li><strong>Mərhələ 2</strong> stackda heç bir node qalmayana kimi təkrarlanır.</li></ol><h4>Gəlin, aşağıdakı nümunədə graph üçün DFS-ə baxaq:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/357/1*Cun_g_npVYKq25Re8Tx5UA.png" /></figure><p><strong>Narıncı</strong> nodelar keçilməmiş, <strong>göy</strong> nodelar isə keçilmiş nodelardır.</p><ol><li>Birinci “A node”u ilə başlayırıq, və onu stacka əlavə edirik.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*pnBw1iCi18UtK6BPW_lQug.png" /></figure><p>2. Stack boş deyilsə, nodeu pop() edibi visited arrayimizə əlavə edirik. Onunla əlaqələnən <strong>univisited</strong> qonşu nodeları isə stacka əlavə edirik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*7NiI2QS5HNvdm3xhueUnVg.png" /></figure><p>3. “Stack”da heç bir node qalmayana kimi bütün <strong>mərhələ 2</strong> təkrarlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/461/1*tIt3t9-eO1G5c25RNmHtrg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*s2vDzkPd3TA6F1I2xoYqzg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/447/1*q4MDNMjxT7vDY1Xwf-kO4g.png" /></figure><figure><img alt="B “node”nun heç bir unvisited “node”u olmadığı üçün stackdan pop() edildikdən sonra visited arrayına əlavə edilir." src="https://cdn-images-1.medium.com/max/457/1*qfV3jQ5CFdh6ctlFyNc8xA.png" /></figure><figure><img alt="Stackda univisted qonşu nodeu olan heç bir node qalmadığı üçün hamısı sıra ilə pop() edilir." src="https://cdn-images-1.medium.com/max/522/1*8lhHrImS4Lpv3gi4ONcLkA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*KpPVK-Gf0npcfXULCpEI1Q.png" /></figure><figure><img alt="DFS tamamlanmışdır" src="https://cdn-images-1.medium.com/max/507/1*rfgecbW_ScLWnV6NGd_NeA.png" /></figure><blockquote>Grap və Tree üçün DFS-də tək fərq “circle”ların qarşısını almaq üçün istifadə etdiyimiz <em>visited</em> “array”idir.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8da1fa20fa60" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breadth First Search (or Traversal)]]></title>
            <link>https://medium.com/@aphar/java-da-tree-%C3%BC%C3%A7%C3%BCn-breadth-first-search-or-traversal-ea2d8971d5ed?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea2d8971d5ed</guid>
            <category><![CDATA[trees]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[breadth-first-search]]></category>
            <category><![CDATA[fb]]></category>
            <category><![CDATA[data-structure-algorithm]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Sat, 29 Oct 2022 16:11:22 GMT</pubDate>
            <atom:updated>2025-08-22T16:24:55.466Z</atom:updated>
            <content:encoded><![CDATA[<p>Breadth-First Search və ya BFS tree və grap-larda hər level üzrə “node”ların gəzilməsidir.</p><blockquote>Biz BFS ilə “node”ları gəziriksə, əvvəlcə başlanğıc “level”dəki bütün qonşu “node”ları daha sonra onun “child node”undakı bütün qonşu “node”ları gəzirik. Hər level üçün isə bu qayda eyni şəkildə təkrar-təkrar “leaf node”a çatana qədər təkrar edilir.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/517/1*4c18M3kFWLblof29sF6h9Q.png" /></figure><p>Gördüyünüz kimi “level”lər üzrə “node”ları gəzmək üçün bizim qonşu “node”larımızı bir birinə bağlayan heç bir əlaqəmiz yoxdur, valideyn “node” istisna olmaqla. Deməli, biz “node”ları level üzrə gəzmək üçün istinad kimi valideyn “node”dan istifadə etməliyik. Bəs necə edəcəyik?</p><p>Bu əlaqənin kod kimi təsviri üçün biz “queue” anlayışından istifadə edəcəyik. “queue” bildiyiniz kimi FIFO (First In First Out) şərtinə əsaslanaraq işləyir. Yəni “queue” əlavə etdiyimiz ilk element ilk “queue”dan çıxan ilk element olur.</p><p>Biz hər dəfə mövcud “level”dəki hər bir “node”un “child node”larını ardıcıl olaraq gəzmək üçün mövcud “level”dəki hər bir valideyn “node”u gəzib onun “child”larını əldə etməliyik. Gəlin indi bunu yuxarıda göstərilən “tree” üçün “queue” üzrə canlandıraq.</p><p>Əvvəlcə, “source node”u “queue”muza əlavə edirik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/1*xeo8-0Hig84hiyPFZ6cBFA.png" /></figure><p>Вaha sonra “0”-ı silirik və eyni zamanda çap edirik və ya “array”ə əlavə edə bilərik. Ardınca onun “child node”larını “queue”a əlavə edirik. Əvvəlcə, sol sonra sağ “child node”u.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/1*_G0Fmhvb3Cxp7B5ykTkFYA.png" /></figure><p>Növbəti dəfə, eyni prosedur 1 və 2 üçün də təkrarlanır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/264/1*9Rbru5DulVkvpH-kgrqxvA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/322/1*IiHg5lV4Ozf3jriU6yTeDA.png" /></figure><p>1 və 2-in “child node”ları əlavə edildikdən sonra “queue”da olan bütün “node”lar “leaf node” olduğu üçün heç bir əlavə edilmə olmadan ardıcıl olaraq gəzilərək ardından “queue”dan silinəcəklər.</p><p>Gəlin, indi bunun Java-da queue ilə təsvir edilmiş halına baxaq.</p><p>Nodeları təsvir etmək üçün, əvvəlcə, dəyəri və sağ, sol “Node”u olan bir Node class yaratmalıyıq.</p><pre>class Node {<br>    int data;<br>    Node left, right;<br><br>    public Node(int item) {<br>        data = item;<br>        left = null;<br>        right = null;<br>    }<br>}</pre><p>Node “class”ı vasitəsilə bir hər bir “node”muzu təsvir edə biləcəyik. İndi növbə BFS-nın Java-da “queue” vasitəsilə təsvirindədir.</p><pre>class BinaryTree {<br><br>    Node root;<br><br>    /**<br>     * Queue istifadə edərək BinaryTree-nin<br>     * nodelarını hər bir levelə görə gəzəcəyk. <br>     */<br>    void printLevelOrder() {<br>        Queue&lt;Node&gt; queue = new LinkedList&lt;Node&gt;();<br>        queue.add(root);<br>        while (!queue.isEmpty()) {<br><br>         /* poll() funksiyası ilə verilmiş nodeu silirik.*/<br>            Node tempNode = queue.poll();<br>            System.out.print(tempNode.data + &quot; &quot;);<br><br>            /*sol nodeu queue əlavə edirik */<br>            if (tempNode.left != null) {<br>                queue.add(tempNode.left);<br>            }<br><br>            /*sağ nodeu queue əlavə edirik*/<br>            if (tempNode.right != null) {<br>                queue.add(tempNode.right);<br>            }<br>        }<br>    }<br>}</pre><p>Kodu yoxlamaq üçün “Main”in içərisində bir neçə kod yazıb nəticəsinə baxaq.</p><pre>public static void main(String args[]) {<br>/* binary tree yaradırıq və Nodelar əlavə edirik*/<br>      BinaryTree tree_level = new BinaryTree();<br>      tree_level.root = new Node(0);<br>      tree_level.root.left = new Node(1);<br>      tree_level.root.right = new Node(2);<br>      tree_level.root.left.left = new Node(3);<br>      tree_level.root.left.right = new Node(4);<br>      tree_level.root.right.left = new Node(5);<br>      tree_level.root.right.right = new Node(6);<br>      System.out.println(&quot;Breadth First Search of binary tree is - &quot;);<br>      tree_level.printLevelOrder();<br>  }</pre><p>Kodu run etdikdə aşağıdakı kimi nəticə əldə edirik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/324/1*-PEyJG5ilninb_8uOwAJcQ.png" /></figure><p>Nəticədən də gördüyümüz üzrə kodumuz “Binary tree”miz üçün düzgün şəkildə işləyir.</p><p>Graph-da isə BFS tree-də olduğundan fərqlidir. Tree data sturukturda heç bir cycle yoxdur, ona görə bizim visited node-ları track etməyimizə ehtiyac yoxdur. Ancaq graph-larda cycle-lar ola bilər, və BFS düzgün işləməsi üçün biz cycle da nəzərə almalıyıq.</p><p>Graph üçün olan BFS pseudocode incələyərək animasiyamızı və java BFS kodunu yaza bilərik.</p><pre>BFS(Graph G, start):<br>    create an empty queue Q<br>    create an empty set visited<br><br>    enqueue start into Q<br>    add start to visited<br><br>    while Q is not empty:<br>        node = dequeue Q<br>        process(node)<br><br>        for each neighbor of node:<br>            if neighbor not in visited:<br>                enqueue neighbor<br>                mark neighbor as visited</pre><p>Gəlin, nümunə üzərindən baxaq:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*795ItzYtxNkmwHchzH50Bw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-MORICW42o3MY7zl7-b1OQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LovltVsybZKdqL5kpAIVeA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7WbYvBn8QoOyKqeUIniPdg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDlH-071c12kXGNktr2g9A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NXCr_FKA6lYsO8Qlgq_fGw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4OSruAuWtBsEqVktjbzGQA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7w0hpq3Bk4uxZUARmkBevg.png" /></figure><p>Aşağıda gördüyünüz kod graph üçün olan BFS algorithm tətbiqidir:</p><pre>public class BFSGraph {<br>    private Map&lt;Integer, List&lt;Integer&gt;&gt; graph = new HashMap&lt;&gt;();<br><br>    public void addEdge(int u, int v) {<br>        graph.putIfAbsent(u, new ArrayList&lt;&gt;());<br>        graph.putIfAbsent(v, new ArrayList&lt;&gt;());<br>        graph.get(u).add(v);<br>        graph.get(v).add(u); // undirected graph<br>    }<br><br>    public void bfs(int start) {<br>        Queue&lt;Integer&gt; queue = new LinkedList&lt;&gt;();<br>        Set&lt;Integer&gt; visited = new HashSet&lt;&gt;();<br><br>        queue.add(start);<br>        visited.add(start);<br><br>        while (!queue.isEmpty()) {<br>            int node = queue.poll();<br>            System.out.print((char) node + &quot; &quot;);<br><br>            for (int neighbor : graph.getOrDefault(node, new ArrayList&lt;&gt;())) {<br>                if (!visited.contains(neighbor)) {<br>                    queue.add(neighbor);<br>                    visited.add(neighbor);<br>                }<br>            }<br>        }<br>    }<br>}</pre><p>Kodu yoxlamaq üçün “Main”in içərisində bir neçə kod yazıb nəticəsinə baxaq.</p><pre>public static void main(String[] args) {<br>        BFSGraph g = new BFSGraph();<br><br>        // Add edges<br>        g.addEdge(&#39;A&#39;, &#39;B&#39;);<br>        g.addEdge(&#39;A&#39;, &#39;C&#39;);<br>        g.addEdge(&#39;B&#39;, &#39;D&#39;);<br>        g.addEdge(&#39;B&#39;, &#39;E&#39;);<br>        g.addEdge(&#39;C&#39;, &#39;D&#39;);<br>        g.addEdge(&#39;C&#39;, &#39;F&#39;);<br>        g.addEdge(&#39;D&#39;, &#39;E&#39;);<br>        g.addEdge(&#39;E&#39;, &#39;F&#39;);<br><br>        System.out.println(&quot;BFS starting from A:&quot;);<br>        g.bfs(&#39;A&#39;);  // Expected output order: A B C D E F<br>    }</pre><p>Kodu run etdikdə aşağıdakı kimi nəticə əldə edirik.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/358/1*eWkeesiqc8-rOipUtIZ00w.png" /></figure><p>Nəticədən gördüyümüz kimi graph üçün olan BFS alqoritmimiz düzgün işləyir.</p><blockquote>Graph və Tree üçün BFS-də tək fərq “circle”ların qarşısını almaq üçün istifadə etdiyimiz <em>visited</em> “array”idir.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea2d8971d5ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Nə vaxt abstract class, nə vaxt interface istifadə etməliyik?]]></title>
            <link>https://medium.com/@aphar/n%C9%99-vaxt-abstract-class-n%C9%99-vaxt-interface-istifad%C9%99-etm%C9%99liyik-8420a46ccf37?source=rss-c49a575daee8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8420a46ccf37</guid>
            <category><![CDATA[interfaces]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[abstrakt-sinif]]></category>
            <category><![CDATA[abstract-class-in-java]]></category>
            <category><![CDATA[interfeys]]></category>
            <dc:creator><![CDATA[Aphar Magaramova]]></dc:creator>
            <pubDate>Wed, 19 Oct 2022 13:02:16 GMT</pubDate>
            <atom:updated>2022-10-19T13:20:28.777Z</atom:updated>
            <content:encoded><![CDATA[<p>Object Oriented Programming-i təzə öyrənən hər kəsin ağlına gələcək ilk suallardan biri interface və abstract class arasındakı fərq nədir? nə vaxt hansını istifadə etməliyəm olur çox vaxt.</p><p>Gəlin, əvvəlcə, baxaq görək interface nədir, abstract class nədir.</p><p>Deməli, abstract class abstract keyword-ün köməyi ilə declare(yaradılır) edilir, içərisində abstract və non-abstract(abstract olmayan) methodlar ola bilər. Abstarct methodların body-si olmur. Bu methodlar sadəcə declare edilir, yəni göstərilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/466/1*FF82zdi2WxjfcpNCSjrWZw.png" /></figure><p>Abstract classlar heç vaxt birbaşa instantiate edilə (obyekti yaradıla) bilməz. Yalnız subclassları vasitəsilə instantiate edilə bilərlər.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*FsMc2sHL0g2mY-czaS1T2A.png" /></figure><p>Bəs, interface nədir? İnterface bütün bir abstract classdır. Ancaq fərq ondadır ki, interface yaradarkən biz interface keywordündən istifadə edirik. İnterfacelər yalnız abstract methodlara sahib olur. Və bu methodları yaradarkən abstract keywordündən istifadə etmək lazım deyil, çünki dəyər default olaraq abstractdır. Eyni zamanda interfacelərin içərisində variable istifadə edəcəyiksə, mütləq instantia etməliyik və bu variable-lar default olaraq final static olacaqlar. İnterfacelərin elementləri yalnız public accsessordan istifadə edə bilərlər.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/286/1*dmHU-JX1Ob-V-uEYnN_xCg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/251/1*SKg-DBOPp70a8jsCzcmNsA.png" /></figure><p>İndi gəldik əsas suala: nə vaxt interface, nə vaxt abstract class istifadə etməliyik?</p><p>Gördüyünüz kimi interfacelərin içərisində non-abstract methodlar yarada bilmirik, ancaq abstract classlarda bu mümkündür. Ona görə belə nəticəyə gəlmək olar ki, əgər biz eyni kodu bütün subclasslarımız üçün istifadə edəcəyiksə, onda interface istifadə etmək düzgün seçim olmaz. Niyə? çünki biz hər dəfə subclass-da methodlarımızı override edəndə məcburuq ki bütün classlar üçün eyni kodu yenidən yazaq. Ancaq abstrac class istifadə edərək, non-abstract methodlar bütün subclasslar üçün eyni olacaq kodu elə abstract classın içərisində yaza bilərik.</p><p>Bir digər tərəfdən Java-da bir class yalnız bir classdan extend edə bilər. Yəni multiple inheritance mümkün deyil, bu yalnız interface-lər vasitəsilə mümkündür. Əgər subclassınız gələcəkdə başqa classlardan da extend edəcəksə, onda abtract istifadə etmək sizə çətinlik yarada bilər. Bu halda interface istifadə edərək subclassınızın bir neçə interfacedən implemente edərək daha yaxşı işləməsinə kömək edə bilərsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8420a46ccf37" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>