<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="3.10.0">Jekyll</generator><link href="https://anhdt2511.github.io/feed.xml" rel="self" type="application/atom+xml" /><link href="https://anhdt2511.github.io/" rel="alternate" type="text/html" /><updated>2026-03-04T12:51:00+00:00</updated><id>https://anhdt2511.github.io/feed.xml</id><title type="html">Góc của T.Anh</title><subtitle>Góc của T.Anh</subtitle><author><name>Đinh Tuấn Anh</name></author><entry><title type="html">Project</title><link href="https://anhdt2511.github.io/project.html" rel="alternate" type="text/html" title="Project" /><published>2021-09-06T00:00:00+00:00</published><updated>2021-09-06T00:00:00+00:00</updated><id>https://anhdt2511.github.io/project</id><content type="html" xml:base="https://anhdt2511.github.io/project.html"><![CDATA[<p>Ở bài này, chúng ta sẽ cùng viết một vài method cơ bản cho các đối tượng đã tạo ở những bài trước đó. Cũng giống như các class có sẵn trong Java, mỗi class đều có các method riêng của class đó để cung cấp các chức năng cụ thể để làm việc với class đó.</p>

<p>Vì vậy đầu tiên chúng ta cần xác định các chức năng cần có để có thể làm việc với các đối tượng <code class="language-plaintext highlighter-rouge">Person</code>, <code class="language-plaintext highlighter-rouge">Student</code> và <code class="language-plaintext highlighter-rouge">Staff</code>.</p>

<h2 id="i-xác-định-các-method">I. Xác định các method</h2>

<blockquote>
  <p>Những method viết trong class là <strong>những method tương tác trực tiếp với các thuộc tính của class đó</strong>.</p>
</blockquote>

<p>Vậy nên tạm thời chúng ta có thể xác định được 2 method cơ bản cần viết đầu tiên là:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">input()</code>: nhập dữ liệu từ bàn phím vào các thuộc tính.</li>
  <li><code class="language-plaintext highlighter-rouge">display()</code>: hiển thị các thuộc tính của đối tượng.</li>
</ul>

<p><em>Chúng ta có thể bổ sung thêm các method mới bất cứ khi nào chúng ta cần.</em></p>

<h2 id="ii-triển-khai-vào-dự-án">II. Triển khai vào dự án</h2>

<p>Sau khi đã xác định cần làm gì, chúng ta sẽ thực hiện viết mã vào dự án theo các bước sau:</p>

