April 30, 2012

တတိယ ခြေလှမ်း XSL

XML ၏ Tag များကို အသုံးပြုခြင်းအားဖြင့် အချက်အလက်များ၏ အဓိပ္ပါယ်များနှင့်၊ ထူးခြားချက်များကို ဖော်ပြပေးနိုင်ပါသည်။ ယခင် အခန်းများဖြင့် ဖော်ပြပြီးသကဲ့သို့ XMLတွင် အချက်အလက်များကို ဖော်ပြရန်အတွက် Tag များကို လွတ်လပ်စွာ အသုံးပြုနိုင်၏။ ထို့အတွက် HTMLကဲ့သို့ ပိုင်ဆိုင်တဲ့ Tagတွေ အသီးသီးကို မည်သို့ ဖော်ပြမည် ဆိုသည်ကို ကြိုတင် သတ်မှတ်ထားခြင်း မရှိပေ။ သို့ရာတွင် XMLအချက်အလက်များကို ပြင်ဆင်ပြီးလှပစွာ ပုံဖော်၍ အသုံးပြုလိုသောအခါ ရှိပေမည်။ XML ဖြင့် ရေးသားထားသော အချက်အလက်များကို လှပသေသပ်စွာ ဖော်ပြနိုင်ရန် မည်သို့ပြုလုပ်ရမည် ဆိုသည့်အချက်သည် လိုအပ်ချက်တစ်ခု ဖြစ်လာခဲ့ပါသည်။

ထိုတာဝန်များကို ထမ်းဆောင်ပေးနေသည်မှာ XSL ဖြစ်ပေသည်။ XSLဆိုသည်မှာ Extensible Style sheet Language ရဲ့အတိုကောက် အခေါ်အဝေါ် ဖြစ်ပြီး၊ XML စာပိုဒ်များ၏ Styleကို သတ်မှတ်ပေးနိုင်သော ပညာရပ်တစ်ခု ဖြစ်၏။

နည်းပညာရပ် တစ်ခုဟု ဆိုသော်လည်း၊ အမှန်မှာမူ XSLသည် အောက်ပါ နည်းပညာရပ်များဖြင့် ဖွဲ့စည်း ထားပါသည်။
  • XML ရဲ့တည်ဆောက်ပုံကို ပြောင်းလည်းပေးသော XSLT (XSL Transformations)
  • XML စာပိုဒ် များ၏ အစိတ်အပိုင်း အတိအကျကို ရှာဖွေနိုင်သော XPath (XML Path Language)
  • အမြင်ပိုင်း ဆိုင်ရာ Styleကိုဖော်ပြပေးနိုင်သော XSLFO (XSL Formatting Objects)
XSL၏XSLFOသည် HTML၏CSSကဲ့သို့ နေရာတွင်တည်ရှိပေသည်။ ဤတတိယခြေလှမ်းတွင် XSLTကို အသုံးပြု၍၊ XMLအချက်အလက်များကို Web Browser များတွင် ဖော်ပြနည်း များကို တင်ပြသွားမည် ဖြစ်သည်။ သို့ရာတွင် XSLFO မှာ CSSဖြင့် အစားထိုးအသုံးပြုနိုင်သဖြင့် ဤအခန်းတွင်မှု အထွေအထူး ဖော်ပြတော့မည် မဟုတ်တော့ပါ။


XSL ၏ အခြေခံ သဘောတရား

XSL သည် အသုံးပြုလိုသည့် ဖိုင်အမျိုးအစား အပေါ်မှုတည်၍ အမျိုးအစားများကို ခွဲခြားထားပါသည်။ PDF ဖိုင်များကို ရေးသားရာတွင် PDF သုံး XSL ကို အသုံးပြုရန် လိုအပ်ပြီး၊ HTML ဖိုင်များအား အသုံးပြုရာတွင် HTML သုံး XSL ကို အသုံးပြုရန် လိုအပ်ပါသည်။ XSL များတွင် XSL processor များကို အသုံးပြုခြင်း အားဖြင့် XML အချက်အလက်များကို အသုံးပြုလိုသည့် အမျိုးအစား၏ တည်ဆောက်ပုံအဖြစ် ပြောင်းလည်း ပေးနိုင်ပါသည်။ ဥပမာ အားဖြင့် XML စာပိုဒ်အား HTML သုံးXSLကိုအသုံးပြုပါက HTMLအချက်အလက်အဖြစ် ပြောင်းလည်း ပေးနိုင်သလို၊ PDF သုံးXSLကိုအသုံးပြုပါက PDF အချက်အလက်များအဖြစ် ပြောင်းလည်းပေးနိုင်ပါသည်။



XSL Processor သည် အတော်များများသော Internet Explore တွင် ပါရှိပါသဖြင့်၊ ဤအခန်းတွင် ဖော်ပြသော နမှုနာများကို Internet Explore ကိုအသုံးပြု၍ လက်တွေ့ လေ့လာသွားမည် ဖြစ်သည်။


XSLT (XSL Transformation)

XML စာပိုဒ်တစ်ခု၏ အချက်အလက်များကို ဘယ်လိုပုံစံဖြင့်ဖော်ပြပါမည်ဆိုတဲ့ အချက်အလက်များကို ရေးသားထားခြင်းကို Style Sheet ဟုခေါ်ပါသည်။ ထို Style Sheet၏ File Typeသည် .xslဟုရေးသားဖို့ လိုအပ်ပါသည်။ သို့ရာတွင် Style Sheetကိုယ်တိုင်လည်း XMLရေးသားပုံအတိုင်း ရေးသားထားခြင်း ဖြစ်ပါသည်။ ဦးစွာ လက်တွေ့ ရေးသားပြီး ဘယ်လို ရေးသားရသည်ကို ရှင်းလင်း သွားပါမည်။


book.xml
<?xml version="1.0" encoding=”UTF-8” ?>
<?xml-stylesheet href="book.xsl" type="text/xsl"?>
<book-list>
    <book>
        <name>Head First Java</name>
        <price>$ 25.00</price>
    </book>
        <book>
        <name>Effective Java</name>
        <price>$ 42.09</price>
    </book>
    <book>
        <name>Head First Design Patterns</name>
        <price>$ 29.00</price>
    </book>
</book-list>
အထက်ပါ book.xmlတွင်အသုံးပြုသော Style Sheet သည်အောက်ပါ book.xslဖြစ်၏။
<?xml version=”1.0” encoding=”UTF-8” ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
    <xsl:template match="/">
        <html>
        <body>
        <table border="1">
        <tr><th>Book Name</th><th>Book Price</th></tr>
        <xsl:apply-templates select="booklist/book" />
        </table>
        </body>
        </html>
    </xsl:template>
    <xsl:template match="book">
        <tr>
        <td><xsl:value-of select="name" /></td>
        <td align="right"><xsl:value-of select="price" /></td>
        </tr>
    </xsl:template>
</xsl:stylesheet>
အထက်ပါ book.xmlကို Internet Explore ဖြင့် ဖွင့်ကြည့်မည် ဆိုလျှင် အောက်ပါအတိုင်း တွေ့မြင်ရပေမည်။


Style Sheet ကို အသုံးပြုခြင်း

အထက်ပါ book.xml ၏ ဒုတိယမြောက် စာကြောင်းသည် XML စာပိုဒ်အတွင်းတွင် XSL ကိုအသုံးပြုပါမည် ဟုသတ်မှတ်ချက် ပေးနေခြင်း ဖြစ်ပါသည်။ ထိုစာကြောင်းကို ရေးသားခြင်းအားဖြင့် XML စာပိုဒ်တွင် အသုံးပြုမည့် Style Sheet ကိုသတ်မှတ်ပြီး ဖြစ်စေပါသည်။ ရေးသားပုံမှာ အောက်ပါအတိုင်း ဖြစ်ပါသည်။
<?xml-stylesheet href="book.xsl" type="text/xsl" ?>

တဖန် Style Sheet ဖြစ်တဲ့ book.xsl ကို လေ့လာကြည့်ကြပါဆို့။ xsl သည်လည်း XML စာပိုဒ်တစ်မျိုး ဖြစ်သည့်အတွက် ပဋ္ဌမစာကြောင်းသည် XML Declaration ဖြစ်ပါသည်။ ဒုတိယ စာကြောင်းမှ စ၍ XML Instance ဖြစ်ပြီး stylesheet Tag ဖြင့် အစပြုထားပေသည်။

Namespace Uri အဖြစ် http://www.w3.org/1999/XSL/Transform ကိုအသုံးပြုပြီး၊ prefix အဖြစ် xsl ကို အသုံးပြုထားပါသည်။ ထိုစာကြောင်းသည် XSLT ကိုရေသားရာတွင် မရေးမဖြစ် ရေးသားရမည်ဖြစ်၏။ တနည်းဆိုသော် Stylesheet Element သည် XSLT၏ Root Element အဖြစ် မရှိမဖြစ်လိုအပ်ပါသည်။ ထိုမှတဆင့် ရေးသားလိုသော Style ကို Child Elements များအတွင်း ရေးသားရမည် ဖြစ်သည်။

Template Rule

စာကြောင်း နံပါတ်၃မှ ၁၇အထိသည် Template စည်းမျဉ်း များဖြစ်ကြ၏။ Template စည်းမျဉ်း ဆိုသည်မှာ XML၏အပိုင်းတစ်ခုကို ဘယ်လိုပုံစံပြောင်းရမည်ဟု သက်မှတ်ထားသော စည်းကမ်းများ ဖြစ်ကြ၏။ စာကြောင်းနံပါတ်၃သည် root node ရဲ့ဖော်ပြပုံပုံစံကို သတ်မှတ်နေ၏။ တဖန်စကြောင်း ၁၂မှစ၍ book node၏ ဖော်ပြပုံဖြစ်၏။ Template Rule Tag၏ရေးသားပုံမှာ အောက်ပါအတိုင်း ဖြစ်၏။
<xsl:template match="/"> <------ root node
…
<xsl:template match="book"> <------ single node
Template Tag၏ match attributeသည် လက်ရှိTemplateတွင်အသုံးပြုမည့် nodeကို Xpath ရေးသားပုံဖြင့် သတ်မှတ်ရပါမည်။ book.xslတွင် root node နှင့် book nodeအသီးသီးကို စာကြောင်း၃နှင့်၁၂တွင်သတ်မှတ်ထားပါသည်။

Template Rule ၏ အသုံးပြုပုံ

book.xsl၏ စာကြောင်းနံပါတ်၈ကို ကြည့်ပါ။ ထိုစာကြောင်းတွင် booklist/book Elementအတွက် Template Ruleကို အသုံးပြုနေပါသည်။ ဤစာကြောင်းသည် Root Node ၏ Template စည်းမျဉ်းအတွင်းရေးသားထားပါသဖြင့် Root Nodeကို Context Nodeအဖြစ်အသုံးပြုပြီး အသုံးပြုမည့် Node များကို ရည်ညွှန်း၍ ဖော်ပြရပါသည်။
<xsl:apply-templates select="booklist/book">
Book Elementl ၏ Template စည်းမျဉ်းများသည် စာကြောင်း၁၂ မှ ၁၇ အထိ ရေးသားထားပြီး XSLT က HTML အဖြစ် ပုံစံပြောင်းလိုက်သောအခါ အောက်ပါ အတိုင်း ပြောင်းလည်းသွားမည် ဖြစ်သည်။
<xsl:template match="/">
<html>
<body>
    <table border="1">
    <tr><th>Book Name</th><th>Book Price</th></tr>
    <!-- ဤနေရာမှ Book Node ၏ Template စည်းမျဉ်းတွင် သတ်မှတ်ထားသည့် အတိုင်းဖြစ်၏ -->
    <tr>
    <td><xsl:value-of select="booklist/book/name" /></td>
    <td><xsl:value-of select="booklist/book/price" /></td>
    </tr>
    </table>
</body>
</html>
</xsl:template>
book.xml ၏ Book Node များအား အထက်ပါ စီးမျဉ်းအတိုင်း ပုံစံပြောင်းပေးမည် ဖြစ်သည်။ book.xml ၏ စာအုပ် ၃အုပ်လုံးသည် အထက်ပါစည်းမျဉ်းအတိုင်း ပုံစံပြောင်း နေသည်ကို ကြည့်ရှုနိုင် ပါသည်။

Text Node များ

book.xsl ၏ စာကြောင်း၁၄နှင့် ၁၅ကိုကြည့်ပါ။ value-of Tag ကိုအသုံးပြုပြီး XML စာပိုက်၏ Text Node များကို ပုံစံပြောင်းပေးနေပါသည်။ XML စာပိုဒ်အတွင်းမှ select attribute တွင်သတ်မှတ်ထားသော Text Nodeအမည်ရှိသော Node များ၏တန်ဖိုးများအား ဤ Tag အတွင်းတွင် သက်မှတ်ထားသော စည်းမျဉ်းအတိုင်း ပုံစံပြောင်းပေး မည်ဖြစ်၏။
<xsl:value-of select="name">


xsl: Prefix မဟုတ်သော Tag များ

Template စာသားအတွင်းရှိ xsl ဖြင့် အစပြုသော Tag များနှင့် အခြားသော Tag များကိုလည်း တွေ့ရှိနိုင်မည် ဖြစ်သည်၊ xsl နှင့်အစမပြုသော အစိတ်အပိုင်းများသည် ပုံစံပြောင်းရန် မလိုအပ်သော အစိတ်အပိုင်းများ ဖြစ်ပြီး၊ ရေးသားထားသည့် အတိုင်း စာပိုဒ်အတွင်းတွင် ဖော်ပြသွားမည် ဖြစ်သည်။


XPath

XPath သည် XSL မှ XML စာပိုဒ်အတွင်းမှ အချက်အလက်များ၏ နေရာအတိအကျကို ဖော်ပြရာတွင် အသုံးပြုသော စနစ်တစ်ခုဖြစ်၏။ XPath မပါဝင်ပဲ XSLကိုအသုံးပြုနိုင်မည် မဟုတ်ပေ။ XPath သည်လည်း XML ဘာသာရပ် ကဲ့သို့ပင် သစ်ပင်ဖွဲ့စည်းပုံ (Tree Structure) ကို အသုံးပြုထားပါသည်။ XMLနှင့် ကွာခြားသည်မှာ Element အဆင့်မဟုတ်ပဲ၊ Nodeအဆင့်ဖြင့် သစ်ပင်ဖွဲ့စည်းပုံကို ဖွဲ့စည်းထားခြင်း ဖြစ်သည်။



Node အမျိုးအစားများ


Xpath တွင်XML၏ Element, Attributeနှင့်တန်ဖိုးများကို သီးခြား Nodeတွေအဖြစ် သတ်မှတ် ထားပေသည်။ Node အမျိုးအစားများကို အောက်ပါအတိုင်း ၄မျိုးခွဲခြား ထားပါသည်။

အမျိုးအစား ရှင်းလင်းချက်
Root Node XML စာပိုဒ်များတွင် မရှိမဖြစ်လိုအပ်သော တစ်ခုတည်းသော Nodeဖြစ်ပြီး၊ သစ်ပင်ဖွဲ့စည်းပုံ၏ ပင်မနေရာတွင် တည်ရှိသော Nodeဖြစ်ပါသည်။ အမြဲတမ်း / ဟုဖော်ပြလေ့ရှိပြီး၊ Nodeတွေအားလုံး၏ ပင်မြစ်ဖြစ်ပေသည်။ Root Node၏အောက်တွင် အမြဲတမ်း Root Element တစ်ခုတည်ရှိပေမယ့် ထိုElementနှင့် Root Node တို့သည် သီးခြား Node များ ဖြစ်ကြပါသည်။
Element Node XML စာပိုဒ်များ၏ Elementအမည်တွင် နေရာကျပေလိမ့်မည်။ အထက်ပါ ဥပမာတွင် company, employee, name, branchအစရှိသည့် Node များသည် Element Node များဖြစ်ကြပါသည်။
Attribute Node XML စာပိုဒ်များ၏ Attribute များ၏နေရာတွင် တည်ရှိပေသည်။ အထက်ပါဥပမာတွင် Age သည် Attribute Nodeဖြစ်၏။
Text Node XML စာပိုဒ်များ၏ Text Value များသည် Text Node များဖြစ်ကြ၏။


XPath Node


Xpath တွင် Nodeတစ်ခုရဲ့ အချက်အလက်ကို ဖော်ပြရာတွင် ထို Node ရဲ့ တည်နေရာကို ဖော်ပြပေးဖို့လိုအပ်ပါသည်။ Node တစ်ခု၏နေရာကိုဖော်ပြရာတွင် Node တစ်ခုနှင့် တစ်ခုအကြား / ကိုကြားခံ၍ ဖော်ပြရပါမည်။ ထိုသို့ဖော်ပြချက်ကို နေရာဖော်ပြချက် (Location Path) ဟု ခေါ်ပါသည်။ Node တစ်ခု၏ တည်နေရာကိုဖော်ပြပုံမှာ ၂မျိုးခွဲခြားနိူင်ပါသည်။ XML စာပိုဒ် တစ်ခုလုံး၏ နေရာအတိအကျကိုဖော်ပြပေးသော အတိအကျနေရာ(Absolute Location Path )နှင့်၊ လက်ရှိ Node မှ၊ ရောက်ရှိလိုသော Node ကိုညွှန်ပြသော နှိုင်းယှဉ်နေရာ (Relative Location Path) ဟူ၍ ရှိပေသည်။


အတိအကျနေရာ (Absolute Location Path)

Root Nodeနေရာမှ ဖော်ပြလိုသော Nodeအထိ လမ်းကြောင်းကို အတိအကျ နေရာဟုခေါ်ပါသည်။ အထက်ဖော်ပြပါပုံတွင် name Node၏ အတိအကျနေရာ ဖော်ပြချက်မှာ အောက်ပါ အတိုင်းဖြစ်သည်။

/company/employee/name


နှိုင်းယှဉ် နေရာ (Relative Location Path)

Node တစ်ခုမှ အခြားသော Node တစ်ခု၏ နေရာကိုနှိုင်းယှဉ်၍ ဖော်ပြရာတွင် အသုံးပြုပါသည်။ Node တစ်ခု၏အပေါ်တွင်ရှိသော Node ကို Parent Node ဟုခေါ်ပြီး၊ အောက်တွင်ရှိသော Node ကို Child Node ဟု ခေါ်ပါသည်။ သား၏သားNode များသည် Grand Child Node များဖြစ်ကြပါသည်။ ကဲ့သို့ ခေါ်အဝေါ်များကို XPath Axes ဟုခေါ်ပါသည်။



အမျိုးအစား ရှင်းလင်းချက်
ancestorကိုယ့်၏အထက်မှNode များ
ancestor-or-selfကိုယ်နှင့်ကိုယ့်၏အထက်မှNode များ
attributeကိုယ်ပိုင်ဆိုင်သောAttribute Node များအားလုံး
childကိုယ်၏သားအဆင့်ရှိChild Node များအားလုံး
descendantကိုယ်၏အောက်မှNode များ
descendant-or-selfကိုယ်နှင့်ကိုယ်၏အောက်မှNode များ
followingကိုယ်၏အနောက်မှရှိသောNode များအားလုံး
following-siblingကိုယ်၏အနောက်မှမိဘတူညီသော ညီအကို Node များအားလုံး
parentကိုယ်၏အထက်တွင်ရှိသောမိဘ Node
precedingကိုယ်၏အရှေ့မှ Node များအားလုံး
Preceding-siblingကိုယ့်ရှေ့မှမိဘတူညီသော ညီအကိုNode များအားလုံး
selfကိုယ်ကိုတိုင်

တဖန် XPath တွင် အတိုကောက် စာလုံးများကိုလည်း အသုံးပြု နိုင်ပေသည်။ အသုံးပြုနိုင်သော အတိုကောက် စာလုံးများမှာ အောက်ပါအတိုင်း ဖြစ်ပါသည်။

အမျိုးအစား ရှင်းလင်းချက်
/root
//descendant-or-self
.self
..parent
@Attribute


အမည်တူ Node များ

ဥပမာအားဖြင့် //name ဟု name ဟု အမည်ရသော node များကို ဖော်ပြသည့်အခါမျိုးတွင် နှစ်ခုထက်မက တည်ရှိပါက ခွဲခြားဖော်ပြရန် လိုအပ်ပါသည်။

Node ၏အမည် [နံပါတ်]

Diagram3.2.1၏ company node တွင် child nodeနှစ်ခုရှိပါသည်။ ဥပမာအားဖြင့် မင်းလွင် အမည်ရှိသော Node သည် employee [1] ဖြစ်၍၊ စည်သူဟုအမည် node ကိုပိုင်ဆိုင်သော node သည် employee [2] ဖြစ်သည်။ အခြားသော ပရိုဂရမ်မင်း ဘာသာရပ်များကဲ့သို့ 0 မှ အစမပြုသည်မှာ သတိထားစရာ အချက် တစ်ခုဖြစ်သည်။


XPath Functions

XPath တွင် xml အချက်အလက်များကို လိုအပ်သလို ပြုပြင်အသုံးပြုနိုင်ရန် Function များကို ပြင်ဆင်ထားပါသည်။ အောက်ပါ book.xml နမှုနာဖြင့် XPath Function များ၏အသုံးပြုပုံကို ဆက်လက်လေ့လာ သွားပါဦးမည်။
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="book.xsl" type="text/xsl"?>
<booklist>
    <book>
        <name>Head First Java</name>
        <price>25.00</price>
    </book>
    <book>
        <name>Effective Java</name>
        <price>42.09</price>
    </book>
    <book>
        <name>Head First Design Patterns</name>
        <price>29.12</price>
    </book>
    <book>
        <name>SQL Hacks</name>
        <price>18.36</price>
    </book>
    <book>
        <name>EJB 3.1</name>
        <price>31.00</price>
    </book>
    <book>
        <name>Seasor 2 Notes</name>
        <price>19.28</price>
    </book>
    <book>
        <name>Java Remote Interface</name>
        <price>29.03</price>
    </book>
</booklist>
အထက်ပါ book.xml ရှိ အချက်အလက်များအား အသုံးပြု၍ book.xsl ကို ရေးသားကြည့်ပါမည်။
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<h3>
Count of Books :
<xsl:value-of select="count(booklist/book)" /></h3>
<table border="1">
    <tr style="background-color:silver">
    <th>Book Name</th>
    <th>Book Price</th>
    </tr>
    <xsl:apply-templates select="booklist/book" />
    <tr style="background-color:silver">
    <td style="padding-left:10px"> Total price</td>
    <td style="text-align: right">
    <xsl:value-of select="sum(booklist/book/price)" />
    </td>
    </tr>
    </table>
    </xsl:template>
    <xsl:template match="book">
    <tr><td style="padding-left:10px;width:450px">
    <xsl:value-of select="name"></xsl:value-of></td>
    <td style="text-align: right">
    <xsl:value-of select="price"></xsl:value-of>
    </td></tr>
    </xsl:template>
</xsl:stylesheet>


Count Function


book.xsl၏ စာကြောင်းနံပါတ်၉ကိုကြည့်ပါ။ select attributeတွင် count(booklist/book) ဟုရေးသား ထားပါသည်။ ထိုစာကြောင်းတွင် count function ကိုအသုံးပြုပြီး၊ booklist ထဲမှ စာအုပ်များကို ရေတွက်နေပါသည်။


Sum Function


book.xsl ၏ စာကြောင်းနံပါတ်၂၀ကိုကြည့်ပါ။ select attribute တွင် sum(booklist/book/price) ဟုရေးသား ထားပါသည်။ sum function ကိုသုံးပြီး စာအုပ်ဈေးနှုန်းများ၏ စုပေါင်းဈေးနှုန်းကို တွက်ချက် ရယူပါသည်။

book.xml ကို web browserဖြင့် ဖွင့်ကြည့်သောအခါ အောက်ပါအတိုင်းတွေ့မြင်ရမည်ဖြစ်သည်။


အထက်ပါ count နှင့်sum အပြင် XPathတွင် အသုံးပြုရန် function များစွာရှိပါသည်။ အသုံးပြုသည့် အချက်အလက် များပေါ်တွင်မှုတည်ပြီး function များကို အဖွဲ့အစည်း ခွဲခြားထားပြီး၊ အသုံးများသော functions များမှာ အောက်ပါအတိုင်းဖြစ်၏။

အုပ်စုအမည် ဖန်ရှင်အမည် အသုံးပြုပုံ
Node Set Functions count (Node set) Node set၏ အရေအတွက်ကို သိလိုသည့်အခါမှာ အသုံးပြုရပါသည်။
id (Identifier Name) Identifier Name နှင့်တူညီသော id ကို ပိုင်ဆိုင်သော Element များကိုရှာဖွေ နိုင်ပါသည်။
last () လက်ရှိ Node၏ နောက်ဆုံးနေရာတွင် တည်ရှိသော Element ကို ရရှိနိုင်ပါသည်။
name (Node Set) Node Set ၏ name Attribute ၏ တန်ဖိုးကို သိရှိနိုင်ပါသည်။
position () လက်ရှိ Node၏ တည်နေရာကို ရရှိနိုင်ပါသည်။
String Functions concat (String1, String2, ...) စကားလုံးစုများကို ပေါင်းစပ်ရာတွင် အသုံးပြု ပါသည်။
substring (String, index, count) စကားလုံးစု String အား၊ indexနေရာမှစ၍ count စာလုံးမြောက်အထိ ဖြတ်ယူရာတွင် အသုံးပြုပါသည်။
substring-after (String1, String2) String1 အတွင်းရှိ String2 စာလုံး၏အနောက်ရှိ စကားလုံးများကို ဖြတ်တောက်ယူရာတွင် အသုံးပြု ပါသည်။
substring-before (String1, String2) String1 အတွင်းရှိ String2 စာလုံး၏အရှေ့ရှိ စကားလုံးများကို ဖြတ်တောက် ယူရာတွင် အသုံးပြု ပါသည်။
substring-length (String) စကားလုံးစု၏ စာလုံးအရေအတွက်ကို ရယူရာတွင် အသုံးပြုပါသည်။
translate (String1, String2, String3) မှုရင်း စာကြောင်း String1 အတွင်းရှိ String2 များကို String3 အဖြစ် ပြောင်းလည်း ဖော်ပြလိုသည့်အခါတွင် အသုံးပြု နိုင်ပါသည်။
Numeric Functions number (String) String စကားလုံးစုများမှ ကိန်းဂဏန်းအဖြစ် ပြောင်းလည်း ယူနိုင်ပါသည်။
round (Numeric) ကိန်းဂဏန်းကို အနီးစပ်ဆုံး အပြည့်ကိန်းများအဖြစ် ပြောင်းလည်းပေး နိုင်ပါသည်။
sum (Node Set)  Node set များ၏ စုစုပေါင်း ရလဒ်ကို တွက်ယူ နိုင်ပါသည်။

XPath Function များသည် XSL တွင်သာမက XML DB တွင် အသုံးပြုသော XQuery တွင်လည်း အသုံးပြုနိုင်ပါသည်။ အသေးစိတ်ကိုတော့ W3C ရဲ့ Web Page များတွင် လေ့လာနိုင်ပါသည်။ 
http://www.w3.org/TR/xpath-functions/


XPath Operators


အထက်ပါအခန်းများတွင် ဖော်ပြပြီးသည့်အတိုင်း XSL တွင် XPath ၏ဖော်ပြချက်များအပေါ်မှုတည်၍ သက်ဆိုင်ရာ Node များ၏ Style များကို ပြောင်းလည်းပေးခြင်း၊ တဖန် XPath ၏ Functions များကို အသုံးပြုပြီး သက်ဆိုင်ရာ Node များမှ လိုအပ်သော တန်ဖိုးများကို ပြောင်းလည်းယူခြင်းများကို ပြုလုပ်နိုင်ကြောင်း တင်ပြခဲ့ပါသည်။ တဖန် XPath ၏ ဖော်ပြချက်များကို လိုအပ်သလို အသုံးပြုနိုင်စေရန် Operators များကိုလည်း ပြင်ဆင်ထားပါသည်။ အသုံးပြုနိုင်သော Operators များမှာ အောက်ပါအတိုင်းဖြစ်၏။