<ol>
  <li>Trong class <strong>entity.Person</strong>:
    <ul>
      <li>
        <p>Chúng ta sẽ viết method <code class="language-plaintext highlighter-rouge">display()</code> để hiển thị một đối tượng <code class="language-plaintext highlighter-rouge">Person</code> như sau:</p>

        <div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">entity</span><span class="o">;</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Person</span> <span class="o">{</span>

    <span class="kd">private</span> <span class="nc">String</span> <span class="n">rollNumber</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">name</span><span class="o">;</span>
    <span class="kd">private</span> <span class="kt">boolean</span> <span class="n">gender</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">dob</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">email</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">mobile</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">address</span><span class="o">;</span>

    <span class="c1">// getter &amp; setter</span>
          
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">display</span><span class="o">()</span> <span class="o">{</span>
        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">printf</span><span class="o">(</span>
                <span class="s">"| %10s | %16s | %5s | %12s | %28s | %12s | %12s |"</span><span class="o">,</span>
                <span class="n">rollNumber</span><span class="o">,</span>
                <span class="n">name</span><span class="o">,</span>
                <span class="n">gender</span> <span class="o">?</span> <span class="s">"Nam"</span> <span class="o">:</span> <span class="s">"Nữ"</span><span class="o">,</span>
                <span class="n">dob</span><span class="o">,</span>
                <span class="n">email</span><span class="o">,</span>
                <span class="n">mobile</span><span class="o">,</span>
                <span class="n">address</span>
        <span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div>        </div>
      </li>
      <li>
        <p>Tiếp theo chúng ta sẽ sử dụng lớp <code class="language-plaintext highlighter-rouge">Scanner</code> để viết method <code class="language-plaintext highlighter-rouge">input()</code> - lấy các giá trị từ bàn phím gán vào các thuộc tính của đối tượng như sau:</p>

        <div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">entity</span><span class="o">;</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Person</span> <span class="o">{</span>

    <span class="kd">private</span> <span class="nc">String</span> <span class="n">rollNumber</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">name</span><span class="o">;</span>
    <span class="kd">private</span> <span class="kt">boolean</span> <span class="n">gender</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">dob</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">email</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">mobile</span><span class="o">;</span>
    <span class="kd">private</span> <span class="nc">String</span> <span class="n">address</span><span class="o">;</span>

    <span class="c1">// getter &amp; setter</span>
          
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">display</span><span class="o">()</span> <span class="o">{</span>
        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">printf</span><span class="o">(</span>
                <span class="s">"| %10s | %16s | %5s | %12s | %28s | %12s | %12s |"</span><span class="o">,</span>
                <span class="n">rollNumber</span><span class="o">,</span>
                <span class="n">name</span><span class="o">,</span>
                <span class="n">gender</span> <span class="o">?</span> <span class="s">"Nam"</span> <span class="o">:</span> <span class="s">"Nữ"</span><span class="o">,</span>
                <span class="n">dob</span><span class="o">,</span>
                <span class="n">email</span><span class="o">,</span>
                <span class="n">mobile</span><span class="o">,</span>
                <span class="n">address</span>
        <span class="o">);</span>
    <span class="o">}</span>
          
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">input</span><span class="o">()</span> <span class="o">{</span>
        <span class="nc">Scanner</span> <span class="n">scanner</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"\nEnter rollNumber: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">rollNumber</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter name: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">name</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter gender: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">gender</span> <span class="o">=</span> <span class="nc">Boolean</span><span class="o">.</span><span class="na">parseBoolean</span><span class="o">(</span><span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">());</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter dob (DD/MM/YYYY): "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">dob</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter email: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">email</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter mobile: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">mobile</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter address: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">address</span> <span class="o">=</span> <span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">();</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div>        </div>
      </li>
    </ul>
  </li>
  <li>Trong class <strong>entity.Student</strong>:
    <ul>
      <li>
        <p>Chúng ta sẽ kế thừa method <code class="language-plaintext highlighter-rouge">display()</code> từ class <code class="language-plaintext highlighter-rouge">Person</code> và viết lại mã cho phù hợp như sau:</p>

        <div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">entity</span><span class="o">;</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Student</span> <span class="kd">extends</span> <span class="nc">Person</span> <span class="o">{</span>

    <span class="kd">private</span> <span class="kt">double</span> <span class="n">mark</span><span class="o">;</span>

    <span class="c1">// getter &amp; setter</span>
          
    <span class="nd">@Override</span>
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">display</span><span class="o">()</span> <span class="o">{</span>
        <span class="kd">super</span><span class="o">.</span><span class="na">display</span><span class="o">();</span>
        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">printf</span><span class="o">(</span><span class="s">"%6s |\n"</span><span class="o">,</span> <span class="n">mark</span><span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div>        </div>
      </li>
      <li>
        <p>Tương tự với method <code class="language-plaintext highlighter-rouge">input()</code> như sau:</p>

        <div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">entity</span><span class="o">;</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Student</span> <span class="kd">extends</span> <span class="nc">Person</span> <span class="o">{</span>

    <span class="kd">private</span> <span class="kt">double</span> <span class="n">mark</span><span class="o">;</span>

    <span class="c1">// getter &amp; setter</span>
          
    <span class="nd">@Override</span>
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">display</span><span class="o">()</span> <span class="o">{</span>
        <span class="kd">super</span><span class="o">.</span><span class="na">display</span><span class="o">();</span>
        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">printf</span><span class="o">(</span><span class="s">"%6s |\n"</span><span class="o">,</span> <span class="n">mark</span><span class="o">);</span>
    <span class="o">}</span>

    <span class="nd">@Override</span>
    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">input</span><span class="o">()</span> <span class="o">{</span>
        <span class="nc">Scanner</span> <span class="n">scanner</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>

        <span class="kd">super</span><span class="o">.</span><span class="na">input</span><span class="o">();</span>
        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="s">"Enter mark: "</span><span class="o">);</span>
        <span class="k">this</span><span class="o">.</span><span class="na">mark</span> <span class="o">=</span> <span class="nc">Double</span><span class="o">.</span><span class="na">parseDouble</span><span class="o">(</span><span class="n">scanner</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">trim</span><span class="o">());</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div>        </div>
      </li>
    </ul>

    <p><em>Thực hiện tương tự đối với đối tượng <code class="language-plaintext highlighter-rouge">Staff</code>, trong phạm vi bài viết từ nay về sau, chúng ta sẽ chỉ triển khai mã ví dụ với chỉ đối tượng <code class="language-plaintext highlighter-rouge">Student</code>.</em></p>
  </li>
</ol>

<h2 id="iii-manual-testing">III. Manual testing</h2>

<p>Cấu trúc dự án hiện tại:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">Project</span><span class="o">/</span>
   <span class="err">└──</span><span class="n">src</span><span class="o">/</span>  
      <span class="err">├──</span><span class="n">entity</span>
      <span class="err">│</span>  <span class="err">├──</span><span class="nc">Person</span><span class="o">.</span><span class="na">java</span>
      <span class="err">│</span>  <span class="err">├──</span><span class="nc">Staff</span><span class="o">.</span><span class="na">java</span>
      <span class="err">│</span>  <span class="err">└──</span><span class="nc">Student</span><span class="o">.</span><span class="na">java</span>
      <span class="err">└──</span><span class="n">main</span> 
         <span class="err">└──</span><span class="nc">Main</span><span class="o">.</span><span class="na">java</span>
</code></pre></div></div>

<p>Sau khi triển khai viết mã cho những method đầu tiên, chúng ta sẽ viết mã kiểm tra xem mã đã viết có chạy đúng như yêu cầu mong muốn hay không, mã kiểm tra sẽ được viết trong class <code class="language-plaintext highlighter-rouge">Main</code>.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">main</span><span class="o">;</span>

<span class="kn">import</span> <span class="nn">entity.Student</span><span class="o">;</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Main</span> <span class="o">{</span>

    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
    
        <span class="nc">Student</span> <span class="n">student</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Student</span><span class="o">();</span> <span class="c1">// create instance Student</span>
        <span class="n">student</span><span class="o">.</span><span class="na">input</span><span class="o">();</span>                 <span class="c1">// call method input()</span>
        <span class="n">student</span><span class="o">.</span><span class="na">display</span><span class="o">();</span>               <span class="c1">// call method display()</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<p>Kết quả nhận được:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">Enter</span> <span class="nl">rollNumber:</span> <span class="no">HE150345</span>
<span class="nc">Enter</span> <span class="nl">name:</span> <span class="nc">Tuan</span> <span class="nc">Anh</span>
<span class="nc">Enter</span> <span class="nl">gender:</span> <span class="kc">true</span>
<span class="nc">Enter</span> <span class="nf">dob</span> <span class="o">(</span><span class="no">DD</span><span class="o">/</span><span class="no">MM</span><span class="o">/</span><span class="no">YYYY</span><span class="o">):</span> <span class="mi">11</span><span class="o">/</span><span class="mi">11</span><span class="o">/</span><span class="mi">1994</span>
<span class="nc">Enter</span> <span class="nl">email:</span> <span class="nc">AnhDTHE150345</span><span class="nd">@fpt</span><span class="o">.</span><span class="na">edu</span><span class="o">.</span><span class="na">vn</span>
<span class="nc">Enter</span> <span class="nl">mobile:</span> <span class="mi">0973876107</span>
<span class="nc">Enter</span> <span class="nl">address:</span> <span class="nc">Ha</span> <span class="nc">Noi</span>
<span class="nc">Enter</span> <span class="nl">mark:</span> <span class="mf">8.5</span>

<span class="o">|</span>   <span class="no">HE150345</span> <span class="o">|</span>         <span class="nc">Tuan</span> <span class="nc">Anh</span> <span class="o">|</span>   <span class="nc">Nam</span> <span class="o">|</span>   <span class="mi">11</span><span class="o">/</span><span class="mi">11</span><span class="o">/</span><span class="mi">1994</span> <span class="o">|</span>     <span class="nc">AnhDTHE150345</span><span class="nd">@fpt</span><span class="o">.</span><span class="na">edu</span><span class="o">.</span><span class="na">vn</span> <span class="o">|</span>   <span class="mi">0973876107</span> <span class="o">|</span>       <span class="nc">Ha</span> <span class="nc">Noi</span> <span class="o">|</span>   <span class="mf">8.5</span> <span class="o">|</span>
</code></pre></div></div>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><category term="basic" /><summary type="html"><![CDATA[Ở bài này, chúng ta sẽ cùng viết một vài method cơ bản cho các đối tượng đã tạo ở những bài trước đó. Cũng giống như các class có sẵn trong Java, mỗi class đều có các method riêng của class đó để cung cấp các chức năng cụ thể để làm việc với class đó.]]></summary></entry><entry><title type="html">Wrapper class</title><link href="https://anhdt2511.github.io/wrapper-class.html" rel="alternate" type="text/html" title="Wrapper class" /><published>2021-09-02T00:00:00+00:00</published><updated>2021-09-02T00:00:00+00:00</updated><id>https://anhdt2511.github.io/wrapper-class</id><content type="html" xml:base="https://anhdt2511.github.io/wrapper-class.html"><![CDATA[<p>Trong Java, kiểu dữ liệu được chia làm hai loại:</p>

<ul>
  <li>Kiểu dữ liệu nguyên thuỷ (<strong>Primitive data types</strong>)</li>
  <li>Kiểu dữ liệu không nguyên thuỷ (<strong>Non-primitive data types</strong>).</li>
</ul>

<p>Thông thường, để phân biệt 2 kiểu này ta dựa vào tên của nó. Kiểu nguyên thủy có tên bắt đầu bằng chữ thường, các kiểu không nguyên thuỷ có tên bắt đầu bằng chữ in hoa.</p>

<p>Ví dụ:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">int</code>, <code class="language-plaintext highlighter-rouge">long</code>, <code class="language-plaintext highlighter-rouge">float</code>, <code class="language-plaintext highlighter-rouge">double</code> là kiểu nguyên thủy</li>
  <li><code class="language-plaintext highlighter-rouge">Integer</code>,<code class="language-plaintext highlighter-rouge">Long</code>, <code class="language-plaintext highlighter-rouge">Float</code>, <code class="language-plaintext highlighter-rouge">Double</code> là kiểu không nguyên thuỷ</li>
</ul>

<h2 id="i-primitive-data-types">I. Primitive data types</h2>

<p>Các bạn có thể đọc lại bài sau <a href="https://github.com/AnestAcademy/Course-Java-OOP/blob/master/03.%20Data%20types.md">Data types</a></p>

<h2 id="ii-non-primitive-data-types">II. Non-primitive data types</h2>

<h3 id="1-kiểu-dữ-liệu-đối-tượng">1. Kiểu dữ liệu đối tượng</h3>

<p>Trong java có 3 kiểu dữ liệu đối tượng:</p>

<table>
  <thead>
    <tr>
      <th style="text-align: center">No</th>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center">1</td>
      <td>Array</td>
      <td>Một mảng của các dữ liệu cùng kiểu.</td>
    </tr>
    <tr>
      <td style="text-align: center">2</td>
      <td>class</td>
      <td>Dữ liệu kiểu lớp đối tượng do người dùng định nghĩa. Chứa tập các thuộc tính và phương thức.</td>
    </tr>
    <tr>
      <td style="text-align: center">3</td>
      <td>interface</td>
      <td>Dữ liệu kiểu lớp giao tiếp do người dùng định nghĩa. Chứa các phương thức của giao tiếp.</td>
    </tr>
  </tbody>
</table>

<p><em>Chúng ta sẽ tìm hiểu chi tiết những đối tượng này ở những bài sau.</em></p>

<h3 id="2-wrapper-class">2. Wrapper class</h3>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class.png" alt="Wrapper Class" /></p>

<p>Lớp Wrapper trong java cung cấp cơ chế để chuyển đổi kiểu dữ liệu nguyên thủy thành kiểu đối tượng và ngược lại từ đối tượng thành kiểu dữ liệu nguyên thủy.</p>

<table>
  <thead>
    <tr>
      <th style="text-align: center">No</th>
      <th>Kiểu nguyên thủy</th>
      <th>Kiểu Wrapper</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center">1</td>
      <td>boolean</td>
      <td>Boolean</td>
    </tr>
    <tr>
      <td style="text-align: center">2</td>
      <td>char</td>
      <td>Character</td>
    </tr>
    <tr>
      <td style="text-align: center">3</td>
      <td>byte</td>
      <td>Byte</td>
    </tr>
    <tr>
      <td style="text-align: center">4</td>
      <td>short</td>
      <td>Short</td>
    </tr>
    <tr>
      <td style="text-align: center">5</td>
      <td>int</td>
      <td>Integer</td>
    </tr>
    <tr>
      <td style="text-align: center">6</td>
      <td>long</td>
      <td>Long</td>
    </tr>
    <tr>
      <td style="text-align: center">7</td>
      <td>float</td>
      <td>Float</td>
    </tr>
    <tr>
      <td style="text-align: center">8</td>
      <td>double</td>
      <td>Double</td>
    </tr>
  </tbody>
</table>

<p>Ví dụ chuyển đổi <code class="language-plaintext highlighter-rouge">int</code> thành <code class="language-plaintext highlighter-rouge">Integer</code>:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">SampleClass</span> <span class="o">{</span>

    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
    
        <span class="kt">int</span> <span class="n">num1</span> <span class="o">=</span> <span class="mi">1</span><span class="o">;</span>
        <span class="nc">Integer</span> <span class="n">num2</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">valueOf</span><span class="o">(</span><span class="n">num1</span><span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<h3 id="tại-sao-phải-chuyển-đổi-kiểu-dữ-liệu-nguyên-thủy-thành-kiểu-đối-tượng">Tại sao phải chuyển đổi kiểu dữ liệu nguyên thủy thành kiểu đối tượng?</h3>

<p>Như chúng ta đã tìm hiểu về đối tượng, thì một đối tượng sẽ có <strong>thuộc tính</strong> và <strong>phương thức</strong> còn dữ liệu nguyên thủy thì không. Trong Java, có sẵn rất nhiều phương thức được cung cấp theo từng <code class="language-plaintext highlighter-rouge">class</code> có chức năng cụ thể để làm việc với <code class="language-plaintext highlighter-rouge">class</code> đó.</p>

<p>Sau khi một giá trị nguyên thủy được chuyển đổi thành đối tượng, nó có thể gọi được các phương thức của <code class="language-plaintext highlighter-rouge">class</code> đó ra để sử dụng.</p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-3.jpg" alt="Wrapper Class" /></p>

<blockquote>
  <p>Nếu bạn thử lấy <code class="language-plaintext highlighter-rouge">num1</code> gọi các phương thức của <strong>class  Integer</strong> thì chương trình sẽ báo lỗi vì <code class="language-plaintext highlighter-rouge">num1</code> là kiểu dữ liệu nguyên thủy. Nhưng sau khi chúng ta chuyển đổi <code class="language-plaintext highlighter-rouge">num1</code> thành đối tượng <code class="language-plaintext highlighter-rouge">num2</code> bằng cách sử dụng phương thức <code class="language-plaintext highlighter-rouge">valueOf()</code> được cung cấp sẵn trong <strong>class Integer</strong> thì <code class="language-plaintext highlighter-rouge">num2</code> có thể gọi các phương thức của <strong>class Integer</strong> một cách bình thường.</p>
</blockquote>

<p><em>Vì trong Java cung cấp rất nhiều phương thức có sẵn đi theo từng <code class="language-plaintext highlighter-rouge">class</code> nên chúng ta có thể sử dụng phím tắt <code class="language-plaintext highlighter-rouge">ctrl + space</code> trong IDE để xem nhanh danh sách phương thức được cung cấp của <code class="language-plaintext highlighter-rouge">class</code> đó.</em></p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-1.jpg" alt="Wrapper Class" /></p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-2.jpg" alt="Wrapper Class" /></p>

<p>Ví dụ chúng ta cần tìm số <code class="language-plaintext highlighter-rouge">int</code> lớn nhất bằng bao nhiêu? Trong <strong>class Integer</strong> đã có sẵn thuộc tính <code class="language-plaintext highlighter-rouge">MAX_VALUE</code> lưu trữ giá trị lớn nhất của <code class="language-plaintext highlighter-rouge">int</code>, chúng ta chỉ cần gọi nó ra là xong, không cần làm gì hay tính toán gì thêm.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">SampleClass</span> <span class="o">{</span>

    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">Integer</span><span class="o">.</span><span class="na">MAX_VALUE</span><span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<p>Kết quả nhận được:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="mi">2147483647</span>
</code></pre></div></div>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><category term="basic" /><summary type="html"><![CDATA[Trong Java, kiểu dữ liệu được chia làm hai loại:]]></summary></entry><entry><title type="html">Wrapper class</title><link href="https://anhdt2511.github.io/wrapper-class.html" rel="alternate" type="text/html" title="Wrapper class" /><published>2021-09-01T00:00:00+00:00</published><updated>2021-09-01T00:00:00+00:00</updated><id>https://anhdt2511.github.io/wrapper-class</id><content type="html" xml:base="https://anhdt2511.github.io/wrapper-class.html"><![CDATA[<p>Trong Java, kiểu dữ liệu được chia làm hai loại:</p>

<ul>
  <li>Kiểu dữ liệu nguyên thuỷ (<strong>Primitive data types</strong>)</li>
  <li>Kiểu dữ liệu không nguyên thuỷ (<strong>Non-primitive data types</strong>).</li>
</ul>

<p>Thông thường, để phân biệt 2 kiểu này ta dựa vào tên của nó. Kiểu nguyên thủy có tên bắt đầu bằng chữ thường, các kiểu không nguyên thuỷ có tên bắt đầu bằng chữ in hoa.</p>

<p>Ví dụ:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">int</code>, <code class="language-plaintext highlighter-rouge">long</code>, <code class="language-plaintext highlighter-rouge">float</code>, <code class="language-plaintext highlighter-rouge">double</code> là kiểu nguyên thủy</li>
  <li><code class="language-plaintext highlighter-rouge">Integer</code>,<code class="language-plaintext highlighter-rouge">Long</code>, <code class="language-plaintext highlighter-rouge">Float</code>, <code class="language-plaintext highlighter-rouge">Double</code> là kiểu không nguyên thuỷ</li>
</ul>

<h2 id="i-primitive-data-types">I. Primitive data types</h2>

<p>Các bạn có thể đọc lại bài sau <a href="https://github.com/AnestAcademy/Course-Java-OOP/blob/master/03.%20Data%20types.md">Data types</a></p>

<h2 id="ii-non-primitive-data-types">II. Non-primitive data types</h2>

<h3 id="1-kiểu-dữ-liệu-đối-tượng">1. Kiểu dữ liệu đối tượng</h3>

<p>Trong java có 3 kiểu dữ liệu đối tượng:</p>

<table>
  <thead>
    <tr>
      <th style="text-align: center">No</th>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center">1</td>
      <td>Array</td>
      <td>Một mảng của các dữ liệu cùng kiểu.</td>
    </tr>
    <tr>
      <td style="text-align: center">2</td>
      <td>class</td>
      <td>Dữ liệu kiểu lớp đối tượng do người dùng định nghĩa. Chứa tập các thuộc tính và phương thức.</td>
    </tr>
    <tr>
      <td style="text-align: center">3</td>
      <td>interface</td>
      <td>Dữ liệu kiểu lớp giao tiếp do người dùng định nghĩa. Chứa các phương thức của giao tiếp.</td>
    </tr>
  </tbody>
</table>

<p><em>Chúng ta sẽ tìm hiểu chi tiết những đối tượng này ở những bài sau.</em></p>

<h3 id="2-wrapper-class">2. Wrapper class</h3>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class.png" alt="Wrapper Class" /></p>

<p>Lớp Wrapper trong java cung cấp cơ chế để chuyển đổi kiểu dữ liệu nguyên thủy thành kiểu đối tượng và ngược lại từ đối tượng thành kiểu dữ liệu nguyên thủy.</p>

<table>
  <thead>
    <tr>
      <th style="text-align: center">No</th>
      <th>Kiểu nguyên thủy</th>
      <th>Kiểu Wrapper</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td style="text-align: center">1</td>
      <td>boolean</td>
      <td>Boolean</td>
    </tr>
    <tr>
      <td style="text-align: center">2</td>
      <td>char</td>
      <td>Character</td>
    </tr>
    <tr>
      <td style="text-align: center">3</td>
      <td>byte</td>
      <td>Byte</td>
    </tr>
    <tr>
      <td style="text-align: center">4</td>
      <td>short</td>
      <td>Short</td>
    </tr>
    <tr>
      <td style="text-align: center">5</td>
      <td>int</td>
      <td>Integer</td>
    </tr>
    <tr>
      <td style="text-align: center">6</td>
      <td>long</td>
      <td>Long</td>
    </tr>
    <tr>
      <td style="text-align: center">7</td>
      <td>float</td>
      <td>Float</td>
    </tr>
    <tr>
      <td style="text-align: center">8</td>
      <td>double</td>
      <td>Double</td>
    </tr>
  </tbody>
</table>

<p>Ví dụ chuyển đổi <code class="language-plaintext highlighter-rouge">int</code> thành <code class="language-plaintext highlighter-rouge">Integer</code>:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">SampleClass</span> <span class="o">{</span>

    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
    
        <span class="kt">int</span> <span class="n">num1</span> <span class="o">=</span> <span class="mi">1</span><span class="o">;</span>
        <span class="nc">Integer</span> <span class="n">num2</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">valueOf</span><span class="o">(</span><span class="n">num1</span><span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<h3 id="tại-sao-phải-chuyển-đổi-kiểu-dữ-liệu-nguyên-thủy-thành-kiểu-đối-tượng">Tại sao phải chuyển đổi kiểu dữ liệu nguyên thủy thành kiểu đối tượng?</h3>

<p>Như chúng ta đã tìm hiểu về đối tượng, thì một đối tượng sẽ có <strong>thuộc tính</strong> và <strong>phương thức</strong> còn dữ liệu nguyên thủy thì không. Trong Java, có sẵn rất nhiều phương thức được cung cấp theo từng <code class="language-plaintext highlighter-rouge">class</code> có chức năng cụ thể để làm việc với <code class="language-plaintext highlighter-rouge">class</code> đó.</p>

<p>Sau khi một giá trị nguyên thủy được chuyển đổi thành đối tượng, nó có thể gọi được các phương thức của <code class="language-plaintext highlighter-rouge">class</code> đó ra để sử dụng.</p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-3.jpg" alt="Wrapper Class" /></p>

<blockquote>
  <p>Nếu bạn thử lấy <code class="language-plaintext highlighter-rouge">num1</code> gọi các phương thức của <strong>class  Integer</strong> thì chương trình sẽ báo lỗi vì <code class="language-plaintext highlighter-rouge">num1</code> là kiểu dữ liệu nguyên thủy. Nhưng sau khi chúng ta chuyển đổi <code class="language-plaintext highlighter-rouge">num1</code> thành đối tượng <code class="language-plaintext highlighter-rouge">num2</code> bằng cách sử dụng phương thức <code class="language-plaintext highlighter-rouge">valueOf()</code> được cung cấp sẵn trong <strong>class Integer</strong> thì <code class="language-plaintext highlighter-rouge">num2</code> có thể gọi các phương thức của <strong>class Integer</strong> một cách bình thường.</p>
</blockquote>

<p><em>Vì trong Java cung cấp rất nhiều phương thức có sẵn đi theo từng <code class="language-plaintext highlighter-rouge">class</code> nên chúng ta có thể sử dụng phím tắt <code class="language-plaintext highlighter-rouge">ctrl + space</code> trong IDE để xem nhanh danh sách phương thức được cung cấp của <code class="language-plaintext highlighter-rouge">class</code> đó.</em></p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-1.jpg" alt="Wrapper Class" /></p>

<p><img src="../assets/img/posts/wrapper-class/wrapper-class-2.jpg" alt="Wrapper Class" /></p>

<p>Ví dụ chúng ta cần tìm số <code class="language-plaintext highlighter-rouge">int</code> lớn nhất bằng bao nhiêu? Trong <strong>class Integer</strong> đã có sẵn thuộc tính <code class="language-plaintext highlighter-rouge">MAX_VALUE</code> lưu trữ giá trị lớn nhất của <code class="language-plaintext highlighter-rouge">int</code>, chúng ta chỉ cần gọi nó ra là xong, không cần làm gì hay tính toán gì thêm.</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">SampleClass</span> <span class="o">{</span>

    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>

        <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="nc">Integer</span><span class="o">.</span><span class="na">MAX_VALUE</span><span class="o">);</span>
    <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<p>Kết quả nhận được:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="mi">2147483647</span>
</code></pre></div></div>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><category term="basic" /><summary type="html"><![CDATA[Trong Java, kiểu dữ liệu được chia làm hai loại:]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-31T00:00:00+00:00</published><updated>2021-08-31T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-30T00:00:00+00:00</published><updated>2021-08-30T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-29T00:00:00+00:00</published><updated>2021-08-29T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-28T00:00:00+00:00</published><updated>2021-08-28T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><category term="basic" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java OOP in Java OOP in Java OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java OOP in Java OOP in Java OOP in Java" /><published>2021-08-27T00:00:00+00:00</published><updated>2021-08-27T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-26T00:00:00+00:00</published><updated>2021-08-26T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>###</p>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><category term="basic" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry><entry><title type="html">OOP in Java</title><link href="https://anhdt2511.github.io/oop-in-java.html" rel="alternate" type="text/html" title="OOP in Java" /><published>2021-08-25T00:00:00+00:00</published><updated>2021-08-25T00:00:00+00:00</updated><id>https://anhdt2511.github.io/oop-in-java</id><content type="html" xml:base="https://anhdt2511.github.io/oop-in-java.html"><![CDATA[<p>Lập trình hướng đối tượng <strong>(Object Oriented Programming – OOP)</strong> là một trong những kỹ thuật lập trình rất quan trọng và sử dụng nhiều hiện nay. Hầu hết các ngôn ngữ lập trình hiện nay như Java, PHP, .NET, Ruby, Python… đều hỗ trợ OOP.</p>

<h2 id="i-what-is-oop">I. What is OOP</h2>

<p><strong>Lập trình hướng đối tượng (OOP)</strong> là một kỹ thuật lập trình cho phép lập trình viên tạo ra các đối tượng trong code - trừu tượng hóa các đối tượng trong cuộc sống vào trong code để tương tác - tính toán - xử lý.</p>

<h2 id="ii-oop-in-programming">II. OOP in programming</h2>

<p>Giả sử bạn đang muốn tạo ra một chiếc ô tô, vậy trước tiên bạn cần thiết kế ra một bản thiết kế của cái ô tô đó. Trong bản thiết kế đó sẽ phác thảo ra những thông tin, đặc điểm của chiếc ô tô cần có ví dụ như: tên, màu sắc, kích thước, trọng lượng… bên cạnh đó bạn cũng cần phải mô tả được những công dụng, thao tác, hành động mà chiếc ô tô đó có thể làm được.</p>

<p>Và khi bạn đã có bản thiết kế thì bạn có thể tạo ra chiếc ô tô, chiếc ô tô này sẽ có các đặc điểm và hành động giống y bản thiết kế.</p>

<p>Như trong cuộc sống, bạn chỉ cần có một bản thiết kế nhưng không vì vậy mà chỉ tạo được một chiếc ô tô - bạn có thể tạo ra được rất nhiều chiếc ô tô dựa trên một bản thiết kế và tất cả chiếc ô tô được tạo ra cùng một bản thiết kế thì đều có các đặc điểm và hành động giống nhau. Nhưng giá trị của những thông tin, đặc điểm sẽ có thể khác nhau hoặc trùng nhau ví dụ: có chiếc xe màu đỏ, có chiếc màu xanh, màu trắng…</p>

<p>Mỗi chiếc ô tô tạo ra được xem là một thực thể (có thực, đã được tạo ra trong thực tế) thể hiện của bản thiết kế.</p>

<h3 id="1-class">1. Class</h3>

<p>Vậy <code class="language-plaintext highlighter-rouge">class</code> trong Java là gì? Nó được xem như là một bản thiết kế các đối tượng (object) trong lập trình.</p>

<p>Một <code class="language-plaintext highlighter-rouge">class</code> là một kiểu dữ liệu (data type) bao gồm:</p>

<ul>
  <li><code class="language-plaintext highlighter-rouge">thuộc tính (Property - Attribute)</code>: thể hiện qua biến (variable)</li>
  <li><code class="language-plaintext highlighter-rouge">phương thức (Method)</code>: thể hiện qua hàm (function)
được định nghĩa từ trước.</li>
</ul>

<p>Khác với kiểu dữ liệu thông thường (nguyên thủy), một <code class="language-plaintext highlighter-rouge">class</code> là một đơn vị (trừu tượng) bao gồm sự kết hợp giữa các <code class="language-plaintext highlighter-rouge">thuộc tính</code> và các <code class="language-plaintext highlighter-rouge">phương thức</code>.</p>

<h3 id="2-object">2. Object</h3>

<p><code class="language-plaintext highlighter-rouge">class</code> bạn có thể hiểu nó như là khuôn mẫu, bản thiết kế thì <code class="language-plaintext highlighter-rouge">object</code> là một thực thể thể hiện (instance) dựa trên khuôn mẫu đó. Hay như ở bối cảnh trên, <code class="language-plaintext highlighter-rouge">object</code> chính là những chiếc ô tô được tạo ra từ bản thiết kế.</p>

<blockquote>
  <p>Trong lập trình, mặc định các <code class="language-plaintext highlighter-rouge">object</code> là khác nhau cho dù có cùng các giá trị <code class="language-plaintext highlighter-rouge">thuộc tính</code> và <code class="language-plaintext highlighter-rouge">phương thức</code> giống nhau.</p>
</blockquote>

<h2 id="iii-what-are-the-main-principles-of-oop">III. What are the main principles of OOP</h2>

<p>Lập trình hướng đối tượng có 4 tính chất đặc thù sau:</p>

<ul>
  <li>Tính đóng gói (Encapsulation)</li>
  <li>Tính kế thừa (Inheritance)</li>
  <li>Tính đa hình (Polymorphism)</li>
  <li>Tính trừu tượng (Abstraction)</li>
</ul>

<p>Khái niệm cơ bản:</p>

<ul>
  <li>
    <p><strong>Tính đóng gói</strong> nhằm bảo vệ đối tượng không bị truy cập từ code bên ngoài vào để thay để giá trị các thuộc tính hay có thể truy cập trực tiếp. Việc cho phép truy cập các giá trị của đối tượng tùy theo sự đồng ý của người viết ra lớp của đối tượng đó. Tính chất này đảm bảo sự bảo mật, toàn vẹn của đối tượng trong Java.</p>
  </li>
  <li>
    <p><strong>Tính kế thừa</strong> cho phép chúng ta cải tiến chương trình bằng cách kế thừa lại lớp cũ và phát triển những tính năng mới. Lớp con sẽ kế thừa tất cả những thành phần của lớp cha, nhờ sự chia sẻ này mới có thể mở rộng những đặc tính sẵn có mà không cần phải định nghĩa lại.</p>
  </li>
  <li>
    <p><strong>Tính đa hình</strong> có thể nói luôn tồn tại song song với tính kế thừa. Khi có nhiều lớp con kế thừa lớp cha nhưng có những tính chất khác nhau cũng gọi là đa hình, hoặc những tác vụ trong cùng một đối tượng được thể hiện nhiều cách khác nhau cũng gọi là đa hình. Tính đa hình là kết quả tất yếu khi ta phát triển khả năng kế thừa và nâng cấp chương trình.</p>
  </li>
  <li>
    <p><strong>Tính trừu tượng</strong> là một tiến trình chỉ nói ra tính năng của người dùng, các khái niệm được định nghĩa trong quá trình phát triển, bỏ qua những chi tiết triển khai bên trong. Tính trừu tượng cho phép người lập trình tập trung cốt lõi cần thiết của đối tượng thay vì quan tâm sự phức tạo bên trong hoặc cách nó hoạt động.</p>
  </li>
</ul>

<p>Trong các bài sau, chúng ta sẽ đi sâu và giải thích rõ hơn từng tính chất cụ thể ở trên và thực hiện code ví dụ minh họa - để có thể hiểu được những tính chất trên được thể hiện trong code như thế nào.</p>

<h2 id="iv-advantages-of-object-oriented-programming">IV. Advantages of object-oriented programming</h2>

<ul>
  <li>Dựa trên nguyên lý kế thừa, trong quá trình tạo - mô tả các <code class="language-plaintext highlighter-rouge">class</code> có thể loại bỏ những chương trình bị lặp, dư. Và có thể mở rộng khả năng sử dụng các <code class="language-plaintext highlighter-rouge">class</code> mà không cần thực hiện lại. Tối ưu và tái sử dụng code hiệu quả.</li>
  <li>Đảm bảo rút ngắn thời gian xây dựng hệ thống và tăng năng suất thực hiện.</li>
  <li>Sự xuất hiện của 2 khái niệm mới là <code class="language-plaintext highlighter-rouge">class</code> và <code class="language-plaintext highlighter-rouge">object</code> chính là đặc trưng của phương pháp lập trình hướng đối tượng. Nó đã giải quyết được các khuyết điểm của phương pháp lập trình hướng cấu trúc để lại. Ngoài ra 2 khái niệm này đã giúp biểu diễn tốt hơn thế giới thực trên máy tính.</li>
</ul>

<p>© Copyright</p>
<blockquote>
  <p>ANEST LEARNING<br />
Join us:     <a href="https://www.facebook.com/groups/anest.learning/">Facebook groups</a><br />
Website:   <a href="https://anest.dev">https://anest.dev</a></p>
</blockquote>]]></content><author><name>Tuấn Anh</name></author><category term="oop" /><category term="java" /><category term="oop" /><summary type="html"><![CDATA[ELI5: what is a neural network.]]></summary></entry></feed>