အမျိုးအစား ရှင်းလင်းချက်
| Node Set များကို၊ ပေါင်းဆက်ရာတွင် အသုံးပြုပါသည်။
// book | //cd ဟုရေးထားမည်ဆိုလျှင်၊ current node ၏အောက်တွင်ရှိသော
book node များနှင့်၊ cd node များကို node setတစ်ခုအဖြစ်ရရှိမည် ဖြစ်သည်။
+ အပေါင်းလက္ခဏာ ဖြစ်ပါသည်။
count (//book) + count (//cd) ဟုရေးသားထားမည်ဆိုလျှင် စာအုပ်အရေအတွက်နှင့်
CDအရေအတွက်ကို စုစုပေါင်းအရေအတွက်ကို ရရှိမည်ဖြစ်သည်။
- အနှုတ်လက္ခဏာ ဖြစ်ပါသည်။
* အမြှောက်လက္ခဏာဖြစ်ပါသည်။
div အစားလက္ခဏာဖြစ်ပါသည်။
mod အကြွင်းကို ရလိုသည့်အခါတွင် အသုံးပြုနိုင်ပါသည်။
= တူညီခြင်းကို ဖော်ပြလိုသောအခါ အသုံးပြုနိုင်ပါသည်။
//book/price=39.00 ဟုရေးသားထားလျှင် book၏တန်ဖိုးသည် 39.00 ရှိသော
စာအုပ်များဟု အဓိပ္ပါယ်ရပါသည်။
!= မတူညီခြင်းကို ဖော်ပြလိုသောအခါ အသုံးပြုနိူင်ပါသည်။
//book/price=39.00 ဟုရေးသားထားလျှင် book၏တန်ဖိုးသည် 39.00 မဟုတ်သော
စာအုပ်များဟု အဓိပ္ပါယ်ရပါသည်။
< ပို၍သေးငယ်ခြင်း ကိုဖော်ပြပါသည်။
<= ပို၍သေးငယ်ခြင်း သို့မဟုတ် တူညီခြင်း ကိုဖော်ပြပါသည်။
> ပို၍ကြီးမားခြင်း ကိုဖော်ပြပါသည်။
>= ပို၍ကြီးမားခြင်း သို့မဟုတ် တူညီခြင်း ကိုဖော်ပြပါသည်။
OR သို့မဟုတ်။
A OR B ဟု ရေးသားထားပါက A သို့မဟုတ် B ဟု အဓိပ္ပါယ်ရပါသည်။
AND နှင့်။
A AND B ဟု ရေးသားထားပါက A နှင့် B ဟု အဓိပ္ပါယ်ရ ပါသည်။



အခြားသော XPath ဝါကျများ


IF ဝါကျ


အခြားသော Programming ဘာသာရပ်များကဲ့သို့ပင် if ကို အသုံးပြုနိုင်ပါသည်။ ဖော်ပြပါအနေအထား အတိုင်းပြည့်ဆုံမည် ဆိုလျှင် ရေးသားထားသော လုပ်ဆောင်ချက်များကို လုပ်ဆောင်သွားမည်ဖြစ်သည်။ သို့ရာတွင် သတိထားရမည်မှာ else ကဲ့သို့ အသုံးပြုချက်များမှာ XPath တွင်အသုံးပြု၍မရပေ။

world.xml
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="world.xsl" type="text/xsl" ?>
<world>
<country population="1338.29">China</country>
<country population="1182.42">India</country>
<country population="309.59">USA</country>
<country population="127.53">Japan</country>
<country population="42.642">Myanmar</country>
</world>

world.xsl
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<h3>Countries population is over 500 Million</h3>
<table>
    <tr>
        <th style="text-align:left">Country</th>
        <th>Population</th>
    </tr>
<xsl:apply-templates select="world/country" />
</table>
</xsl:template>

<xsl:template match="country">
<xsl:if test="./@population > 500">
<tr>
    <td width="250px">
        <xsl:value-of select="." />
    </td>
    <td>
        <xsl:value-of select="./@population" />
    </td>
</tr>
</xsl:if>
</xsl:template>

</xsl:stylesheet>

World.xsl၏ စာကြောင်း၁၇မှ ၂၆အထိသည် If ဝါကျကို အသုံးပြုထားသော နမှုနာဖြစ်သည်။ စာကြောင်း ၁၇တွင် <xsl:if test="./@population > 500"> ဟူ၍ If ဝါကျကိုရေးသားထား၏။ test attributeသည် If ဝါကျတွင် မရေးမဖြစ် ပါဝင်ရမည်ဖြစ်ပြီး အသုံးပြုမည့် ဖော်ပြချက်လည်းဖြစ်၏။ ". /@population > 500" သည် လက်ရှိ node၏ population attribute ရဲ့ တန်ဖိုးသည် 500 အထက်ဖြစ်လျှင်ဟု အဓိပ္ပါယ်ရပါသည်။ အကယ်၍ testအတွင်းကဖော်ပြချက်နှင့် ကိုက်ညီမည်ဆိုလျှင် IF ဝါကျ အတွင်းမှ ရေးသားထားသော သတ်မှတ်ချက်များအတိုင်း ပြောင်းလည်းပေးသွားမည်ဖြစ်သည်။ အထက်ပါ world.xml ကို web browserနှင့် ဖွင့်ကြည့်မည် ဆိုလျှင် အောက်ပါအတိုင်း တွေ့မြင်ရမည် ဖြစ်သည်။




Choose ဝါကျ


နှိုင်းယှဉ်ရန် အချက်အလက်သည် တစ်ခုထက်ပိုရှိပြီး၊ အချက်အလက်များကို ကိုယ်စီ လုပ်ဆောင်ချက် များကို ခွဲခြားပြီး ရေးသားလိုလျှင် အသုံးပြုနိုင်ပေသည်။ Choose node ၏ Child nodeဖြစ်သော When Node များတွင် အချက်အလက်များကို သီးခြားရေးသားနိုင်ပေသည်။ အခြားသော Programming ဘာသာရပ်များ၏ switch ဝါကျများနှင့် အသုံးပြုပုံ တူညီပေသည်။

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<h3>Choose Sample</h3>
<table width="60%">
<tr>
<th style="text-align:left">Country</th>
<th style="text-align:right">Population</th>
<th style="text-align:left;padding-left:60px">Type</th>
</tr>
<xsl:apply-templates select="world/country" />
</table>
</xsl:template>

<xsl:template match="country">
<tr>
<td>
    <xsl:value-of select="." />
</td>
<td style="text-align:right">
    <xsl:value-of select="@population" />
</td>
<td style="text-align:left;padding-left:60px">
    <xsl:choose>
    <xsl:when test="@population > 500">
        Over 500 Million
    </xsl:when>
    <xsl:when test="@population > 300">
        Over 300 Million
    </xsl:when>
    <xsl:otherwise>
        Under 300 Million
    </xsl:otherwise>
    </xsl:choose>
</td>
</tr>
</xsl:template>

</xsl:stylesheet>

If နမှုနာတွင် ရေးသားထားသော world.xsl အား အထက်ပါအတိုင်း ပြောင်းလည်း ရေးသားကြည့်ပါမည်။ စာကြောင်း၂၆မှ ၃၆ အထိသည် choose ဝါကျကို အသုံးပြုထားပါသည်။ When node အတွင်းမှ test သတ်မှတ် ချက်များနှင့် ပြည့်စုံလျှင် When အတွင်းတွင် ရေးသားထားသော လုပ်ဆောင်ချက် များအတိုင်း လုပ်ဆောင်သွားမည် ဖြစ်သည်။ တဖန် Whenလုပ်ဆောင်ချက်များနှင့် မပြည့်စုံပါက Otherwise nodeအတွင်းမှ လုပ်ဆောင်ချက်ကို လုပ်ဆောင်ပေးမည် ဖြစ်၏။




For Each ဝါကျ


Node List များမှ Node များကိုတစ်ခုပြီးတစ်ခု သတ်မှတ်ထားသည့် လုပ်ဆောင်ချက်များကို လုပ်ဆောင်စေလိုလျှင် for-each ကို အသုံးပြုရမည် ဖြစ်သည်။ အခြားသော Programmingဘာသာရပ်များမှ while သို့မဟုတ် for ဝါကျနှင့် ဆင်တူပါသည်။
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<h3>For Each sample</h3>
<table width="50%">
<tr>
    <th style="text-align:left">Country</th>
    <th style="text-align:left">Population</th>
</tr>

<xsl:for-each select="world/country">
<tr>
    <td>
        <xsl:value-of select="." />
    </td>
    <td>
        <xsl:value-of select="@population" />
    </td>
</tr>
</xsl:for-each>

</table>
</xsl:template>

</xsl:stylesheet>
wrold.xsl file ကို အထက်ပါအတိုင်း ပြောင်းလည်း ရေးသားပြီး Web Browserဖြင့် ဖွင့်ကြည့်မည် ဆိုလျှင် အောက်ပါအတိုင်း တွေ့မြင်ရမည် ဖြစ်သည်။




Sort လုပ်ခြင်း


ဖော်ပြပုံ အချက်အလက်များကို အစီအစဉ်တကျ ပြောင်းလည်း စီစဉ်လိုပါက Sort ဝါကျကို အသုံးပြုရမည် ဖြစ်သည်။ Sort Elementသည် <xsl:apply-templates> သို့မဟုတ် <xsl:for-each> Element များနှင့် တွဲဖက်၍ အသုံးပြုလေ့ရှိပါသည်။ Sort element တွင် သတ်မှတ်နိုင်သော Attribute များမှာ အောက်ပါ အတိုင်း ဖြစ်၏။

အမည် ရှင်းလင်းချက်
select အစီအစဉ်ပြောင်းလည်းရာတွင် အသုံးပြုမည့် Node Setကို ရေးသားရမည်။
lang အစီအစဉ်ပြောင်းလည်းရာတွင် အသုံးပြုမည့် ဘာသာရပ် ကို ရေးသားရမည်။
data-type အစီအစဉ်ပြောင်းလည်းရာတွင် အသုံးပြုမည့် အချက်အလက်ပုံစံကို ရေးသားရမည်။
  • text : စာလုံးပုံစံ အချက်အလက်
  • number : ကိန်းဂဏာန်းပုံစံ အချက်အလက်
order အစီအစဉ်ပြောင်းလည်းရာတွင် အသုံးပြုမည့် စာစီစဉ်ကို ရေးသားရမည်။
  • ascending : တက်စဉ်
  • descending : ကျစဉ်
case-order အချက်အလက်ပုံစံသည် text ကို အသုံးပြုမှသာလျှင် အသုံးပြုနိုင်မည် ဖြစ်သည်။
  • upper-first : စာလုံးအကြီးကို ဦးစွာဖော်ပြပါမည်။
  • lower-first : စာလုံးအငယ်ကို ဦးစွာဖော်ပြပါမည်။
ကျွှန်တော်တို့ For Each နမှုနာတွင် ရေးသားထားသော xsl ကို အနည်းငယ် ပြုပြင် ရေးသားကြည့်ပါဦးမည်။
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">
<h3>For Each sample</h3>
<table width="50%">
<tr>
    <th style="text-align:left">Country</th>
    <th style="text-align:left">Population</th>
</tr>

<xsl:for-each select="world/country">
<xsl:sort select="." data-type="text" order="ascending"/>
<tr>
    <td>
        <xsl:value-of select="." />
    </td>
    <td>
        <xsl:value-of select="@population" />
    </td>
</tr>
</xsl:for-each>

</table>
</xsl:template>

</xsl:stylesheet>

စာကြောင်း နံပါတ် ၁၄ကို ဖြည့်စွက်ရေးသားပြီး Sort လုပ်စေပါသည်။ ရေးသားထားသော world.xml ကို Double Click လုပ်၍ IE ဘရောင်ဇာ၏ ရလဒ်ကို ကြည့်ပါက အောက်ပါအတိုင်း အစီအစဉ်ကို ပြန်ပြောင်းပေးနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။



Attribute များအား ပြောင်းလည်းသတ်မှတ်ခြင်း

xslတွင် ပြောင်းလည်းရန် Element များကပိုင်ဆိုင်သော Attributes များ၏ တန်ဖိုးများကို သတ်မှတ် ပေးနိုင်ပါသည်။ ထိုအခါတွင် အသုံးပြုသော ဝါကျမှာ attributeဖြစ်၏။
attr.xml
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="attr.xsl" type="text/xsl" ?>
<pages>
 <page url="http://caloricp.jp/apc/sscp/K1006CAL/top.html">Caloricp</page>
 <page url="http://www.ajinomoto.co.jp/aji/egg/generator2/">Ajinomoto</page>
 <page url="http://manifani.com/">Manifani</page>
 <page url="http://www.brucke.co.jp/kolok/">Brucke</page>
 <page url="http://aikohno.com/">Aikohno</page>
 <page url="http://www.premacy.mazda.co.jp/pre/">Masada Premacy</page>
</pages>

attr.xsl
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<h3>Web Pages That I Like</h3>
<ol>
<xsl:for-each select="pages/page">
<li>
    <a>
        <xsl:attribute name="href">
        <xsl:value-of select="@url" />
        </xsl:attribute>
        <xsl:value-of select="." />
    </a>
</li>
</xsl:for-each>
</ol>
</xsl:template>
</xsl:stylesheet>

အထက်ပါ attr.xsl၏ စာကြောင်းနံပါတ်၁၀မှ ၁၂အထိသည် Attribute ကိုသတ်မှတ်ပေးသော ဝါကျဖြစ်၏။ စာကြောင်း၉တွင်ရေးသားထားသော Element <A> ၏ hrefဟု အမည်ရသော Attrubute ၏ တန်ဖိုးကို သတ်မှတ်ပေးနေပါသည်။ တန်ဖိုးမှာ စာကြောင်းနံပါတ် ၁၁ တွင် ရေးသား ထားသည့်အတိုင်း လက်ရှိ Node၏ url Attribute၏ တန်ဖိုးဖြစ်၏။

ထိုသို့ရေးသားထားခြင်းအားဖြင့် <A> element ၏ href attribute တန်ဖိုးတွင် page node ၏ url attribute ၏ တန်ဖိုးကို အစားထိုးဖော်ပြပေးနိုင်ပါသည်။

attr.xml file ကို web browserဖြင့် ဖွင့်ကြည့်သောအခါ အောက်ပါအတိုင်း တွေ့မြင်ရ မည်ဖြစ်၏။



ပြန်လည် သုံးသပ်ချက်


ဤ XMLဆီသို့ခြေလှမ်းများရဲ့ တတိယခြေလှမ်းဖြစ်တဲ့ အခြေခံXSL တွင် XSLTကိုအသုံးပြုပြီး XML စာပိုဒ်များ ၏ တည်ဆောက်ပုံကို အခြားသောတည်ဆောက်ပုံအဖြစ် ပြောင်းလည်းနိုင်ပုံကို ဖော်ပြခဲ့ပါသည်။ 

ဤအခန်းတွင် HTMLသို့ပြောင်းလည်းပုံကို အဓိကထားဖော်ပြခဲ့ပေမယ့်၊ XML စာပိုဒ်အတူတူခြင်း ဖြစ်လင့်ကစား Style Sheetကို ပြောင်းလည်းခြင်းအားဖြင့် ပုံစံတစ်မျိုးဆီသို့ ပြောင်းလည်းပေးနိုင်ကြောင်း နားလည်နိုင်ပေလိမ့်မည်။ ယခုအခန်းတွင်XSLT Processorအဖြစ် Internet Exploreကို အသုံးပြုခဲ့ပါသဖြင့် ပြောင်းလည်းပြီးနောက် အချက်အလက်များ ကိုပြန်လည် အသုံးပြုခြင်းမရှိခဲ့ပေးမယ့်၊ Jax သို့မဟုတ် Xalan ကဲ့သို့ XSLT Processor များကို အသုံးပြုပါက ပြောင်းလည်းပြီးသော အချက်အလက်များ File အဖြစ် ထုတ်ပြန်ပေးနိုင်ပါလိမ့်မည်။ တဖန် Style Sheet၏ ရေးသား  ပုံပေါ်မှုတည်ပြီး CSV ပုံသဏ္ဍာန် အဖြစ်ရေးသားနိုင်ပါသဖြင့် XMLအချက်အလက်များကို Microsoft Excel များမှ တဆင့် အသုံးပြုနိုင်မည်ဖြစ်သည်။

နောက်အခန်းများတွင် DOM, SAX APIကိုအသုံးပြု၍ XMLအချက်အလက်များကို Java Program မှတဆင့် အသုံးပြုပုံများကို ဆက်လက်ဖော်ပြသွားမည် ဖြစ်သည်။

Class နဲ့ Instance ကို​ကွဲ​အောင်​လုပ်​ပါ

Java ကို​လေ့​လာ​ရာ​တွင် ဦးစွာ​တွေ့​ကြုံ​ရ​မည့် အခက်​အခဲ​များ​ကတော့ Classဆို​တာ​ဘာ​လဲ၊ ပြီး​တော့ Instanceဆို​တာ​ဘာ​လဲ ဟုခေါ်​သော မေးခွန်း​များ​ဖြစ်​ကြ​ပါ​သည်။ ဤ Javaကို​အမြန်​ဆုံး​လေ့​လာ​ခြင်း အခန်း​ဆက် ဘ​လော့​ထဲ​မှာ​တော့ Object Oriented Programming ရဲ့​အမြင်​က မဟုတ်​ပဲ၊ Memoryပေါ်​က Program တစ်​ခုပေါ်​တွင် တည်​ရှိ​သော အမြင်​ပိုင်း​ဆိုင်​ရာ ရှု့​ထောင့်​မှ Classနဲ့ Instance တို့​ရဲ့ ကွဲ​ခြား​ချက်​တွေ​ကို လေ့​လာ​သွား​ပါ​မည်။
Class ဆို​သည်မှာ အဲ့​ဒီ​အစု​အစည်း​ရဲ့ တန်ဖိုး​တွေ​ကို​သတ်​မှတ်ရန်အတွက် အချက်အလက်များ (Field)နဲ့၊ လုပ်ဆောင်​ချက် (Method)များ​ကို စုစည်း​ထား​တဲ့ အစု​အစည်း​တစ်​ခု​လို့​သတ်​မှတ်ထား​၏။ ဤ​ရှင်းလင်း​ချက်​ကို ကြည့်​ရုံဖြင့် Class နဲ့ Instance ကို​ကွဲပြား​ပြီး သိရှိ​နိုင်​မည်​မဟုတ်​ပေ။ ဤသို့ဆိုလျှင် Class နဲ့ Instance ကွာခြားချက်သည် အဘယ်နည်း ဟုမေးစရာရှိပါမည်။ Java နှင့် ပတ်သက်သော စာအုပ်ပေါင်းများစွာတွင် နားလည်လွယ်စေရန် နည်းအမျိုးမျိုးဖြင့် ရှင်းပြထားလေ့ရှိ၏။ ကျွှန်တော်အနှစ်အသက်ဆုံး အဖြေမှာ ကွန်ပျူတာ Memory အပေါ်တွင် ဖြစ်ပေါ်လာပုံ၏ ဒါ​မှ​မဟုတ် ဇာစ်​မြစ် ဟာ​ကွဲပြားခြားနားသည် ဟူသော ရှင်းလင်းချက်ပဲ ဖြစ်ပါသည်။

Class ရဲ့ ဇာစ်​မြစ်​သည် .java ဖိုင်​ကို Compileလုပ်​ပြီး၊ ရ​ရှိ​လာ​တဲ့ .class ဖိုင် ဖြစ်​ပါ​သည်။ Program တစ်​ခု​မှ Class ကို​ဆက်​သွယ် အသုံးပြု​မည် ဆို​လျှင် .class ကို​ဖတ်​ယူ​ပြီး Memoryပေါ်​တွင် Class အဖြစ် နေရာ​ချထား​ပါ​မည်။ တ​ဖန် Instance သည် Memoryပေါ်​တွင် တည်​ရှိ​ပြီး​ဖြစ်​သော Class ကို​အသက်​သွင်း​၍ Memory ပေါ်​မှ​အခြား​သော​နေရာ​တွင် ဖြစ်ပေါ်​လာ​စေ​ပါ​သည်။ မှတ်​ရန်​အချက်​မှာ Classသည် .class ဖိုင်​တစ်​ခု​မှ တစ်​ကြိမ်​တည်း​သာ ဖတ်​ယူ​မွေး​ဖွား​ပြီး၊ Instanceသည် Memory ပေါ်​တွင်​တည်​ရှိ​ပြီး​ဖြစ်​သော Class မှ Memory ရှိ​သ​လောက် အကြိမ်ကြိမ် ကူး​ယူ​မွေး​ဖွား​နိုင်​ခြင်း ဖြစ်​ပေ​သည်။

အမြန်​မှတ်ချက်

Class နှင့် Instanceတို့​သည်၊ တန်ဖိုး​နှင့် လုပ်ဆောင်​ချက်​များ​ကို စုစည်း​ထား​သည့်​အချက်​မှာ တူညီ​ကြ​ပေ​သည်။ သို့ရာတွင် Class သည် .class ဖိုင်​မှ တစ်​ကြိမ်​တည်း​သာ ဖတ်​ယူ​မွေး​ဖွား​ပြီး၊ Instanceသည် Memoryပေါ်​တွင်​တည်​ရှိ​သော Classမှ​တစ်​ဆင့် အကြိမ်ကြိမ် ကူး​ယူ​မွေး​ဖွား​နိုင်​ခြင်း တို့​က​ကွဲပြား​ချက်​တို့ ဖြစ်​ကြ​ပါ​သည်။


သည်လို​ဆို​ရင်Classနဲ့Instanceကို ဘယ်​လို​ခွဲ​ခြား​ပြီး အသုံး​ချ​သင့်​တယ်​ဆို​တာ​ကို လက်တွေ့Codeကို​ရေး​ပြီး လေ့​လာ​ကြည့်​ရအောင်။ အောက်​ပါ န​မှု​နာ​တွေ​ကို​ကြည့်⁠ကြည့်​ကြ​ပါ။ အသီး​သီး class A နဲ့ Bကို​ရေးသား​ထား​ပြီး TestClassမှ​နေ ခေါ်​ယူ​အသုံးပြု​ထား​ပါ​သည်။ class A နဲ့ Bတို့​ရဲ့ ကွဲပြား​ချက်​ကို​လေ့​လာ​ကြည့်​ကြ​ပါ​ဆို့။
class A
public class A {
    static int i;
    static int getTwice() {
        return i*2;
    }
}
class B
public class B {
    int i;
    public int gatTwice() {
        return i * 2;
    }
}

Class AရောBပါ၊ ကိုယ်စီ Member Fieldအနေ​နဲ့ int i ကို​ပိုင်ဆိုင်​ပြီး၊ လုပ်ဆောင်​ချက် int တန်ဖိုး​ကို​ပြန်​ပေး​တဲ့ getTwice methodကို ပိုင်ဆိုင်​ကြ​ပါ​တယ်။ class A ရဲ့ i နဲ့ getTwice() ဟာ Classကို​တိုက်ရိုက်​ဆက်​သွယ်​ပြီး အသုံးပြု​နိုင်​ဖို့​အတွက် အရှေ့​မှာ staticဆို​ပြီ သတ်​မှတ်ချက်​ကို ရေးသား​ရ​ပါ​တယ်။ အဲ့​ဒီ​လို​ရေးသား​ထား​တဲ့ Fields တွေ​နဲ့ method တွေ​ကို static field, static methodဆို​ပြီး ခေါ်ဝေါ်​လေ့​ရှိ​ပါ​တယ်။
တ​ဖန် class B မှာ​ရှိ​တဲ့ field နဲ့ method တွေ​ရဲ့​ရှေ့​မှာ static ဆို​တာ​မ​ရေးသား​ထား​ပါ​ဘူး။ အဲ့​ဒါ​ဟာ class B မှ​တ​ဆင့် ပွား​ယူ​နိုင်​တဲ့ instanceတွေ​မှ​တ​ဆင့် အသုံးပြု​စေ​နိုင်​ဖို့​အတွက် ဖြစ်​ပါ​တယ်။ အဲ့​ဒီ​အတွက် instance field, instance method ဆို​ပြီးခေါ်ဝေါ်​လေ့ ရှိ​ပါ​တယ်။
class Test
public class Test {

    public static void main(String [] args) {
        A.i = 10;
        System.out.println("Twice Of Class A : " + A.getTwice());

        B b = new B();
        b.i = 10;
        System.out.println("Twice of Instance b : " + b.gatTwice());
    }
}
Test Classထဲ​မှာ​တော့ class A နဲ့ B တို့​ရဲ့ အသုံးပြု​ပုံ​တွေ​ကို ဖော်​ပြ​ပေး​နေ​ပါ​တယ်။ A.i ဆို​တဲ့ class field i ရဲ့​တန်ဖိုး​ကို 10ဆို​ပြီး​သတ်​မှတ်​နေ​ပါ​တယ်။ ပြီး​သော​အခါ A.getTwice()ဆို​ပြီး A class ရဲ့ getTwiceလုပ်ဆောင်​ချက်​ကို ခေါ်​ယူ​ပြီး system consoleမှာ​ရေးသား​စေ​ပါ​တယ်။ A class ရဲ့ i နဲ့ getTwice ကို static အနေ​နဲ့ သတ်​မှတ်ထား​တဲ့​အတွက် class A မှ တိုက်ရိုက်​အသုံး​ချ​နိုင်​ခြင်း ဖြစ်​ပါ​တယ်။
တ​ဖန် class B ရဲ့ instance b ကို B b = new B(); ဆို​ပြီး သတ်​မှတ်​ပေး​နေ​ပါ​တယ်။ နောက်​တစ်​ကြောင်း​တွင် b.i = 10ဆို​ပြီး instance b ရဲ့ i ရဲ့​တန်ဖိုး​ဟာ 10 ဖြစ်​ပါ​တယ် လို့​သတ်​မှတ်​နေ​ပြန်​တယ်။ ဆက်​ပြီး instance methodဖြစ်​တဲ့ b.getTwiceကိုခေါ် ပြီး System Consoleမှာ ရေးသား​နေ​ပါ​တယ်။ b instance မှ​နေ​အသုံးပြု​နိုင်​ရန် အတွက် သူ့​ရဲ့ Field နဲ့ methodရဲ့​ရှေ့​မှာ staticဆို​တာ မ​ရေးသား​ထား​ပါ​ဘူး။ အဲ့​ဒီ​လို instance field နဲ့ instance method တွေ​ရှိ​တဲ့​အတွက် B classရဲ့ instance b မှ​တ​ဆင့် အသုံးပြု​နိုင်​ခြင်း​ဖြစ်​ပါ​တယ်။

အမြန်​မှတ်ချက်

Class ရဲ့ static field နဲ့ static methodတွေ​ဟာ memory ပေါ်​မှာ တစ်​ကြိမ်​တည်း​သာ ဖြစ်​တည်​တယ်​ဆို​တဲ့ ထူးခြား​ချက်​ကို အသုံး​ချ​ပြီး Class field နဲ့ လုပ်ဆောင်​ချက် တွေ​ကို​ရေးသား​သင့်​ပါသည်။


တ​နည်း​တွေး​ကြည့်​ကြ​ရအောင်။ class A ကို​ရော instance မ​လုပ်​နိုင်​ဘူး​လား။ လုပ်​နိုင်​ပါ​တယ်။ ဒါ​ပေ​မယ့် class A မှာ static field နဲ့ static method သာ​ပိုင်ဆိုင်​ပြီး insatance fieldတွေ methodတွေ မ​ပါ​တဲ့​အတွက် သူ့​ရဲ့ instance ကို​ပွား​ယူ​လုပ်​အောင် အဓိပ္ပါယ်​မ​ရှိ​နိုင်​ပါ​ဘူး။
ဒါ​ဖြင့် Classလည်း​အဲ​လုပ်​လို့​ရ​တယ်၊ instanceလည်း​အလုပ်​လုပ်​လို့​ရ​တယ်။ ဘာ​လို့ instanceက​လို​အပ်​ရ​တာ​လဲဆို​တာ​ကို စဉ်းစား​ကြည့်​ကြ​ရအောင်။ အောက်​ပါ Personဆို​တဲ့ Classကို​ကြည့်​ပါ။ name နဲ့ ageဆို​တဲ့ instance fieldကို​ပိုင်ဆိုင်​ပြီး introdude() ဆို​တဲ့ instance methodရယ် Person(String name, int age)ဆို​တဲ့ constructor ကို​ပိုင်ဆိုင်​ပါ​တယ်။ Constructorဟာ instance တွေ​ကို ပွား​ယူ​တဲ့​အခါ​မှာ အမြဲ​တမ်းခေါ်​ယူ​ခံ​ရ​မည့် လုပ်ဆောင်​ချက်​တစ်​ခု​ဖြစ်​ပါ​တယ်။ Classမှ​တ​ဆင့် instanceကို လုပ်​ယူ​တဲ့​အခါ​မှာ လုပ်ဆောင်​ရ​မည့် လုပ်ဆောင်​ချက်​ဆို​ရင်​လည်း မ​မှား​နိုင်​ပါ​ဘူး။
သည်Person Constructor ကတော့ String name နဲ့ int age ကို Argumentအနေ​နဲ့ လက်ခံ​ရ​ယူ​ပြီး၊ instance member ဖြစ်​ကြ​တဲ့ name နဲ့ ageမှာ အသီး​သီး အစားထိုး​သတ်​မှတ်​နေ​ပါ​တယ်။ ပြီး​တော့ လုပ်ဆောင်​ချက် introduceထဲ​မှာ​တော့ သူ့​ရဲ့ name နဲ့ ageကို System Consoleမှာ ရေးသား​ပြ​နေ​ပါ​တယ်။
class Person
public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.print("My name is " + name);
        System.out.println(" and I am " + age + "years old.");
    }
}
အောက်​ပါ Test class ထဲ​မှာ​တော့ Person ရဲ့ a instance နဲ့ b instance ကို​လုပ်​ယူ​ပြီး အသီး​သီး​ရဲ့ introduceလုပ်ဆောင်​ချက်​ကို လုပ်ဆောင်​စေ​ပါ​တယ်။

classTest
public class Test {   
    public static void main(String [] args) {

        Person a = new Person("Aung Aung", 30);
        Person b = new Person("Thida", 24);
        a.introduce();
        b.introduce();
    }
}
အထက်​ပါ Test Classကို Run ကြည့်​မည်​ဆို​ပါ​က System Console မှာ အောက်​ပါ​အတိုင်း စာ​ကြောင်း​များ​က ထွက်ပေါ်​လာ​ပါ​လိမ့်​မည်။
My name is Aung Aung and I am 30years old.
My name is Thida and I am 24years old.
အထက်ပါ န​မှု​နာ​ကို​ကြည့်​ခြင်း​အား​ဖြင့် Classတစ်​ခု​မှ မ​တူညီ​သော​တန်ဖိုး​များ​နှင့် မ​တူညီ​သော Instanceများ​ကို အကြိမ်ကြိမ် လုပ်​ယူ​နိုင်​တယ် ဆို​တာ​ကို သိရှိ​နိုင်​ပါ​တယ်။


အမြန်​မှတ်ချက်

Constructorမှ​တ​ဆင့် ပုံစံ​ချ​ယူ​ခြင်း​အား​ဖြင့် Class တစ်​ခု​မှ​နေ Instanceကို အကြိမ်ကြိမ်​ပွား​ယူ​နိုင်​ပါ​သည်။


အလွယ်​ဆုံး​ပြော​ရ​မည်​ဆို​လျှင် Classနဲ့ Instance ဟာ ဒယ်အိုး​နဲ့ ဘိန်း​မုန့်​လို​ပါ​ပဲ။ ဒယ်အိုး​တစ်​လုံး​လို​ပဲ Classဟာ​တစ်​ခု​တည်း​ရှိ​ပြီး၊ ဒယ်အိုး​ထဲ​မှာ​ပါဝင်​တဲ့ အစာ​တွေ​ကို အမျိုး​မျိုး​ပြောင်း​ထည့်​ပြီး၊ ထော​ပါတ်​ဘိန်း​မုန့်​တွေ ရိုး⁠ရိုး​ဘိန်း​မုန့်​တွေ​ကို ဖုတ်​ယူ​နိုင်​သ​လို၊ Classတစ်​ခု​မှ တန်ဖိုး​အမျိုး​မျိုး​ပြောင်း​လည်း​ပြီး Instanceတွေ​ကို အမျိုး​မျိုး​လုပ်​ယူ​နိုင်​ပါ​တယ်။
Class နဲ့ Instanceတို့​ရဲ့ ကွဲ​ခြား​ချက်​ကို​သိရှိ​ပြီး Javaဆန်​တဲ့ Codeများ​ကို​ရေးသား​သွား​ကြ​ပါ​ဆို့။

April 29, 2012

Class နှင့် Method

အခြေခံ ပရိုဂရမ်မင်း ခေါင်းစဉ်ဖြင့် Java ပရိုဂရမ်မင်း၏ အခြေခံသဘောတရားများကို ဖော်ပြခဲ့သည်မှာ ၅ကြိမ်မြောက်ရှိပြီ ဖြစ်၏။ Script ဘာသာရပ်များဆိုလျှင် ဤအခြေအနေလောက်ဆိုလျှင် တော်ရုံ ပရိုဂရမ်များ စရေးနိုင်ပြီထင်၏။ သို့ရာတွင် Java မှာမူ မရေးနိုင်သေးပေ။ ကိန်းများ၊ သင်္ကေတများနှင့် ကွန်တရိုးများရလျှင် တော်ရုံ လော့ဂျစ်များကို စဉ်းစားနိုင်မည် ဖြစ်၏။ သို့ရာတွင် ဤအရာမှာ နိုင်ငံခြားဘာသာစကား သင်စလူတစ်ယောက်နှင့် တူ၏။ အရမ်းလည်းပြောချင်နေပြီ။ သို့ရာတွင် တစ်ခုခုလိုနေသလို။ ပြန်စဉ်းစားကြည့်မည် ဆိုလျှင် ဤပြောလိုစိတ်သည် အလွန်အရေးကြီးပါသည်။

ကျွှန်တော် တက္ကသိုလ် ပဋ္ဌမနှစ် တက်တုန်းက အကြောင်းကို ပြန်စဉ်းစားမိပါသည်။ Java အတန်းတက်ရင်း တစ်ရက် ကျောင်းပြေးမိပါသည်။ မှတ်မှတ်ရရ မက်သတ်အကြောင်းကို သင်သည့်အချိန်ဖြစ်၏။ void ဆိုတာဘာလည်း၊ return ဆိုတာဘာလည်း။ ကောင်းကောင်းနားမလည်ပါ။ နောက်တစ်ခေါက် ကျောင်းတက်ချိန်တွင် ရုတ်တရက် ဆရာက ပုဒ်စာတစ်ခုချပေးပါသည်။ မက်သတ်ကိုသုံးပြီး၊ ပါရာမီတာအလိုက် လုပ်ဆောင်ပုံများကို အမျိုးမျိုးခွဲစေနိုင်သော ပုဒ်စာဖြစ်ပါသည်။ သို့ရာတွင် ကျွှန်တော်မှာ ပြီးခဲ့တဲ့အပါတ်က ကျောင်းပြေးမိပါသဖြင့် နားမလည်လိုက်ပါ။ မက်သတ်ကို ဘယ်လိုသုံးရမှန်းမသိ။ ဒါပေမယ့် ကွန်တရိုးတွေနဲ့ ကိန်းကိုသိပါသည်။ ပြီတော့ main ထဲကနေ ပြီးခဲ့တဲ့သင်ခန်းစာတွေတုန်းက ရေးဘူးပါသည်။ ကဲမထူးဘူးဆိုပြီး၊ ရှိသမျှခေါင်းထဲက အကြံတွေထုတ်ပြီး ဖြစ်အောင်ရေးခဲ့ပါသည်။ ပြီးတော့ ဆရာက ခေါ်ပြီး ဘာလို့ မက်သတ်ကို မသုံးတာလဲဟုမေးသည်။ ကျွှန်တော်က မက်သတ်ဆိုတာဘာလဲ ဟုပြန်မေးပါသည်။ အဲ့ဒီမှာ ကျောင်းပြေးတာပေါ်ပါတော့သည်။ ဒါပေမယ့် အားလုံးရဲ့စာစစ်ပြီးတဲ့အချိန်မှာ ဆရာက ကျွှန်တော်ရေးတဲ့ ပရိုဂရမ်ကို နမှုနာပြပြီး ပရိုဂရမ်ဆိုတာ ဘယ်လိုရေးရေးရတဲ့အကြောင်းကို ဖော်ပြခဲ့ပါသည်။

မှန်၏၊ ပရိုဂရမ်ဆိုသည်မှာ လိုချင်တာကို ဖြစ်ရင် မှန်ပါသည်။ ရေးပုံရေးနည်း အမျိုးမျိုးရှိ၏။ ရေးမည်ဆိုလျှင် အစင်ဘလာ ဘာသာရပ်ကဲ့သို့ အစမှ အဆုံး တောက်လျှောက် ရေးချသွားနိုင်၏။ အသုံးပြုနည်းများကို ကြွယ်ကြွယ်ဝဝ အသုံးပြုပြီး၊ ရှင်းလင်းစွာလည်း ရေးသားနိုင်၏။ ရှည်လွန်း၍ ရှုပ်ထွေးသော ပရိုဂရမ်နှင့် လိုရင်းတိုရှင်း ပရိုဂရမ်မှာ ဘယ်အရာကောင်းသနည်း။ မေးစရာတောင်လိုမည် မဟုတ်။ စာလုံးတစ်လုံးပိုရေးရလျှင် စာလုံးတလုံးစာ လက်ပိုညောင်းပါသည်။ တတ်နိုင်လျှင် စိတ်ကူးရုံနဲ့ အလုပ်လုပ်ပေးနိုင်သော ပရိုဂရမ်သည် အကောင်းဆုံး ဖြစ်ပါလိမ့်မည်။

အဲ့ဒီအတွက် ကျွှန်တော်တို့ ဘာတွေကိုလေ့လာဖို့ လိုအပ်သနည်း။ ပရိုဂရမ်မင်းဘာသာရပ်များသည် ကိုယ်စီ ထူးခြားချက်များကို ပိုင်ဆိုင်၏။ ပြောစရာတောင်လိုမည် မထင်၊ Java သည် Class ကို အခြေခံသော Object Oriented ပရိုဂရမ်မင်းဘာသာရပ်ဖြစ်၏။ ကျွှန်တော်တို့ ဒီတစ်ခေါက် Java ၏ Class နှင့် ၎င်း၏ အသုံးပြုပုံတို့ကို လေ့လာသွားပါမည်။



Class ဆိုသည်မှာ


Java သည် Class ကို အခြေခံသော Object Oriented Programming ဘာသာရပ် တစ်မျိုးဖြစ်၏။ Class ဆိုသည်မှာ Object တစ်ခု၏ အရည်အချင်းများကို ဖော်ပြနိုင်ရန်အတွက် လိုအပ်သော အကြောင်းအရာများကို စုစည်းထားသော အချက်အလက် အစုအစည်းတစ်ခု ဖြစ်ပါသည်။

ဥပမာအားဖြင့် လက်တွေ့ဘဝအား ကွန်ပျူတာ မံမိုရီ အပေါ်ခေါ်ယူ အသုံးချခြင်းကို စဉ်းစားကြည့်ပါမည်။ စားသောက်ဆိုင် တစ်ဆိုင်ရှိပါမည်။ အထက်ပါပုံကို java ပရိုဂရမ်တစ်ခု ရေးရန် စဉ်းစားကြည့်ပါမည်။


ထိုဆိုင်အတွင်းတွင် အောင်အောင်၊ မနီလာနှင့် မသန္တာတို့ ရှိကြသည် ဟု ဆိုကြပါစို့။ မနီလာနှင့် မသန္တာတို့သည် ဧည့်သည်ဆိုသည့် ကလပ်စ်မှ instance လုပ်ထားသော object များဖြစ်ကြပြီး၊ အောင်အောင်သည် စာပွဲထိုး ဆိုသည့် ကလပ်စ်မှ instance လုပ်ထားသော object ဖြစ်ပါသည်။


စာပွဲထိုးနှင့် ဧည့်သည်တို့သည် ကလပ်စ်များဖြစ်ကြပြီး၊ စာပွဲထိုးဆိုသည့်ကလပ်စ်တွင် စာပွဲထိုးတစ်ယောက် ပိုင်ဆိုင်သင့်သည့် အချက်အလက်များနှင့် စာပွဲထိုးက လုပ်ဆောင်နိုင်သော လုပ်ဆောင်ချက်များကို သက်မှတ် ရေးသားထားပါသည်။ ဥပမာအားဖြင့် သူ၏ အမည်၊ ရာထူးအဆင့်အတန်း၊ လစာ၊ လုပ်သက်၊ အရည်အချင်းများ အစရှိသည့်အချက်အလက်များအပြင် အော်ဒါမှာယူခြင်း၊ အရက်စပ်ခြင်း၊ စားပွဲများကိုပို့ပေးခြင်း၊ သိမ်းဆည်းခြင်း အစရှိသည့် လုပ်ဆောင်ချက်များကိုလည်း ပြင်ဆင်ထားရန် လိုအပ်ပါသည်။ တဖန် အောင်အောင်သည် စာပွဲထိုးကလပ်စ်၏ အင်းစတန့်စ် (instance) လုပ်ထားသော အော့ဘဂျက် (Object) ဖြစ်ပါသဖြင့် အောင်အောင် အော့ဘဂျက်သည် စပွဲထိုကလပ်စ်၏ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်နိုင်ပေမည်။ ဥပမာအားဖြင့် အောင်အောင်သည် စာပွဲထိုးဖြစ်ခြင်းကြောင့်၊ အော်ဒါများမှာယူခြင်း၊ အရက်ဖျော်စပ်ခြင်းများကို လုပ်ဆောင်နိုင်ပေမည်။

အကျဉ်းဆုံးဆိုရမည် ဆိုလျှင် အော့ဘဂျက်သည် လက်ရှိလောကတွင်တည်ရှိသော ရုပ်ဝတ္တုများကို ကိုယ်စားပြုထားသော မံမိုရီအပေါ်ရှိ အချက်အလက် အစုအဝေးဖြစ်ပြီး၊ ကလပ်စ်ဆိုသည်မှာ ထိုအော့ဘဂျက်များသည် မည်သည့်အရာဖြစ်သည်ကို သတ်မှတ်ပေးနိုင်သော ဒီဇိုင်းပုံ တစ်ခုဖြစ်ပါသည်။ ပြိုင်ကားတစ်စီး၏ ဒီဇိုင်းပုံအတိုင်း တည်ဆောက်ထားသော ရုပ်ဝတ္တုသည် ပြိုင်ကားတစ်စီးဖြစ်လာပြီး၊ ကုန်တင်ကား ဒီဇိုင်းပုံအတိုင်း တည်ဆောက်ပါက ကုန်တင်ကား တစ်စီးဖြစ်လာမည် ဖြစ်သည်။


ပိုင်ဆိုင်မှု့ အချက်အလက်များ


ကလပ်စ်တစ်ခုသည် အော့ဘဂျက်မှ ပိုင်ဆိုင်သင့်သော အချက်အလက်များနှင့် လုပ်ဆောင်ချက်များကို သက်မှတ်ပေးသည်ဟု ဖော်ပြခဲ့၏။ ပိုင်ဆိုင်မှု့ အချက်အလက်များကို မည်ကဲ့သို့ရေးသားနိုင်သည် ဆိုသည်ကို လက်တွေ့ ကလပ်စ်တစ်ခုကို ရေးသားကြီးရင်း ဖော်ပြပါမည်။

လောလောဆယ် နမှုနာအနေဖြင့် နာမည်မေးလျှင် ပြန်ဖြေတတ်သော Human ဆိုသည့် ကလပ်စ် တစ်ခုကို ရေးသားကြည့်ပါမည်။ Human တွင် အမည်၊ အသက်နှင့် ကျားမကိုဖော်ပြနိုင်သော အချက်အလက်ကို ပိုင်ဆိုင်စေပါမည်။

public class Human {
 
 String name;
 boolean male;
 int age;

}

အထက်ပါအတိုင်း ရေးသားမည်ဆိုလျှင် အမည်၊ လိမ်နှင့် အသက် အစရှိသည့် အချက်အလက်များကို ပိုင်ဆိုင်သော ကလပ်စ် တစ်ခုကို ရေးသားပြီးဖြစ်ပါသည်။ ဆက်လက်၍ ထိုကလပ်၏ အော့ဘဂျက်ကို ရေးသားကြည့်ပါမည်။
public class Human {
 
 String name;
 boolean male;
 int age;
 
 public static void main(String[] args) {
  Human aungaung = new Human();
  aungaung.name = "Aung Aung";
  aungaung.male = true;
  aungaung.age = 22;
  
  System.out.println("Name : " + aungaung.name);
  System.out.println("Age  : " + aungaung.age);
  System.out.println("Male : " + aungaung.male);
 }

}

အထက်ပါ ကုဒ်များကို ကွန်ပိုင်းလုပ်၍ အလုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း ထိုအော့ဘဂျက်၏ အမည် ၊ အသက်နှင့် လိမ်ကို ဖော်ပြပေးနိုင်ပါသည်။


ရုတ်တရက် ကြည့်မည်ဆိုပါက ဖော်ပြလိုသည်ကို ဖော်ပြနိုင်သဖြင့် ဘာမှ ပြဿနာမရှိသလို ထင်ရမည် ဖြစ်၏။ သို့ရာတွင် အထက်ပါ ကုဒ်များအား main လုပ်ဆောင်ချက်ထဲမှ အောက်ပါအတိုင်း ပြုပြင် ရေးသားကြည့်ပါမည်။
public class Human {
 
 String name;
 boolean male;
 int age;
 
 public static void main(String[] args) {
  Human aungaung = new Human();
  aungaung.name = "Aung Aung";
  aungaung.male = true;
  aungaung.age = 22;
  
  aungaung.male = !aungaung.male;
  
  System.out.println("Name : " + aungaung.name);
  System.out.println("Age  : " + aungaung.age);
  System.out.println("Male : " + aungaung.male);
 }

}

မိန်းလုပ်ဆောင်ချက်အတွင်းတွင် အကြောင်းတစ်ခုခုကြောင့် aungaung အော့ဘဂျက်၏ male တန်ဖိုးကို ပြောင်းပြန်သတ်မှတ်မိပါသည်။ ကွန်ပိုင်းလုပ်ပြီး အလုပ်လုပ်ခိုင်းကြည့်သောအခါ အောင်အောင်သည် ကျားမဟုတ်တော့ပါ။


ဤကဲ့သို့ အော့ဘဂျက်တစ်ခု၏ ပိုင်ဆိုင်မှု့ အချက်အလက်များကို ပြင်ပမှ အလွယ်တကူ ပြုပြင်ပြောင်းလည်းနိုင်လျှင် ထိုအော့ဘဂျက်သည် မိမိကစီမံထားသလို အလုပ်လုပ်နိုင်တော့မည် မဟုတ်ပေ။ ထို့ကြောင့် အချက်အလက်များကို လိုအပ်သလို ပြင်ပမှ အလွယ်တကူ ပြုပြင်ပြောင်းလည်းခြင်း မရှိနိုင်အောင် ပြင်ဆင်ထားသင့်ပါသည်။

Java ဘာသာရပ်တွင် ကလပ်တစ်ခု၏ အချက်အလက်များနှင့် လုပ်ဆောင်ချက်များအား လိုအပ်သလို ဆက်သွယ်ပိုင်ခွင့်ကို သက်မှတ်နိုင်ရန် စကားလုံးများကို ပြင်ဆင်ပါသည်။ ထိုစကားလုံးများမှာ အောက်ပါအတိုင်းဖြစ်၏။

  • public မည်သည့်နေရာက မဆို ဆက်သွယ်အသုံးပြုနိုင်ပါသည်။
  • protected မိမိ၏ Sub Class များမှ တဆင့် ဆက်သွယ်အသုံးပြုနိုင်ပါသည်။
  • private မိမိကိုယ်တိုင်မှလွဲ၍ အခြားသောနေရာများမှ ဆက်သွယ်နိုင်ခြင်းမရှိပါ။
တဖန် ဘာမှ သတ်မှတ်ရေးသားထားခြင်းမရှိပါက၊ package တစ်ခုတည်းအတွင်းမှ ဆိုလျှင် ဆက်သွယ်အသုံးပြုနိုင်ပါလိမ့်မည်။


လုပ်ဆောင်ချက်များ


Java ပရိုဂရမ်တွင် Object များအား အလုပ်လုပ်စေရာတွင် ထို Object ၏ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်စေခြင်းအားဖြင့် ပရိုဂရမ်များကို လိုအပ်သလို အလုပ်လုပ်စေနိုင်ခြင်းဖြစ်သည်။ လုပ်ဆောင်ချက်များအား မက်သတ် (Method) ဟုလည်းခေါ်ဆိုလေ့ရှိပါသည်။

ပိုင်ဆိုင်မှု့ အချက်အလက်များကဲ့သို့ပင် လုပ်ဆောင်ချက်များအားလည်း ဆက်သွယ်အသုံးပြုနိုင်ခွင့်ကို ခွဲခြားရေးသားနိုင်ပါသည်။ လုပ်ဆောင်ချက်များအား ကလပ်စ် အတွင်းတွင် ရေးသားပုံမှာ အောက်ပါအတိုင်းဖြစ်၏။

private String name;

public String getName() {
    return this.name;
}

public void setName(String str) {
    this.name = str;
}

အထက်ပါ ကုဒ်များအတွင်းတွင် String name အချက်အလက်သည် private ဖြစ်ပါသဖြင့်၊ မိမိ၏ အော့ဘဂျက်၏ အပြင်မှ တိုက်ရိုက် ဆက်သွယ်အသုံးပြုနိုင်ခြင်း မရှိပါ။ လုပ်ဆောင်ချက်များကို ရေးသား၍ လိုအပ်သည်များကို လုပ်ဆောင်စေပါသည်။ လုပ်ဆောင်ချက်များကို ရေးသားရာတွင် ဦးစွာ ဆက်သွယ်နိုင်ခွင့် ဖြစ်သော public / private / protected အစရှိသည့် စကားလုံးကို ရေးသားပြီး၊ ရလဒ်၏ အချက်အလက်ပုံစံကိုရေးသားရပါမည်။ ရလဒ်ကိုပြန်ပေးစရာမလိုသော လုပ်ဆောင်ချက်ဆိုပါက void ကို ရေးသားရပြီး၊ int ကို ရလဒ်အဖြစ်ပြန်ပေးလိုပါက int အစရှိသဖြင့် ကနဦးပုံစံများမှအစ၊ Object များအဖြစ်အသုံးပြုနိုင်သော ကိုးကားပုံစံများ အထိ ရလဒ်အဖြစ်ပြန်ပေးနိုင်ပါသည်။

အထက်ပါကုဒ်၏ getName လုပ်ဆောင်ချက်သည် အမည်ကို ရလဒ်အဖြစ်ပြန်ပေးရန် လိုအပ်သည့် လုပ်ဆောင်ချက်ဖြစ်သောကြောင့် public String getName() ဟု ရေးသားပြီး၊ လက်သဲကွင်း { } အတွင်းတွင် ထိုလုပ်ဆောင်ချက်အတွင်းတွင် လုပ်ဆောင်စေလိုသည့် လော့ဂျစ်များကို ရေးသားရပါမည်။ ဤနမှုနာတွင် အမည်ကို ရလဒ်အဖြစ်ပြန်ပေးရန် လိုအပ်ပါသဖြင့် return this.name; ဟု ရေးသားထားပါသည်။ this.name ဆိုသည်မှာ မိမိကပိုင်ဆိုင်သော အချက်အလက်ဖြစ်သည့် name ကို ရလဒ်အဖြစ် ခေါ်ဆိုသည့်နေရာကို ပြန်ပေးနေခြင်းဖြစ်ပါသည်။

တဖန် setName လုပ်ဆောင်ချက်ကို ကြည့်ပါ။ public void setName(String str) ဟု ရေးသားထားသည်။ ပါရာမီတာ String str ကို ပေးပြီး အမည်ကို သတ်မှတ်စေပါသည်။ အတွင်းပိုင်းတွင် this.name = str; ဟု ရေးသားထားပြီး အော့ဘဂျက်၏ name အား ပါရာမီတာ str ဖြင့် အစားထိုးပါသည်။

ဤအတိုင်းဆိုပါက ယခင်ရေးသားခဲ့သော ပိုင်ဆိုင်မှု့ အချက်အလက်များအား တိုက်ရိုက်ဆက်သွယ်သည်နှင့် ဘာမှခြားမည် မဟုတ်ပေ။ ကွာခြားချက်ကို သိရှိစေရန် နမှုနာတစ်ခုကို ရေးသားကြည့်ပါမည်။

public class HumanTest {
 
 private Human aung;
 
 public HumanTest(Human aung) {
  this.aung = aung;
 }
 
 public void init(String name, boolean isMale, int age) {
  this.aung.setAge(age);
  this.aung.setName(name);
  this.aung.setMale(isMale);
 }
 
 public void doOutput() {
  System.out.println("Name : " + this.aung.getName());
  System.out.println("Age  : " + this.aung.getAge());
  System.out.println("Sex  : " + this.aung.getSex());
 }
 
 public static void main(String[] args) {
  HumanTest test = new HumanTest(new Human());
  test.init("Aung Aung", true, 22);
  test.doOutput();
 }
}

class Human {

 private String name;
 private Integer age;
 private Boolean male;
 
 public String getName() {
  String tmp = "";
  if(male) {
   if(age > 30) {
    tmp = "U ";
   } else if (age > 20) {
    tmp = "Ko ";
   } else {
    tmp = "Mg ";
   }
  } else {
   if(age > 30) {
    tmp = "Daw ";
   } else {
    tmp = "Ma ";
   }
  }
  return tmp + name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getSex() {
  if(male) {
   return "Male";
  }
  return "Female";
 }
 public void setMale(boolean male) {
  if(null == this.male) {
   this.male = male;
  }
 }
}

ဒီတစ်ခေါက် ကုဒ်တွေအရှည်ကြီး ရေးသားထားသော်လည်း ကြည့်စေလိုသည်မှာ စာကြောင်း ၁၂နှင့် ၆၈ မှ ၇၂အထိ ဖြစ်ပါသည်။ Human ကလပ်စ်၏ male အား တိုက်ရိုက် သက်မှတ်ခွင့်မရှိတော့သောကြောင့် setMale လုပ်ဆောင်ချက်ကို ပြင်ဆင်လာပါသည်။ ဤကဲ့သို့ လုပ်ဆောင်ချက်ကို ပြင်ဆင်ထားခြင်းအားဖြင့် လုပ်ဆောင်ချက်အတွင်းတွင် male သည် သတ်မှတ်ထားခြင်း မရှိပါမှ သက်မှတ်နိုင်မည်ဟု ပြုပြင် ရေးသားနိုင်ပါသည်။ ဤနည်းအားဖြင့် တစ်ကြိမ် သတ်မှတ်ထားသော အချက်အလက်အား စစ်ဆေး၍ ပြင်ပြင်နိုင်စံရန် စီမံနိုင်ပါသည်။


ကွန်စတရက်တာ (Constructor)


အထက်ပါ ကုဒ်များကိုကြည့်ရင်း မလိုအပ်ပဲ အလွန်ရှည်နေသည်ဟု ထင်မိသူများရှိမည်။ ဟုတ်သည်။ Setter လုပ်ဆောင်ချက်များသည် ပရိုဂရမ်အတွင်းတွင် တစ်ကြိမ်သာသုံးရန်လိုအပ်ပြီး၊ နောက်ပိုင်းတွင် အကြိမ်ကြိမ်ပြန်သုံးနေသည်ကို မတွေ့ရ။ ထို့ကြောင့် အော့ဘဂျက်အားခေါ်ယူစဉ် တစ်ခါရေးပြီး နောက်ပိုင်းတွင် ပြန်သုံးရန်မလိုသဖြင့် တကူးတက Setter လုပ်ဆောင်ချက်များကို ပြင်ဆင်ထားရန် မဖြစ်မနေ လိုအပ်ခြင်းမရှိပေ။

အော့ဘဂျက်အား ခေါ်ယူစဉ်တွင် သတ်မှတ်ရန် နည်းလမ်းရှိပါသည်။ ထိုအရာမှာ Constructor ပင်ဖြစ်၏။ ကွန်စတရက်တာသည် Class တစ်ခုမှ အော့ဘဂျက်အား instance လုပ်ယူသည့်အခါတွင် ခေါ်ဆိုမည့် လုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ Java Class များသည် Object Class ၏ Sub Class များဖြစ်သောကြောင့် Parameter ကို အသုံးမပြုသော ကွန်စတရက်တာကို အလိုအလျှောက်ပိုင်ဆိုင်ပါသည်။ တကူးတကရေးစရာမလိုပဲ အလိုအလျှောက် instance ကို ခေါ်ယူနိုင်ပါသည်။

သို့ရာတွင် Class မှ instance ကို ခေါ်ယူလိုသည့်အခါတွင် ကြိုတင်၍ လော့ဂျစ်များကို ရေးသားထားလိုပါက ကွန်စတရက်တာ အတွင်းတွင် ရေးသားထားနိုင်ပါသည်။
public class HumanTest {

 public static void main(String[] args) {
  Human aung = new Human("Aung Aung", 22, true);
  System.out.println("Name : " + aung.getName());
  System.out.println("Age  : " + aung.getAge());
  System.out.println("Sex  : " + aung.getSex());
 }
}

class Human {

 private String name;
 private Integer age;
 private Boolean male;
 
 public Human(String name, int age, boolean male) {
  this.name = name;
  this.age = age;
  this.male = male;
 }
 
 public String getName() {
  String tmp = "";
  if(male) {
   if(age > 30) {
    tmp = "U ";
   } else if (age > 20) {
    tmp = "Ko ";
   } else {
    tmp = "Mg ";
   }
  } else {
   if(age > 30) {
    tmp = "Daw ";
   } else {
    tmp = "Ma ";
   }
  }
  return tmp + name;
 }

 public int getAge() {
  return age;
 }

 public String getSex() {
  if(male) {
   return "Male";
  }
  return "Female";
 }
}

အထက်ပါ ကုဒ်များ၏ စာကြောင်း ၁၇မှ ၂၁သည် ကွန်စတရက်တာဖြစ်ပါသည်။ ထိုကွန်စတရက်တာတွင် ဤကလပ်စ်၏ ပိုင်ဆိုင်မှု့အချက်အလက်များအား သတ်မှတ်ရန် အချက်အလက်များကို ပါရာမီတာအဖြစ် လက်ခံရယူပြီး၊ ကွန်စတရက်တာ အတွင်း၌ပင် အစားထိုးနေပါသည်။ ဤသည်ကို ကြည့်ခြင်းအားဖြင့် Human ၏ instance ကို ခေါ်ယူရာတွင် String name, int age, boolean male ကို ပါရာမီတာအဖြင့် ပေးရန်လိုအပ်သည် ဆိုသည်ကို သိနိုင်ပါသည်။ တနည်းဆိုရသော် ဤနည်းအားဖြင့် ပါရာမီတာအဖြစ်ပေးလိုက်သော အချက်အလက်များကို ပိုင်းဆိုင်သော အော့ဘဂျက်ကို ရရှိနိုင်မည်ဖြစ်သည်။ ကျွှန်တော်တို့ အထက်ပါ ကုဒ်များကို အလုပ်လုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း ရရှိပါလိမ့်မည်။



လေးစားစွာဖြင့်
မင်းလွင်

File, Directory များအား အသုံးချခြင်း

ပြီးခဲ့တဲ့ ဘလောဂ်များဖြင့် Java Nio2 ၏ Files Utility Class ကို အသုံးပြု၍ နမှုမှာအမျိုးမျိုးကို ဖော်ပြခဲ့ပါသည်။ သို့ရာတွင် Files ကလပ်စ်၌ အခြားအသုံးဝင်သော လုပ်ဆောင်ချက်များစွာ ကျန်ရှိပါသေးသည်။ ဖိုင်နှင့် ဒိုင်အတ္တရီ များအား ကော်ပီကူးခြင်း၊ ပြောင်းရွှေ့ခြင်းနှင့် ဖျက်ပစ်ခြင်း(Delete) အစရှိသည် လုပ်ဆောင်ချက်များကို Files ကလပ်စ်ကို အသုံးပြု၍ လုပ်ဆောင်နိုင်ပါသေးသည်။

အထူးသဖြင့် ကော်ပီကူးခြင်းသည် ယခင် ပံ့ပိုးထားခြင်း မရှိပါသဖြင့် Streams နှင့် Channel များကို အသုံးပြု၍ တကူးတက ရေးသားနေရပါသည်။ ထို့အပြင် ကော်ပီကူးခြင်းသည် အသုံးများပါသဖြင့် Nio2 တွင် ကော်ပီကူးခြင်းကို ပံ့ပိုးလာခြင်းသည် လွန်စွာမှ အသုံးဝင်လပေသည်။ ယခုတစ်ခေါက်တွင်လည်း ဆက်လက်၍ ဖိုင်နှင့် ဒိုင်အတ္တရီများကို အသုံးပြုပုံတို့ကို နမှုနာများရေး၍ ဆက်လက်လေ့လာသွားပါဦးမည်။


ကော်ပီကူးခြင်း


ဖိုင်နှင့် ဒိုင်အတ္တရီများအား ကော်ပီကူရာတွင် Files#copy လုပ်ဆောင်ချက်များကို အသုံးပြုနိုင်ပါသည်။

import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;


public class FileCopy {

 public static void main(String[] args) {
  
  if(args.length != 2) {
   System.err.println("Please set 2 parameters");
   return;
  }
  
  try {
   FileSystem fs = FileSystems.getDefault();
   
   Path origin = fs.getPath(args[0]);
   Path toCopy = fs.getPath(args[1]);
   
   Files.copy(origin, toCopy);
  } catch (IOException e) {
   System.err.println("There is no file ["+args[0] +"]");
  }

 }
}



ရိုးရိုးကော်ပီကူးရုံဆိုပါက Files#copy မက်သတ်၏ ပဋ္ဌမပါရာမီတာတွင် ကူးလိုသည့် မှုရင်း ဖိုင်၏ Path အော့ဘဂျက်ကို ရေးသားပြီး၊ ဒုတိယ ပါရာမီတာတွင် ကူးလိုသည့် ဖိုင်၏ Path အော့ဘဂျက်ကို ရေးသားရပါမည်။

အထက်ပါ နမှုနာတွင်  ရေးသားထားသည့်အတိုင်း Files.copy(origin, toCopy); ဟု၊ origin သည် မှုလဖိုင်ဖြစ်ပြီး toCopy သည် ကူးမည့် ဖိုင်အသစ်ဖြစ်ပါသည်။ ဤကဲ့သို့ရေးသားရာတွင် origin သည် လက်ရှိ တည်ရှိခြင်းမရှိပါက NoSuchFileException ကို ဖြစ်ပွားစေမည် ဖြစ်ပြီး၊ toOrigin သည် လက်ရှိ တည်ရှိပြီး ဖြစ်ပါက FileAlreadyExitsException ကို ဖြစ်ပေါ်စေမည် ဖြစ်ပါသည်။

အကယ်၍ ရှိပြီးသားဖိုင် အပေါ်တွင် ထပ်ပြီး ရေးသားလိုပါက Files#copy မက်သတ်၏ တတိယ လုပ်ဆောင်ချက်တွင် java.nio.file.StandardCopyOption.REPLACE_EXISTING ကို သတ်မှတ် ရေးသားနိုင်ပါသည်။

StandardCopyOption သည် enum ပုံစံ ဖြစ်ပြီး၊ အောက်ပါ အချက်အလက်များကို ပိုင်ဆိုင်ပါသည်။

  • REPLACE_EXISTING
  • COPY_ATTRIBUTES
  • ATOMIC_MOVE
COPY_ATTRIBUTES ကို အသုံးပြုပါက၊ နောက်ဆုံးဆက်သွယ်သော အချိန် ကဲ့သို့သော ဖိုင်တစ်ခု၏ Meta data အချက်အလက်များကိုပါ ကော်ပီကူးနိုင်ပါသည်။ တဖန် ATOMIC_MOVE သည် ကော်ပီကူးရာတွင် အသုံးမပြုနိုင်ပဲ ထိုဖိုင်အား ရွှေ့ပြောင်းရာတွင် အသုံးပြုနိုင်ပါသည်။

StandardCopyOption ကဲ့သို့ပင် ယခင် အခန်းများတွင် ဖော်ပြပြီးဖြစ်သော LinkOption များကိုလည်း အသုံးပြုနိုင်ပါသည်။ 

သတိပြုရန် အချက်တစ်ခုမှာ ကော်ပီကူးရာတွင် Windows ဆိုပါက copy ကွန်မန်းကို၎င်း၊ Linux ၏ cp ကွန်မန်းကို၎င်း အသုံးပြုရာ၌၊ ဖိုင်တစ်ခုအား အခြားသော ဒိုင်အတ္တရီ တစ်ခုဆီသို့ လက်ရှိအမည်အတိုင်း ကော်ပီကူးလိုပါက ကော်ပီကူးမည့်ဖိုင်အသစ်နေရာတွင် ကူးပြီးသိမ်းစေလိုသည့် ဒိုင်အတ္တရီကို သာရေးသားလျှင် ရနိုင်ပေသည်။ တကူးတက ဖိုင်အမည် ရေးသားရန် မလိုအပ်ပေး။ အောက်ပါအတိုင်းဖြစ်၏။


သို့ရာတွင် Java ၏ Files.copy ကို အသုံးပြုရာ၌ ကူးလိုသည့် ဖိုင်၏ အမည် အပြည့်အစုံကို ရေးသားရန် လိုအပ်ပါသည်။ ရေးပြီးသား FileCopy.java ကို အသုံးပြု၍ စမ်းသပ်ကြည့်ပါမည်။


ကော်ပီကူးမည့်နေရာတွင် copydir သည် ရှိနှင့်ပြီးဖြစ်သောကြောင့် FileAlreadyExitsException ကို ဖြစ်ပေါ်စေပါသည်။ အောက်ပါအတိုင်း အမည်အပြည့်အစုံကို ရေးသားပါက ကူးနိုင်မည် ဖြစ်ပါသည်။




ရွှေ့ပြောင်းခြင်း


ဖိုင်များအား ကော်ပီကူးသကဲ့သို့ တစ်နေရာမှ တစ်နေရာဆီသို့ ပြောင်းရွှေ့ရာတွင်လည်း Files ကလပ်စ်ကို အသုံးပြုနိုင်ပါသည်။ ဖိုင်များအား ရွှေ့ပြောင်းရာတွင် Files#move မက်သတ်ကို အသုံးပြုနိုင်ပါသည်။

import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class MoveSample {
 
 public static void main(String[] args) throws IOException {
  FileSystem fs = FileSystems.getDefault();
  Path origin = fs.getPath(args[0]);
  Path toMove = fs.getPath(args[1]);
  Files.move(origin, toMove, StandardCopyOption.ATOMIC_MOVE);
 }
}

ဖိုင်ဒါမှမဟုတ် ဒိုင်အတ္တရီ တစ်ခုအား ပြောင်းရွှေ့ရာတွင်၎င်း၊ အခြားအမည်တစ်ခုအဖြစ် ပြောင်းလည်း လိုသည့်အခါမျိုးတွင် Files#move လုပ်ဆောင်ချက်ကို အသုံးပြုနိုင်ပါသည်။ move လုပ်ဆောင်ချက်၏ ပဋ္ဌမ ပါရာမီတာနေရာတွင် မှုရင်းဖိုင်ကို ရေးရန်လိုအပ်ပြီး၊ ပြောင်းရွှေ့လိုသည့် ဖိုင်နေရာအား ဒုတိယ ပါရာမီတာနေရာတွင် ရေးသားရပါမည်။ တတိယ ပါရာမီတာအနေဖြင့် Varags ပုံစံ LinkOption နှင့် StandardCopyOption များကို အသုံးပြုနိုင်ပါသည်။ အထက်ပါ နမှုနာထဲတွင်မှု ATOMIC_MOVE ကို အသုံးပြုထားပါသည်။




ဖျက်ပစ် (Delete) ခြင်း


Java ၏ ဖိုင်အိုင်အို အင်တာဖေစ် အသစ်ဖြစ်သော nio2 တွင် ဖိုင်နှင့် ဒိုင်အတ္တရီများအား ဖျက်ပစ်ရာတွင် Files#delete နှင့် Files#deleteIfExists ကို အသုံးပြုနိုင်ပါသည်။ File#delete ကို အသုံးပြုရာတွင် လက်ရှိ ဖိုင်စစ္စတမ်အပေါ်တွင် ဖျက်လိုသည့်ဖိုင်သည် တည်ရှိနေခြင်းမရှိပါက NoSuchFileExitsException ကို ဖြစ်ပေါ်စေမည် ဖြစ်သည်။ Files#deleteIfExits ကို အသုံးပြုပါက ဖိုင်ရှိရှိ မရှိရှိ Exception ကို ဖြစ်ပေါ်စေမည် မဟုတ်ပေ။

File#deleteIfExits ကို အသုံးပြုရာတွင် ဖျက်လိုသည့် ဖိုင်အား ဖျက်ပစ်နိုင်ပါက true ကို ရရှိမည် ဖြစ်ပြီး၊ အကယ်၍ ဖိုင်မရှိပက၊ ဒါမှမဟုတ် ဖျက်ပစ်နိုင်ခြင်း မရှိပါက false ကို ပြန်ရမည် ဖြစ်သည်။ လက်တွေ့ရေးသားကြည့်ပါမည်။

import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;

public class DeleteSample {

 public static void main(String[] args) throws IOException {
  FileSystem fs = FileSystems.getDefault();
  for(String s : args) {
   Path origin = fs.getPath(s);
   Files.delete(origin);
  }
 }
}



ယနေ့တွင် Java ၏ ဖိုင်စစ္စတမ် အင်တာဖေစ် အသစ်၏ အသုံးများမည်ဖြစ်သော Files ကလပ်စ်၏ လုပ်ဆောင်ချက်အချို့ကို ဖော်ပြခဲ့၏။ နောက်ရက်များတွင်လည်း ဆက်လက်၍ ဖော်ပြသွားပါဦးမည်။


ကိုးကား

http://itpro.nikkeibp.co.jp/article/COLUMN/20110830/367909/?ST=develop&mkjb&P=3
http://itpro.nikkeibp.co.jp/article/COLUMN/20110830/367909/?ST=develop&mkjt&P=4

လေးစားစွာဖြင့်
မင်းလွင်

April 26, 2012

ကိန်းရှင်များ

ကွန်ပျူတာ ပရိုဂရမ်မင်းဘာသာရပ် အတော်များများမှာ ပရိုဂရမ်အတွင်းတွင် အသုံးပြုနေသည့် တန်ဖိုးများကို အစားထိုးအသုံးပြုရန် ကိန်းရှင်များကို အသုံးပြုလေ့ရှိပါသည်။ ဘီရှဲတွင်လည်း ကိန်းရှင်များကို အသုံးပြု၍ ပရိုဂရမ်များကို ရေးသားနိုင်ပါသည်။ ကိန်းရှင်များအား အင်္ဂလိပ်စာလုံးများနှင့် _ စာလုံးကို အသုံးပြု၍ ရေးသား နိုင်ပါသည်။ သို့ရာတွင် ပဋ္ဌမဦးဆုံးစာလုံးအား ကိန်းဂဏာန်းများကို အသုံးပြု၍မရပေ။ ကိန်းရှင်များအား အစားထိုးအသုံးပြုရာတွင် = ကို အသုံးပြု၍ ကိန်းရှင်အား တန်ဖိုးဖြင့် အစားထိုးနိုင်ပါသည်။ သတိပြုရန် အချက်မှာ = ၏ ဘယ်ညာတွင် Blank စာလုံးကို အသုံးပြု၍ မရပါ။
#!/bin/sh

var="This is variable"

echo $var


အထက်ပါအတိုင်း $var ဟု ရေးသားခြင်း အားဖြင့် ကိန်းရှင်များ၏ တန်ဖိုးများအား အသုံးပြုနိုင်ပါသည်။ ထို့ကြောင့် echo $var ကွန်မန်း၏ ရလဒ်သည် this is variable ဟု ကိန်းရှင်၏ တန်ဖိုးကို echo လုပ်ပေးနိုင်ခြင်း ဖြစ်ပါသည်။


တန်ဖိုးသတ်မှတ်မထားသေးသော ကိန်းရှင်များအား အသုံးပြုခြင်း

B Shell တွင် ကိန်းရှင်တစ်လုံး၏ တန်ဖိုးသည် ဗလာဖြစ်သည့်အခါတွင်၎င်း၊ သတ်မှတ်ထားခြင်း မရှိသည့်အခါမျိုး တွင်၎င်း အမျိုးမျိုးသော လုပ်ဆောင်ချက်များကို လုပ်ဆောင်စေနိုင်ပါသည်။

ရေးသားပုံ တန်ဖိုးသတ်မှတ်ပြီးအခါ တန်ဖိုးသတ်မှတ်ထားခြင်း မရှိသောအခါ
${ကိန်းရှင်:-word} ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။ word ၏ တန်ဖိုးအား အသုံးပြုပါမည်။
${ကိန်းရှင်:=word} ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။ word ၏ တန်ဖိုးအား ကိန်းရှင်တွင် အစားထိုး၍ အသုံးပြုပါမည်။
${ကိန်းရှင်:?word} ကိန်းရှင်၏ တန်ဖိုးကို အသုံးပြုပါမည်။ word အား Error Message အဖြစ် အသုံးပြု၍ စကရစ်အား ပြီးဆုံးစေပါမည်။
${ကိန်းရှင်:+word} word ၏ တန်ဖိုးဖြင့် ကိန်းရှင်အား အစားထိုးပါမည်။ ဘာမှမလုပ်ပါ



${ကိန်းရှင်:-word}

#!/bin/sh

echo What is your name? $name
echo What is your name? ${name:-minlwin}
echo $name

name=kgkg
echo What is your name? ${name:-minlwin}


စာကြောင်း ၄ကြောင်းမြောက်တွင် name သည် တန်ဖိုးသတ်မှတ်ထားခြင်း မရှိပါသဖြင့် minlwin အား အစားထိုး အသုံးပြုသွားသည်ကို တွေ့ရပါမည်။ သို့ရာတွင် name အား အစားထိုးခြင်း မရှိပါသဖြင့် စာကြောင်း နံပါတ် ၅ ၏ echo $name ရဲ့ ရလဒ်မှာ ဗလာ အတိုင်းဖြစ်ပါသည်။

တဖန် စာကြောင်း ၇ တွင် name အား kgkg ဖြင့် အစားထိုးပါသည်။ ထို့ကြောင့် စာကြောင်း ၈ တွင် ${name:-minlwin} ဟု ရေးသားထားပါသော်လည်း name မှာ ဗလာ မဟုတ်ပါသောကြောင့် name ၏ တန်ဖိုးဖြစ်သော kgkg ကို ဖော်ပြနိုင်ခြင်း ဖြစ်ပါသည်။


${ကိန်းရှင်:=word}

#!/bin/sh

echo What is your name? $name
echo What is your name? ${name:=minlwin}
echo $name

name=kgkg
echo What is your name? ${name:=minlwin}
echo $name


စာကြောင်း၄ တွင် name ၏ တန်ဖိုးသည် သတ်မှတ်ထားခြင်းမရှိပါသဖြင့်၊ ${name:=minlwin} ဟု ရေးသားထားသောကြောင့် echo ၏ ရလဒ်မှာ minlwin အား အစားထိုး၍ အသုံးပြုသွားပါသည်။ တဖန် စာကြောင်း ၅ ၏ ရလဒ်ကို ကြည့်ခြင်းအားဖြင့် name ၏ တန်ဖိုးအား minlwin ဖြင့် အစားထိုးသွားသည်ကို တွေ့မြင် နိုင်ပါသည်။

တဖန် စာကြောင်း ၇ တွင် name အား kgkg ဖြင့် အစားထိုးပါသဖြင့်၊ စာကြောင်း၉တွင် name အစား minlwin ဖြင့် ဖော်ပြခြင်းမရှိသလို၊ စာကြောင်း ၁၀ အားကြည့်ခြင်းအားဖြင့် name ၏ တန်ဖိုးအား minlwin ဖြင့် အစားမထိုးကြောင်း တွေ့မြင်နိုင်ပါသည်။


${ကိန်းရှင်:?word}


#!/bin/sh

name=kgkg
echo What is your name? ${name:?minlwin}

name=
echo What is your name? ${name:?minlwin}


စာကြောင်း ၄ ၏ ရလဒ်သည် name ၏ တန်ဖိုးသည် kgkg ဖြစ်ပါသဖြင့် kgkg ကို ဖော်ပြပေးပါသည်။ စာကြောင်း ၇ ၏ ရလဒ်သည် စာကြောင်း ၆ တွင် name အား ဗလာဖြင့် အစားထိုးထားပါသဖြင့် Error Message အဖြင့် minlwin ကို ဖော်ပြပြီး၊ Script အား အမှားအဖြစ် ပြီးဆုံးစေပါသည်။


${ကိန်းရှင်:+word}

#!/bin/sh

name=kgkg
echo What is your name? ${name:+minlwin}
echo $name
name=
echo What is your name? ${name:+minlwin}


စာကြောင်း ၄၏ ရလဒ်သည် name တွင် kgkg ဟူသော တန်ဖိုးကို ပိုင်ဆိုင်သောကြောင့် minlwin ကို အစားထိုးဖော်ပြပါသည်။ သို့ရာတွင် စာကြောင်း ၇ ၌မှု name ၏ တန်ဖိုးမှာ ဗလာဖြစ်ပါသဖြင့် minlwin ဖြင့် အစားထိုးဖော်ပြခြင်း မရှိသည်ကို တွေ့ရပါမည်။

ဆက်လက် လေ့လာဖော်ပြသွားပါဦးမည်။

လေးစားစွာဖြင့်
မင်းလွင်

April 24, 2012

Hello B Shell

ဆာဗာအပလီကေးရှင်းများ ရေးသားသူတွေအတွက်တော့ ရင်းနှီးပြီး ဘာသာရပ်တစ်မျိုးဖြစ်ပါသည်။ Open Source အပလီများ ခေတ်စားလာသည်နှင့်အတူ Linux ဆာဗာများသည်လည်း အသုံးများလာကြပါသည်။ ဂျပန်လိုနိုင်ငံမျိုးမှာတော့ ဆာဗာစက်အတော်များများသည် ယခင်ကတည်းက Solaries, AIX ကဲ့သို့ Unix ဆာဗာများကို အသုံးပြုခဲ့သခဲ့သို့ Open Source ခေတ်အရောက်မှာလည်း Unix ကို အခြေခံသော Linux ဆာဗာများကို အသုံးပြုလာပါသည်။

Unix အခြေခံ Linux စက်များသည် ယခင်ကတည်းက ဆာဗာအတွက်ကိုရည်ရွယ်ပြီး ရေးသားခဲ့ပါသဖြင့် ဆာဗာအတွက် အလွန်သင့်တော်သည်မှာ မေးစရာပင်မလို။ ယခုနောက်ပိုင်းတွင် GUI ဘက်ပိုင်းဆိုင်ရာတွင် တိုးတက်လာခဲ့ပြီး Ubintu၊ CentOS အစရှိသည့် Personal PC သုံး Linux OS များကြောင့် Linux ကို ပို၍ လူသိများလာခဲ့ပါသည်။

Shell ဆိုသည်မှာ Linux စက်များအပေါ်တွင် အသုံးပြုနိုင်သော လွန်စွာအသုံးဝင်သည့် Script ဘာသာရပ် တစ်မျိုးဖြစ်ပါသည်။ Linux ကို အသုံးပြုဘူးသူတိုင်းသိရှိပါလိမ့်မည်။ Linux တွင် GUI အပြင် CUI Interface သည် လွန်စွာမှ အသုံးဝင်လှပါသည်။ Linux စက်ပေါ် Login လုပ်ပြီး Command Prompt ကို ဖွင့်ကာ ls ဟု ကွန်မန်းကို ရိုက်လိုက်ပါက လက်ရှိ Directory အောက်ရှိ ဖိုင် နှင့် ဒိုင်အတ္တရီများကို ဖော်ပြပေးနိုင်ပါသည်။ ထိုကဲ့သို့ ကွန်မန်းများသည် Shell ကွန်မန်းများဖြစ်ကြပြီး၊ ထို Shell ကွန်မန်းများအား စီရီ၍ ကွန်ပျူတာအား လိုအပ်သလို ခိုင်းစေနိုင်ပါသည်။ Shell ကွန်မန်းများ စီရီရေသားထားသော Text ဖိုင်များအား Shell Script ဖိုင်များ ဟုခေါ်ဆိုပါသည်။

Shell သည် အမျိုးအစားကွဲပေါင်းများစွာရှိ၏။ ထင်ရှားသည်မှာ Bash Shell၊ C Shell, Korn Shell (kshell) တို့ဖြစ်ကြ၏။ ထို့အပြင် Shell ဘာသာရပ်၏ ဝါကျများသည် လွန်စွာရိုးရှင်း၍ တော်ရုံ ကွန်ပျူတာပရိုဂရမ်မင်း အခြေခံရှိသူ တစ်ယောက်ဆိုပါက အထွေအထူးလေ့လာစရာမလိုပဲ Manual များကို ဖတ်ပြီး လက်တမ်း ချရေးနိုင်လောက်အောင် လွယ်ကူလှပါသည်။ တဖန် Shell တစ်မျိုးမျိုးကို လေ့လာဖူးပါက ကျန်သော Shell များကိုလည်း လွယ်ကူစွာ လေ့လာ အသုံးပြုနိုင်ပါသည်။ ထို့အပြင် Shell များသည် လွယ်ကူရုံသာမက လွန်စွာမှ အသုံးဝင်လှပေသည်။ ဤခေါင်းစဉ်ဖြင့် ဘယ် Linux အပေါ်တွင်မဆို Default အနေဖြင့် ပါဝင်သော B Shell အကြောင်းကို မိတ်ဆက်သွားပါမည်။


Hello B Shell

ပြောနေသည်ထက် ရေးကြည့်သည် ကပို၍မြန်ပါသည်။


Linux တာမိနယ်ကို ဖွင့်၍ အထက်ပါအတိုင်း vi hello.sh ဖြင့် Text ဖိုင်တစ်ခုရေးသားရန် vi Editor ကို ဖွင့်ပါမည်။ ပြီးလျှင် အောက်ပါ Shell ကွန်မန်းများကို ရေးသားပါမည်။

#!/bin/sh

echo "Hello B Shell"
ပဋ္ဌမစာကြောင်းဖြင့် အသုံးပြုမည့် Interpreter ကို သတ်မှတ်နေပါသည်။ ဤနေရာတွင် /bin/sh ဟု ရေးသားထားပါသည်။ Interpreter ၏ နေရာသည် စက်နှင့် အသုံးပြုသူ၏ သက်မှတ်ချက်အပေါ်တွင် မှုတည်၍ ပြောင်းလည်းတတ်ပါသည်။ ထို့ကြောင့် ဘယ်နေရာမှာ shell ၏ Interpreter ရှိမှန်းမသိပါက which sh ဟု ရိုက်ကြည့်ပါက အသုံးပြုနေသည့် Interpreter ၏ နေရာကို ဖော်ပြပေးပါမည်။ တတိယစာကြောင်းသည် ဤ စကရစ်တွင် အသုံးပြုမည့် အမိန့်ပေးစာကြောင်းဖြစ်ပါသည်။ ဤနေရာတွင် echo "Hello B Shell" ဟု ရေးသားထားပါသည်။ echo ကွန်မန်းကို အသုံးပြု၍ "Hello B Shell" ဟူသည့် စာကြောင်းကို ဖော်ပြပေးနိုင်ပါသည်။

ပြီးပါက cat hello.sh ဖြင့် ရေးသားထားသော စာများအား ပြန်ဖွင့်ကြည့်ပါမည်။ ပြီးလျှင် ls -l ကွန်မန်းကို ရိုက်ထည့်လိုက်ပါက hello.sh ဖိုင်ကို တွေ့ရမည် ဖြစ်သည်။ vi ဖြင့်ရေးထားသော ဖိုင်သည် Default အတိုင်းဆိုပါက ရေးသား၍ ဖတ်နိုင်သော (-rw-rw-r--) Text ဖိုင်တစ်ခုသာဖြစ်ပါမည်။ Shell Script အဖြစ်အသုံးပြုနိုင်ရန် chmod +x hello.sh ဟု ပါမစ်ရှင်းကို ပြောင်းလည်းပါမည်။

-rwxrwxr-x ဟု Runnable ဖိုင်အဖြစ်ပြောင်းလည်းသွားသည်ကို တွေ့ရပါမည်။ သင်သည် Shell Script ဖိုင်တစ်ခုကို ရေးသားပြီး ဖြစ်ပါလိမ့်မည်။ ./hello.sh ဟု ရိုက်ကြည့်ပါက ရေးသားထားသော hello.sh သည် အလုပ်လုပ်ပြီး Hello B Shell ဟု ဖော်ပြပေးနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။

တစ်ခုသတိထားမိမည် ဖြစ်ပါသည်။ hello.sh ကို ခေါ်ယူရာတွင် ./hello.sh ဟု ရေးသားနေပါသည်။ အကြောင်းမှာ ကွန်ပျူတာတစ်လုံးတွင် ကွန်မန်းများအား ခေါ်ယူရာတွင် အသုံးပြုမည့် နေရာများကို ကြိုတင်သတ်မှတ်ထားရန်လိုအပ်ပါသည်။ ကွန်ပျူတာအတွင်းတွင် အသုံးပြုမည့် ကွန်မန်းများအား PATH ဟု အမည်ရသော ကိန်းရှင်အတွင်းတွင် ကြိုတင်သတ်မှတ်ထားရန်လိုအပ်ပါသည်။

အကယ်၍ hello.sh ရိုက်လိုက်ပါက PATH အတွင်းတွင် hello.sh ကို ရှာဖွေမည် ဖြစ်၏။ မတွေ့ပါက ရှာမတွေ့ပါဟု အဖြေပြန်ထုတ်ပေးမည် ဖြစ်၏။ ယခုတစ်ခေါက်တွင် hello.sh ကို ရေးသားသားသော ဒိုင်အတ္တရီအား PATH အတွင်းတွင် သတ်မှတ်ထားခြင်းမရှိသောကြောင့် နေရာအတိအကျကို ဖော်ပြပေးရန် လိုအပ်ပါသည်။ ./ သည် Current Directory ကို ဖော်ပြနိုင်ပါသဖြင့် ./hello.sh ဟု ရေးသားရခြင်း ဖြစ်ပါသည်။ ဤကဲ့သို့ရေးသားသောကြောင့် current directory အောက်ရှိ hello.sh ကို အလုပ်လုပ်ရန်လိုအပ်သည်ဟု ကွန်ပျူတာမှသိရှိနိုင်ပြီး Hello B Shell ဟု ပြန်လည် ဖော်ပြပေးနိုင်ခြင်းဖြစ်ပါသည်။


ကွန်မန့်များ

ပရိုဂရမ်တစ်ခုသည် ကွန်မန်းများကို စီရီရေထားခြင်းဖြင့် အလုပ်လုပ်စေနိုင်ပါသည်။ သို့ရာတွင် ကွန်မန်းများကြီးသာဆိုပါက လူတစ်ယောက်က ဖက်ကြည့်မည်ဆိုလျှင် နားလည်ရခက်ခဲမည် ဖြစ်သည်။ နောင်တစ်ချမ်း ပြန်ဖတ်ကြည့်မည်ဆိုလျှင် တစ်ခါတစ်လေ ဘာရေးထားမှန်း မသိ ဖြစ်တတ်ပါသည်။

ပရိုဂရမ်များအားနာလည် လွယ်ကူစေရန် ပရိုဂရမ်အတွင်းတွင် အလုပ်လုပ်ရန် မလိုသော်လည်း ရေးသားသူများ နားလည်လွယ်စေရန် ကွန်မန့်များကို ရေးသားလေ့ရှိ၏။ C နှင့် java ဘာသာရပ်များတွင်// /* */ အစရှိသည့် လက္ခဏာများကို အသုံးပြု၍ ကွန်မန့်များကို ရေးသားလေ့ရှိ၏။ Shell ဘာသာရပ်တွင်လည်း ကွန်မန့်များကို ရေးသားနိုင်ပါသည်။

# စ၍ ရေးသားထားသော စာကြောင်းများသည် ကွန်မန့်များဖြစ်ကြ၏။ အထက်ပါ hello.sh အား ကွန်မန့်တစ်ခု ဖြည့်စွက်ရေးသားကြည့်ပါမည်။


#!/bin/sh

# out hello b shell
echo "Hello B Shell"
အထက်ပါအတိုင်း # out hello b shell ဟုရေးသားထားသော စာကြောင်းသည် ကွန်မန့် စာကြောင်းဖြစ်ပါသဖြင့် ပရိုဂရမ်ကအလုပ်လုပ်စရာမလိုပဲ echo "Hello B Shell" ကိုသာ အလုပ်လုပ်စေမည် ဖြစ်ပါသည်။


ယနေ့ဘလောဂ်ဖြင့် Shell Script တစ်ခု ရေးသားပုံကို လွယ်ကူစွာ မိတ်ဆက်ခဲ့ပါသည်။ Shell Script ပရိုဂရမ်တစ်ခုသည် ကွန်မန်းများကို စီရီရေးသားထားသော Text ဖိုင်တစ်ခုဖြစ်ပြီး၊ ကွန်မန်းများအကြားတွင် ရေးသားသူများ ဖတ်၍ နားလည်လွယ်ကူစေရန် ကွန်မန့်များကို ဖြည့်စွက် ရေးသားနိုင်ပါသည်။

နောက်ဘလောဂ်ဖြင့် Shell တွင် အသုံးပြုနိုင်သော ကိန်းရှင်များ အကြောင်းကို ဆက်လက်ဖော်ပြပါဦးမည်။


လေးစားစွာဖြင့်
မင်းလွင်

April 21, 2012

File, Directory နှင့် Link များကို ရေးသားခြင်း

စာမရေးဖြစ်သည်မှာ အတော်ပင်ကြာပြီ ဖြစ်၏။ အခုတလော နေ့တိုင်း အလုပ်နောက်ကျနေသည်က တစ်ကြောင်း၊ စနေတနင်္ဂနွေကျပြန်တော့လည်း ကြားအလုပ်ကို လက်ခံထားပါသဖြင့် မပြီးပြီးအောင် လုံးပမ်းနေရသည်က တစ်ကြောင်း အကြောင်းကြောင်းကြောင့် စာမရေးဖြစ်ပါ။ စာမရေးတာကြာတော့ တစ်ခုခုလိုနေသလိုပင်။ ဒီနေ့တော့ တစ်နာရီလောက် အချိန်ရပါသဖြင့် အရင်ရေးလက်စဖြစ်သော Java 7 ၏ NIO2 ကို ဆက်ပါဦးမည်။

ပြန်နွေးသည့်အနေဖြင့် အရင်ရေးခဲ့ပြီးအကြောင်းများကို အကျဉ်းချုပ် စဉ်းစားကြည့်ပါဦးမည်။ NIO2 သည် Java ၏ File System အင်တာဖေစ်အသစ်တစ်ခု ဖြစ်ပြီး၊ လက်ရှိ File System Interface ၏ အားနည်းချက်များကို ပြုပြင်ရန်ရည်ရွယ်၍ ရေးသားခဲ့သော API အသစ်တစ်ခု ဖြစ်ပါသည်။ File System တစ်ခုလုံးကို ကိုယ်စားပြုအသုံးပြုနိုင်ရန်အတွက် java.nio.file.FileSystem ကလပ်စ်၊ java.io.File အား အစာထိုးလာသည်မှာ java.nio.file.Path အင်တာဖေစ် ဖြစ်၏။ Path အင်တာဖေစ် အားအသုံးပြုနိုင်ရန် ရေးသားထားသော Utility Class မှာ java.nio.file.Files ကလပ်စ် ဖြစ်၏။

ပြီးခဲ့သော အခန်းဆက်များဖြင့် Path အော့ဘဂျက်ကို ရေးသားပုံ၊ ယခင် အသုံးပြုခဲ့သော File အော့ဘဂျက်များနှင့် အပြန်အလှန် ခေါ်ယူအသုံးပြုနိုင်ပုံ၊ အလွယ်တကူ Input Output များကို ရေးသားအသုံးပြုနိုင်ပုံ အစရှိသည်တို့ကို ဖော်ပြခဲ့၏။ ယခု တစ်ခေါက်တွင်လည်း ဆက်လက်၍ Files Utility ကလပ်စ်၏ အသုံးပြု၍ ဖိုင်နှင့် ဒိုင်အတ္တရီများကို ရေးသားပုံကို လေ့လာဖော်ပြသွားပါဦးမည်။

ယခင် IO API တွင် File ကလပ်စ်ကို အသုံးပြု၍ ဖိုင်နှင့် ဒိုင်အတ္တရီများကို အသစ်ရေးသားနိုင်ပါသည်။ Java ၏ IO System အသစ်ဖြစ်သော NIO2 တွင်လည်း၊ ဖိုင်နှင့် ဒိုင်အတ္တရီများကို အသစ်ရေးသားနိုင်ပါသည်။ သို့ရာတွင် Path ၏ လုပ်ဆောင်ချက်အနေဖြင့် မဟုတ်ပဲ Files ကလပ်စ်၏ လုပ်ဆောင်ချက်အနေဖြင့် ပံ့ပုံလာခဲ့ပါသည်။



ဖိုင်များကို ရေးသားခြင်း


ဦးစွာ ဖိုင်တစ်ခုကို အလွယ်တကူ ရေးသားကြည့်ပါမည်။
   FileSystem fs = FileSystems.getDefault();
   Path path1 = fs.getPath("default.txt");
   Files.createFile(path1);

Nio2 တွင် ဖိုင်များကို ရေးသားရာတွင် Files#createFile လုပ်ဆောင်ချက်ကို အသုံးပြုနိုင်ပါသည်။ ပါရာမီတာအနေဖြင့် ရေးသားလိုသည့် Path အော့ဘဂျက်ကို ဖြည့်စွက်ရေးသားရမည် ဖြစ်၏။ အထက်ပါ ကုဒ်များကို ကွန်ပိုင်းလုပ်ပြီး၊ အလုပ်လုပ်ခိုင်းကြည့်ပါက myfile.txt ဆိုသည့် ဖိုင်တစ်ခုကို ပမာဏ 0 byte ဖြင့် တည်ဆောက်နိုင်မည် ဖြစ်သည်။

ရှိနှင့်ပြီးသား ဖိုင်အား create လုပ်ပါက java.nio.file.FileAreadyExistsException ကို ဖြစ်ပေါ်စေမည် ဖြစ်၏။ တဖန် လက်တွေ့မရှိသော ဒိုင်အတ္တရီတွင် ဖိုင်အား တည်ဆောက်မိပါက java.nio.file.NoSuchFileException ကို ဖြစ်ပေါ်စေပါမည်။

တဖန် Linux နှင့် Solaries ကဲ့သို့ POSIX ကို အခြေခံသော Operating System များတွင်၊ ဖိုင်များကို တည်ဆောက်မည် ဆိုပါက အသုံးပြုနိုင်ခွင့်များကို သတ်မှတ်ရေးသားနိုင်မည် ဖြစ်သည်။ အကဲ၍ ဖတ်ရုံသာ ဖတ်နိုင်သော ဖိုင်တစ်ခုကို တည်ဆောက်မည် ဆိုပါက အောက်ပါနာ့မှုနာ အတိုင်း ရေးသားနိုင်မည် ဖြစ်သည်။
   Path path2 = fs.getPath("readOnly.txt");

   Set<PosixFilePermission> pms = 
     PosixFilePermissions.fromString("r--r--r--");
   FileAttribute<Set<PosixFilePermission>> attribute = 
     PosixFilePermissions.asFileAttribute(pms);

   Files.createFile(path2, attribute);
အထက်ပါ စာကြောင်း နံပါတ် ၈ တွင် ဖော်ပြထားသကဲ့သို့၊ Files#createFile လုပ်ဆောင်ချက်၏ ဒုတိယ ပါရာမီတာ အနေဖြင့် ပါမစ်ရှင်းကို သတ်မှတ်ရေးသားနိုင်ပါသည်။ ဒုတိယ ပါရာမီတာ၏ ပုံစံမှာ java.nio.file.attribute.FileAttribute အင်တာဖေစ် ဖြစ်ပါသည်။

FileAttribute အင်တာဖေစ်သည် name နှင့် value လုပ်ဆောင်ချက်များကို ပံ့ပိုးထားပြီး၊ name လုပ်ဆောင်ချက်ဖြင့် Attribute ၏ အမည်ကိုပြန်ပေးပြီး၊ value လုပ်ဆောင်ချက်ဖြင့် Attribute ၏ တန်ဖိုးကိုပြန်ပေးသော လုပ်ဆောင်ချက်ကို ဖြည့်စွက်ရေးသားမည်ဆိုပါက FileAttribute ၏ အော့ဘဂျက်ကို တိုက်ရိုက်ရေးသားနိုင်မည် ဖြစ်၏။ သို့ရာတွင် ဤနမှုနာ၌ PosixFilePermissions ကလပ်စ်ကို အသုံးပြုပြီး၊ FileAttribute ၏ အော့ဘဂျက်ကို ရေးသားထားပါသည်။

PosixFilePermissions ကလပ်၏ နောက်ဆုံးစာလုံးတွင် s ပါသည့်အတိုင်း၊ ဤကလပ်စ်သည် PosixFilePermission enum ကို အသုံးချနိုင်ရန် ပြင်ဆင်ထားသော Utility ကလပ်စ် တစ်ခု ဖြစ်ပါသည်။ အထက်ပါကုဒ်၏ စာကြောင်းနံပါတ် ၄ တွင် ရေးသားထားသည့်အတိုင်း၊ PosixFilePermissions#fromString လုပ်ဆောင်ချက်ကို အသုံးပြုခြင်းအားဖြင့် FilePermission အော့ဘဂျက်များပါဝင်သော java.util.Set ၏ အော့ဘဂျက်ကို ခေါ်ယူအသုံးပြု နိုင်မည် ဖြစ်၏။ fromString လုပ်ဆောင်ချက်၏ ပါရာမီတာသည် Unix အမျိုးအစား OS များတွင်ဖော်ပြလေ့ရှိသော ခွင့်ပြုချက် စာလုံးများ ဖြစ်ပါသည်။ "r--r--r--" သည် Read Only ပါမစ်ရှင်းကို ဖော်ပြပေးနေပါသည်။

စာကြောင်းနံပါတ် ၆ တွင် PosixFilePermissions#asFileAttribute ကို အသုံးပြု၍၊ အထက်ပါ FilePermission အော့ဘဂျက် Set မှတဆင့် FileAttribute အော့ဘဂျက်ကို ခေါ်ယူ နေသည်ကို တွေ့ရပါမည်။

နောက်ဆုံးတွင် Files#create ဖြင့် ပါမစ်ရှင်းကို သက်မှတ်ထားသော File တစ်ခုကို တည်ဆောက်နေခြင်း ဖြစ်ပါသည်။ အထက်ပါ ကုဒ်များကို လက်တွေ့ Fedora Linux အပေါ်တွင် အသုံးပြုကြည့်ပါမည်။


Default ဖြင့် ရေးသားထားသော defalut.txt မှာ Owner နှင့် Group တွင်ရေးသားခွင့်ရှိသော ဖိုင်အဖြစ် တည်ဆောက်ထားသည်ကို တွေ့ရမည် ဖြစ်ပြီး၊ ပါမစ်ရှင်းကို သတ်မှတ်ထားသော readOnly.txt ကိုမူ read only ပါမစ်ရှင်းဖြင့် တည်ဆောက်ထားသည်ကို တွေ့ရပါလိမ့်မည်။

ဖော်ပြပါ ကလပ်ကို Windows အပေါ်တွင် ကွန်ပိုင်းလုပ်၍ အသုံးပြုကြည့်ပါက java.lang.UnsupportedOperationException ကို ဖြစ်ပေါ်စေသည်ကို တွေ့ရပါမည်။ အဘယ်ကြောင့်ဆိုသော် Windows တွင် POSIX ကို Support မလုပ်သောကြောင့် ဖြစ်ပါသည်။


ဒိုင်အတ္တရီကို ရေးသားခြင်း


ဒိုင်အတ္တရီများကိုလည်း ဖိုင်များကဲ့သို့ပင် Files ကလပ်စ်ဖြင့် တည်ဆောက်နိုင်ပါသည်။ အောက်ပါ နမှုနာကို ကြည့်ပါ။
   FileSystem fs = FileSystems.getDefault();
   Path dir1 = fs.getPath("dir1");
   Files.createDirectory(dir1);
   
   Path dir3 = fs.getPath("dir2", "dir3");
   Files.createDirectories(dir3);
ဒိုင်အတ္တရီ တစ်ခုချင်းကို တည်ဆောက်လိုပါက အထက်ပါ စာကြောင်းနံပါတ် ၃ အတိုင်း Files#createDiractory မက်သတ်ကို အသုံးပြုနိုင်ပါသည်။ တဖန် စာကြောင်း ၆ကဲ့သို့ dir2/dir3 လက်ရှိ ဒိုင်အတ္တရီ (Current Directory) မှ dir2 နှင့် dir2/dir3 ကို တည်ဆောက်လိုပါက Files#createDirectories မက်သတ်ကို အသုံးပြုရန်လိုအပ်ပါသည်။

အကယ်၍ ရှိပြီးသား ဒိုင်အတ္တရီ(Directory) တစ်ခုအား Files#createDirectory ဖြင့် တည်ဆောက်မိပါက java.nio.file.FileAlreadyExistsException ကို ဖြစ်ပေါ်စေမည်ဖြစ်သည်။ သို့ရာတွင် Files#createDirectories ကို အသုံးပြုပါက Exception ကို ဖြစ်ပေါ်စေမည်မဟုတ်ပါ။


လင့်ခ်များကို ပြုလုပ်ခြင်း

Java7 အရောက်တွင် Java ဖြင့် လင့်ခ်(link)များကို အသုံးပြုလာနိုင်ပါသည်။ Java ဖြင့် အသုံးပြုနိုင်သော လင့်ခ်များမှာ Hard Link နှင့် Symbolic Link ဟူ၍ နှစ်မျိုးနှစ်စား ခွဲခြားနိုင်ပါသည်။


လင့်ခ်အမာ (Hard Link)

   FileSystem fs = FileSystems.getDefault();
   Path target = fs.getPath("target.txt");
   
   if(!Files.exists(target)) {
    Files.createFile(target);
   }
   
   // Creation of Hard Link
   Path link = fs.getPath("link.txt");
   Files.createLink(link, target);
လင့်ခ်အမာ (Hard Link) များအား အထက်ပါ စာကြောင်း ၁၀ အတိုင်း Files#createLink ကို အသုံးပြု၍ တည်ဆောက်နိုင်ပါသည်။ ပဋ္ဌမ ပါရာမီတာမှာ အသုံးပြုမည့် လင့်ခ်၏ Path အော့ဘဂျက်ဖြစ်ပြီး၊ ဒုတိယ ပါရာမီတာမှာ လင့်ခ်လုပ်မည့် ဖိုင်၏ ပါရာမီတာကို ရေးသားရပါမည်။

လင့်ခ်အမာများကို ရေးသားအသုံးပြုရာတွင် ဖိုင်ကိုသော်၎င်း ဒိုင်အတ္တရီကိုသော်၎င်း ရေးသားအသုံးပြုနိုင်ပါသည်။ သို့ရာတွင် သတိပြုရန် အချက်အနည်းငယ်ရှိပါသည်။

  • Linux, Solaries များတွင် ဖိုင်နှင့် ဒိုင်အတ္တရီများကို လင့်ခ်အမာဖြင့် လင့်ခ်လုပ်နိုင်သော်လည်း၊ Windows မှာတော့ ဖိုင်များကိုသာ လင့်ခ်လုပ်နိုင်ပါသည်။
  • Windows တွင်အသုံးပြုရာတွင် FAT ကိုအသုံးပြုသည့် Volume ဆိုပါက Hard Link များကို အသုံးပြု၍ရမည် မဟုတ်ပါ။
  • Linux, Solaries နှင့် Windows များမှာပါ လင့်ခ်အမာ (Hard Link) များကို လင့်ခ်လုပ်လိုသည့် ဖိုင်၊ ဒိုင်အတ္တရီများနှင့် Volume တစ်ခုအတွင်းမှသာ အသုံးပြုနိုင်ပါသည်။


စင်ဘိုးလစ်လင့်ခ် (Symbolic Link)


လင့်ခ်အမာများနှင့်စာလျှင် စင်ဘိုးလစ်လင့်ခ်များသည် ပို၍သုံးရလွယ်ကူပါသည်။ လက်တွေ့ ရေးသားကြည့်ပါမည်။
   // Creation of Symbolic Link
   Path link = fs.getPath("link.txt");
   Files.createSymbolicLink(link, target);
အထက်ပါအတိုင်း Files#createSymbolicLink မက်သတ်ဖြင့် စင်ဘိုးလစ်လင့်ခ်ကို ရေးသားအသုံးပြုနိုင်ပါသည်။ အထက်ပါကုဒ်များကို Fedora Linux ပေါ်တွင် Run ကြည့်ပါမည်။


အထက်ပါအတိုင်း target.txt ကို ရည်ညွှန်းသော link.txt စင်ဘိုးလစ်လင့်ခ်ကို ရေးသားနိုင်သည်ကို တွေ့ရပါမည်။

Windows အပေါ်တွင်လည်း Windows Vista မှစ၍ စင်ဘိုးလစ်လင့်ခ်များကို ရေးသားအသုံးပြု နိုင်ပါသည်။ သို့ရာတွင် စင်ဘိုးလစ်လင့်ခ်ကို ရေးသားရန် Admin Permission ကို လိုအပ်ပါသည်။ Command Promt ကို Admin ဖြင့်ဖွင့်ပြီး၊ နမှုနာ Symbolic.java ကို ကွန်ပိုင်းလုပ်ပြီး၊ အလုပ်ခိုင်းကြည့်ပါမည်။


အထက်ပါအတိုင်း target.txt ကို ရည်ညွှန်းသည့် စင်ဘိုးလစ်လင့်ခ်ကို ရေးသားနိုင်သည်ကို တွေ့ရပါမည်။

ယခုတစ်ခေါက်တွင် Files Utility Class ကို အသုံးပြု၍ File၊ Directory နှင့် လင့်ခ်များကို ရေးသားနိုင်ပုံကို ဖော်ပြခဲ့၏။ နောက်အခေါက်များတွင်လည်း ဆက်လက်၍ Nio2 နှင့်ပတ်သက်သော အကြောင်းအရာများကို ဆက်လက်ဖော်ပြသွားပါဦးမည်။


လေးစားစွာဖြင့်
မင်းလွင်


ကိုးကား
http://itpro.nikkeibp.co.jp/article/COLUMN/20110830/367909/?ST=develop&mkjt&P=1
http://docs.oracle.com/javase/tutorial/essential/io/check.html