JShell - Quick Start

ဒီအခန်းမှာတော့ JShell ကို ဘယ်လို စပြီး အသုံးပြုသွားမလဲဆိုတာကို လေ့လာသွားကြပါမယ်။ JShell ရဲ့ အခြေခံအသုံးပြုပုံတွေ၊ ပြီးတော့ Help ကို အသုံးပြုပုံတွေနဲ့ Shortcuts တွေအကြောင်းကို ဖေါ်ပြသွားပါမယ်။

Basic Usages

JShell ဟာ JDK ရဲ့ Tool တစ်ခုဖြစ်တဲ့ အတွက် jdk 9 ကို Install လုပ်လိုက်တာနဲ့ JDK Install Directory ရဲ့ bin အောက်မှာ ပါဝင်ပြီး ဖြစ်နေပါတယ်။ JDK 9 ရဲ့ bin directory ကို Environment Variable Path အောက်မှာ ဖြည့်စွက်လိုက်တာနဲ့ JShell ကို စပြီး အသုံးပြုလို့ရမှာ ဖြစ်ပါတယ်။


Start JShell


JShell ကို စတင် အသုံးပြုဖို့ Terminal (Console) ကနေ jshell command ကို ရိုက်ထည့်ပြီး tools ကို invoke လုပ်ရမှာ ဖြစ်ပါတယ်။ ဒီလို Invoke လုပ်နိုင်အောင်လဲ jshell.exe file ရှိတဲ့ jdk installed Directory အောက်က bin directory ကို PATH environment variable ထဲမှာ သွားရောက်ဖြည့်စွက်ထားရင် ရပါပြီ။

PATH ထဲမှာ လမ်းကြောင်းထည့်ပုံကိုတော့ JDK Installation မှာကထဲက ဖေါ်ပြထားပြီး ဖြစ်တဲ့ အတွက် အဲ့ဒီအတိုင်း ဆောင်ရွက်လိုက်မယ်ဆိုရင်ရမှာ ဖြစ်ပါတယ်။

Mins-MacBook-Pro:~ minlwin$ jshell
|  Welcome to JShell -- Version 9
|  For an introduction type: /help intro

jshell> 

ဒီအတိုင်း jshell> လို့ပေါ်လာခဲ့ရင် JShell ရဲ့ REPL Mode ကို စတင် အသုံးပြုလို့ရမှာ ဖြစ်ပါတယ်။


Writing Variable


ဆက်လက်ပြီး Variable တွေကို အသုံးပြုကြည့်ပါမယ်။ အရင်ဆုံး Variable တွေကို Declare လုပ်ကြည့်ပါမယ်။ ပြီးရင် သတ်မှတ်ထားတဲ့ Variable ကို တန်ဖိုးတစ်ခု Assign လုပ်ကြည့်ပါမယ်။ ပြီးတော့ အဲ့ဒီ Variable ကို ပြန်ပြီး Access လုပ်ပြီး အသုံးပြုကြည့်ပါမယ်။

jshell> String school
school ==> null

jshell> school = "Java Developer Class"
school ==> "Java Developer Class"

jshell> System.out.println(school)
Java Developer Class

JShell ကို အသုံးပြုတဲ့ နေရာမှာ Statement တစ်ကြောင်းရေးပြီးတိုင်းမှာလဲ Semi Comma ကို ပိတ်စရာမလိုအပ်ပါဘူး။ Variable ကို Declare လုပ်တဲ့နေရာမှာလဲ အထက်ပါအတိုင်း String school လို့ ရေးသားလိုက်တာနဲ့ school ဆိုတဲ့ String Type Variable ကို Default တန်ဖိုးဖြစ်တဲ့ null နဲ့ သတ်မှတ်ပေးသွားမှာ ဖြစ်ပါတယ်။

တဖန် ရေးသားထားတဲ့ Variable နေရာကို တန်ဖိုးတစ်ခုခု Assign လုပ်လိုချင်တဲ့ အခါမှာလဲ school = “Java Developer Class” ဆိုပြီး ရေးသားနိုင်ပါတယ်။ အဲ့ဒီလို ရေးသားလိုက်တဲ့ အခါမှာလဲ တန်ဖိုးပြောင်းသွားတယ်ဆိုတာကို school ==> “Java Developer Class” ဆိုပြီး ဖေါ်ပြပေးမှာ ဖြစ်ပါတယ်။

အထက်ပါအတိုင်း မိမိရေးသားထားတဲ့ Variable ကို Method တစ်ခုခုရဲ့ Argument အနေနဲ့ အသုံးပြုလိုတဲ့ အခါမှာလဲ System.out.println(school) ဆိုပြီးရေးသား အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။


Writing Enum


Enum ဆိုတာဟာ Java 5 မှာ စတင်ပါဝင်ခဲ့တဲ့ Static Class အမျိုးအစားတစ်ခုဖြစ်ပါတယ်။ ဒီတစ်ခေါက်တော့ JShell ကို အသုံးပြုပြီး Enum တစ်ခုကို Declare လုပ်ကြည့်ပြီး ရေးသားထားတဲ့ Enum ကို ပြန်ပြီး အသုံးပြုကြည့်ပါမယ်။

Enum တွေကို Declare လုပ်မယ်ဆိုရင်လဲ အထက်ပါအတိုင်း enum Course {} ဆိုပြီး ရေးသားရပါမယ်။ တဖန် enum ရဲ့ Member တွေကိုလဲ {} အတွင်းမှာ ရေးသားနိုင်ပါတယ်။ အထက်ပါအတိုင်း ရေးသားပြီး Enter Key ကို Press လုပ်လိုက်ရင် create enum Course ဆိုပြီး enum တစ်ခုကို Create လုပ်ပြီးကြောင်းကို ဖေါ်ပြပေးမှာ ဖြစ်ပါတယ်။

တဖန် မိမိရေးသားထားတဲ့ Enum ကိုလဲ ပြန်ပြီး Course.values() ဆိုပြီး ပြန်ပြီး အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။ အထက်ဖေါ်ပြပါထဲကလို Line အများကြီးကို အသုံးပြုပြီး ရေးသားရတဲ့ for statememt လို နေရာမျိုးမှာလဲ Line တစ်ကြောင်းဆုံးရင် Enter ကို နှိပ်ပြီး ဆက်တိုက်ရေးသားနိုင်မှာ ဖြစ်ပါတယ်။

Line အများကြီးပါတဲ့ Statement တွေဆိုရင်တော့ Statement ပြီးဆုံးသွားမှသာ ရေးသားထားတဲ့ Code တွေကို Evaluate လုပ်ပြီး အဖြေကို ပြန်ပြပေးမှာ ဖြစ်ပါတယ်။ ဒါ့ကြောင့် for statement ရဲ့ အဆုံးဖြစ်တဲ့ } ကို ရိုက်နှိပ်ပြီးတော့မှသာ အဖြေတွေကို ပြန်ပြပေးနေတာဖြစ်ပါတယ်။


Writing Methods


ဆက်လက်ပြီး JShell နဲ့ Method တွေကို ဘယ်လိုရေးမယ်ဆိုတာကို လေ့လာသွားကြပါမယ်။ Method တွေကို ရေးတဲ့ နေရာမှာ Method တွေကို ဘယ်လို ရေးမလဲ၊ ပြီးတော့ Method တွေကို ဘယ်လို Invoke လုပ်မလဲဆိုတာကို လေ့လာသွားပါမယ်။ တဖန် Method တွေလို့ ပြောတဲ့ နေရာမှာလဲ Argument မပါတဲ့ Method တွေ ပြီးတော့ Argument ပါတဲ့ Method တွေ၊ ပြီးတော့ Return ပြန်တဲ့ Method တွေ၊ Return မပြန်တဲ့ Method တွေ ဆိုပြီး ရှိပါတယ်။

Method တွေကို Invoke လုပ်တဲ့ နေရာမှာလဲ Return ပြန်တဲ့ Method တွေဆိုရင် Return ပြန်လာတဲ့ တန်ဖိုးတွေကို Variable တစ်ခုမှာ ဘယ်လို Assign လုပ်မယ်ဆိုတာကို လက်တွေ့ ရေးသားလေ့လာကြည့်ပါမယ်။

အထက်ပါ နမူနာထဲမှာတော့ sayHello() ဆိုတဲ့ Argument လဲမပါ Return လဲ မပြန်တဲ့ Method တစ်ခုကို ရေးသားပါတယ်။ အထက်ပါအတိုင်း Method ကို ရေးသားပြီးတဲ့ အခါမှာ created method sayHello() ဆိုပြီး Method ကို ရေးသားပြီးပြီဖြစ်ကြောင်းကို ပြန်ပြီး ဖေါ်ပြပါတယ်။

ထိုနောက် sayHello() ဆိုပြီး ရေးသားခဲ့တဲ့ sayHello() method ကို Invoke လုပ်လိုက်တဲ့ အခါမှာ အဲ့ဒီ Method ထဲမှာ ရေးသားခဲ့တဲ့ လုပ်ဆောင်ချက်တွေကို ပြန်ပြီး ဖေါ်ပြပေးနိုင်မှာ ဖြစ်ပါတယ်။

အထက်ပါနမူနာကတော့ String name ဆိုတဲ့ Argument တစ်ခုကို ယူတဲ့ sayHello Method ကို ရေးသားကြည့်တာပါ။ အရှေ့မှာ ရေးခဲ့တဲ့ Method နဲ့ Method Name ချင်းတူပါတယ်။ ဒါပေမဲ့ Argument List တွေမတူကြပါဘူး။ ပထမ sayHello မှာက Argument မပါပေမဲ့ ဒုတိယ တစ်ကြိမ်ရေးတဲ့ sayHello Method မှာတော့ String တစ်ခုကို Argument အနေနဲ့ ရယူပါတယ်။

Java Compiler က ဒီလိုမျိုး နာမည်တူပြီး Argument မတူတဲ့ Method တွေကို မတူညီတဲ့ Method တွေလို့ သတ်မှတ်ပါတယ်။ ဒါ့ကြောင့် sayHello() ဆိုပြီး ဘာ Parameter မှ မပါပဲ ရေးသားခဲ့ရင် Argument မပါတဲ့ sayHello() method ကို Invoke လုပ်မှာ ဖြစ်ပြီး၊ sayHello(school) ဆိုပြီး String Type Variable school ကို Parameter အနေနဲ့ ပေးပြီး invoke လုပ်တဲ့ အခါမှာ Argument ပါတဲ့ sayHello(String name) method ကို Invoke လုပ်မှာ ဖြစ်ပါတယ်။

ဒီလိုမျိုး method name တူပြီး Argument List မတူတဲ့ Method တွေကို ရေးသားခြင်းကို Method Overload လုပ်တယ်လို့ ခေါ်ပါတယ်။

အထက်နမူနာမှာတော့ Argument နှစ်ခုကိုရယူပြီး၊ return ပြန်တဲ့ add(int a, int b) method ကို ရေးသားထားတာဖြစ်ပါတယ်။ အဲ့ဒီ Method ထဲမှာတော့ int variable နှစ်ခုကို Argument အနေနဲ့ ရယူပြီး a နဲ့ b ကို ပေါင်းပြီး ရလဒ်ကို Return ပြန်ပေးနေပါတယ်။ တဖန် add method ကို invoke လုပ်တဲ့ နေရာမှာလဲ int result = add(10, 3) ဆိုပြီး 10 နဲ့ 3 ကို a နဲ့ b နေရာကို ပေးပြီး ခေါ်ပါတယ်။ ရလာတဲ့ တန်ဖိုးကို int variable result မှာ အစားထိုးပါတယ်။ အဲ့ဒီ Statement ကို Evaluate လုပ်ပြီးတဲ့ အခါမှာ result ==> 13 ဆိုပြီး result ရဲ့ တန်ဖိုးဟာ 13 ဖြစ်သွားပါပြီဆိုပြီး ဖေါ်ပြနေတာ ဖြစ်ပါတယ်။


Writing Class


ကျွန်တော်တို့ ဒီတစ်ခေါက်တော့ Class တွေကို ရေးကြည့်ပါမယ်။ Class ထဲမှာ Instance Variable တွေပါမယ်။ ပြီးတော့ Method တွေ၊ ပြီးတော့ Constructor ပါပါမယ်။ ပြီးတော့ ရေးထားတဲ့ Class ကနေ Object တစ်ခုကို တည်ဆောက်ကြည့်ပြီး အဲ့ဒီ Object ရဲ့ Method တွေကို Invoke လုပ်ကြည့်ပါမယ်။

အထက်ပါ နမူနာထဲမှာတော့ name ဆိုတဲ့ Instance Variable တစ်ခုရယ်၊ Argument တစ်ခုယူတဲ့ Constructor တစ်ခုရယ်၊ greet() ဆိုတဲ့ Method တစ်ခုပါတဲ့ Student Class တစ်ခုကို ရေးသားထားပါတယ်။ အဲ့ဒီ အတိုင်းရေးပြီးရင် created class Student ဆိုပြီး Student Class ကို ရေးသားပြီးပြီဖြစ်ကြောင်း ဖေါ်ပြမှာ ဖြစ်ပါတယ်။

ဒါဆိုရင် ဒီ Student Class နဲ့ ဘာလုပ်လို့ရမလဲ။ Student အမျိုးအစား Object တွေကို တည်ဆောက်လို့ရမှာ ဖြစ်ပြီး၊ အဲ့ဒီ Student Object ကနေ greet() ဆိုတဲ့ လုပ်ဆောင်မှု့တွေကို ဆောင်ရွက်ပေးနိုင်မှာ ဖြစ်တယ်။

အထက်ပါ ကုဒ်တွေထဲမှာတော့ အရင်ဆုံး aung ဆိုတဲ့ Student Type Variable နေရာကို new Student(“Aung Aung”) ဆိုပြီး Object တစ်ခုကို တည်ဆောက်ပြီး အစားထိုးပါတယ်။ ဒါ့ကြောင့် aung ဆိုတဲ့ Variable နေရာရဲ့ တန်ဖိုးဟာ Student Object က အစားထိုးသွားပါပြီဆိုပြီး ဖေါ်ပြပေးနိုင်တာ ဖြစ်ပါတယ်။

အဲ့ဒီနောက်မှာ aung.greet() ဆိုပြီး Student Object ရဲ့ greet() method ကို လှမ်းပြီး Invoke လုပ်ခိုင်းပါတယ်။ ဒါ့ကြောင့် Hello! My name is Aung Aung ဆိုပြီး greet() method ထဲက လုပ်ဆောင်မှု့တွေကို ဆောင်ရွက်ပေးနိုင်တာ ဖြစ်ပါတယ်။


Writing Interface


ဒီနေရာမှာတော့ JShell ကို အသုံးပြုပြီး Interface ကို ရေးသားကြည့်ပါမယ်။ Interface ဆိုတာက 100% Abstract Class တွေဖြစ်ပြီး Object တစ်ခုကနေ အသုံးပြုနိုင်တဲ့ Method တွေကို စုစည်းဖေါ်ပြပေးနိုင်ပါတယ်။ Interface ကို Object တွေရဲ့ Type အနေနဲ့ အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။

ဒီနမူနာထဲမှာတော့ Interface တစ်ခုကို အရင် ရေးသားကြည့်ပါမယ်။ ထိုနောက် Interface ကို Implement လုပ်ထားတဲ့ Class တစ်ခုကို ရေးသားပါမယ်။ ပြီးကာမှ Interface Object ကို Implement လုပ်ထားတဲ့ Class ကနေ တဆင့် Object ဆောက်ကြည့်မယ်။ ဆက်လက်ပြီး Anonymous Class ကနေလဲ Object ဆောက်ကြည့်ပါမယ်။ နောက်ထပ် Lambda Expression ကို အသုံးပြုပြီးလဲ Interface Object ကို တည်ဆောက် အသုံးပြုကြည့်ပါမယ်။

အထက်ပါ နမူနာမှာတော့ add method တစ်ခုပါတဲ့ Addable Interface တစ်ခုကို တည်ဆောက်လိုက်ပါတယ်။ Abstract Method တစ်ခုသာပါတဲ့ Interface ဖြစ်တဲ့ အတွက် Addable ကို Lambda Expression နဲ့လဲ အစားထိုးရေးသားနိုင်မှာ ဖြစ်ပါတယ်။

ဆက်လက်ပြီး Adder Interface ရဲ့ Object တွေကို ပုံစံအမျိုးမျိုးနဲ့ တည်ဆောက် ရေးသားသွားပါမယ်။

ဒီနေရာမှာတော့ ရှေ့က ရေးခဲ့တဲ့ Addable Interface ကို implement လုပ်ထားတဲ့ Adder Class ကို အရင်ဆုံး ရေးသားပါတယ်။ Inerface ကို Implement လုပ်လိုက်ပြီဆိုတာနဲ့ Interface ထဲမှာ ရေးသားထားတဲ့ abstract method ဖြစ်တဲ့ add method ကို Override လုပ်ပြီးရေးသားရပါတော့မယ်။

Addable ထဲမှာ ရေးသားထားတဲ့ add method ကို ကြည့်ပါ။ public လဲ​မရေးထားသလို abstract လဲ မရေးထားပါဘူး။ ပြီးတော့ method body လဲမပါတဲ့ အတွက် Abstract Method ဖြစ်ပါတယ်။ Interface တွေဟာ default abstract နဲ့ public ဖြစ်တဲ့ အတွက် abstract နဲ့ public ကို မရေးထားလဲ public abstract ဖြစ်နေပါတယ်။

ဒါပေမဲ့ Implement လုပ်တဲ့ Adder Class ထဲမှာတော့ public ကိုမဖြစ်မနေ ရေးသားရမှာ ဖြစ်ပြီး၊ Method Body ကိုလဲ ရေးသားရမှာ ဖြစ်ပါတယ်။

ဆက်လက်ပြီး Addable Type ဖြစ်တဲ့ a1 နေရာကို Adder Class ကနေ တဆင် new Adder() ဆိုပြီး Object ကို ဆောက်ပြီး အစားထိုးပါတယ်။ Interface Type Variable တွေကနေ အဲ့ဒီ Interface ကို Implement လုပ်ပြီး ရေးသားထားတဲ့ Class  ရဲ့ Object တွေကို Reference လုပ်နိုင်တဲ့ အတွက် ဖြစ်ပါတယ်။

ဒီနေရာမှာ a1 ရဲ့ Type ဟာ Addable Interface ဖြစ်ပေမဲ့ နောက်ကွယ်မှာ ရှိတဲ့ Object ကတော့ Adder Class ရဲ့ Object ဖြစ်ပါတယ်။ ဆက်လက်ပြီး d1 နေရာကို a1.add(10, 11) ကို Invoke လုပ်ပြီး ရလာတဲ့ ရလဒ်နဲ့ အစားထိုးပါတယ်။ a1 ရဲ့ add(10,11) ကို ခေါ်လိုက်တာဖြစ်ပေမဲ့ တကယ် အလုပ်လုပ်သွားတာကတော့ Adder Class ကနေ တည်ဆောက်ထားတဲ့ Object ရဲ့ add method က အလုပ်လုပ်သွားတာဖြစ်ပါတယ်။ ဒါ့ကြောင့် d1 ရဲ့ တန်ဖိုးဟာ 21.0 ဖြစ်သွားပါပြီလို့ ပြန်ပြောပြနိုင်တာဖြစ်ပါတယ်။

ဒီတစ်ခေါက်ကတော့ Addable Interface ရဲ့ Object ကို Anonymous Class ကနေ တည်ဆောက် အသုံးပြုကြည့်ပါမယ်။

Interface Object တွေကို Anonymous Class တွေကနေလဲ ရေးသား နိုင်ပါတယ်။ အထက်ပါအတိုင်း new Addable() ဆိုပြီး Interface ကိုခေါ်ပြီး လိုအပ်တဲ့ Abstract တိုက်ရိုက်ဒီနေရာမှာပဲ Implement လုပ်ပြီး ရေးသားရပါတယ်။ ဒီနေရာမှာကြည့်မယ်ဆိုရင် a2 ရဲ့ တန်ဖိုးနေရာမှာ Class Name မပါပဲ ရှိနေတာကို တွေ့ရပါမယ်။ ဒါ့ကြောင့်ဒီလို Class မျိုးကို Anonymous Class လို့ခေါ်တာဖြစ်ပါတယ်။

a2.add(10, 11) လို့ Invoke လုပ်လိုက်ရင်လဲ တန်ဖိုးဟာ 21 ဖြစ်တယ်လို့ ဖေါ်ပြနိုင်တာဖြစ်ပါတယ်။

Addable Interface ဟာ Single Abstract Method Interface ဖြစ်တဲ့ အတွက် Lambda Expression  နဲ့လဲ ရေးသားနိုင်ပါတယ်။ ဒါ့ကြောင့် a3 Variable ကို (a,b) -> a + b ဆိုပြီး Lambda Expression နဲ့ အစားထိုးရေးသားနိုင်ခြင်း ဖြစ်ပါတယ်။

a3.add(10, 11) လို့ Invoke လုပ်လိုက်တဲ့အခါမှာလဲ တန်ဖိုးဟာ 21 ဖြစ်တယ်လို့ ဖေါ်ပြနိုင်တာဖြစ်ပါတယ်။

Lambda Expression နဲ့ ရေးသားလို့ရတဲ့ နေရာတိုင်းကို Method Reference နဲ့လဲ ရေးသားနိုင်ပါတယ်။ အထက်ပါ နမူနာကတော့ Method Reference ကို အသုံးပြုပြီး ရေးသားထားတာ ဖြစ်ပါတယ်။ a4 ရဲ့ add method ကို Invoke လုပ်ကြည့်တဲ့ အခါမှာလဲ မှန်ကန်တဲ့ အဖြေကို ဖေါ်ပြနိုင်တာကို တွေ့ရပါတယ်။

Using Helps & Commands

JShell ကို အသုံးပြုရင် Java Statement တွေကို Evaluate လုပ်ပြီး အဖြေကို ချက်ချင်းပြန်ပြပေးနိုင်တယ်ဆိုတာကို လက်တွေ့ လေ့လာခဲ့ပါတယ်။ ဒါပေမဲ့ JShell ကို အသုံးပြုတဲ့ နေရာမှာ ပိုပြီး အသုံးပြုရတာလွယ်ကူစေရန် ပြင်ဆင်ထားတဲ့ Commands တွေနဲ့ Help Feature တွေလဲပါဝင်ပါတယ်။

JShell မှာ အသုံးပြုနိုင်တဲ့ Function တွေကိုတော့ /help command ကို အသုံးပြုပြီး သိရှိစေနိုင်ပါတယ်။

တဖန် မိမိရှာဖွေလိုတဲ့ Command ရဲ့ အသုံးပြုပုံကို သိရှိလိုပါက /? ကို အသုံးပြုပြီး ရှာဖွေနိုင်ပါတယ်။

Listing Sources


ဆက်လက်ပြီး အသုံးများတဲ့ Command တွေကို လေ့လာသွားပါမယ်။ အရင်ဆုံးမိမိ ရေးသားထားခဲ့တဲ့ Source တွေကို ပြန်ကြည့်လိုပါက /list ဆိုတဲ့ Command ကို အသုံးပြုနိုင်ပါတယ်။

JShell ပေါ်မှာ မိမိရေးသားခဲ့တဲ့ Source တွေကို ID နံပါတ်နဲ့ အတူ ဖေါ်ပြပေးနိုင်မှာ ဖြစ်ပါတယ်။

တဖန် ID ကို ရွေးချယ်ပြီး Execute လုပ်ချင်တယ်ဆိုရင်လဲ /[ID] ကို အသုံးပြုပြီး ရေးသားနိုင်မှာ ဖြစ်ပါတယ်။


Listing Variables


မိမိရေးသားခဲ့တဲ့ Variables တွေကို ပြန်ပြီး ကြည့်လိုပါက /vars Command ကို အသုံးပြုနိုင်ပါတယ်။

Listing Methods


မိမိရေးသားခဲ့တဲ့ Methods တွေကို ပြန်ပြီး ကြည့်လိုပါက /methods Command ကို အသုံးပြုနိုင်ပါတယ်။

Listing Types


တဖန် မိမိရေးသားခဲ့တဲ့ Type အဖြစ် အသုံးပြုနိုင်တဲ့ Class, Interface နဲ့ Enum တို့ကို /types Command ကို အသုံးပြုပြီး ပြန်ကြည့်နိုင်ပါတယ်။

Edit with External Editor


တဖန် မိမိရေးသားထားခဲ့တဲ့ Type တွေကို External Editor ကို အသုံးပြုပြီး ပြုပြင်လိုတဲ့အခါမျိုးမှာ /edit [source] Command ကို အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။

/edit sayHello လို့ ရေးလိုက်တာနဲ့ sayHello Method တွေကို External Editor နဲ့ ဖွင့်ပေးမှာ ဖြစ်ပါတယ်။

ပြင်ဆင်လိုတဲ့ နေရာကို ပြင်ဆင်ပြီး Accept ကို နှိပ်လိုက်ပါက Source ထဲမှာလဲ ပြောင်းပေးမှာ ဖြစ်ပါတယ်။

အထက်ပါအတိုင်း Hello JShell ကို We Love JDC လို့ပြောင်းပြီး Accept ကို နှိပ်လိုက်ပါမယ်။

အထက်ပါအတိုင်း sayHello() ဆိုပြီး Method ကို Invoke လုပ်လိုက်ရင် We Love JDC ဆိုပြီး ပြောင်းသွားမှာ ကိုတွေ့ရပါမယ်။



Listing Imports


JShell ထဲမှာ Default အတိုင်းပါဝင်တဲ့ imports တွေနဲ့ မိမိရေးသားထားတဲ့ imports တွေကို သိရှိလိုပါက /imports Commands ကို အသုံးပြုနိုင်ပါတယ်။

အထက်မှာ မြင်ရတဲ့ အတိုင်း JShell ထဲမှာ အသုံးများတဲ့ Package တွေကိုပဲ Import လုပ်ထားတာ ဖြစ်ပါတယ်။ ဒါဟာ Java 9 မှာ စတင်ပါဝင်လာတဲ့ Modularity ကို အသုံးပြုပြီး Basic Module ကိုပဲ Import လုပ်ထားတဲ့ အတွက် ဖြစ်ပါတယ်။ နောက်အခန်းများမှာ Modularity နဲ့ ပတ်သက်ပြီး ဆက်လက် ဖေါ်ပြသွားပါမယ်။

Date And Time API ထဲက Class တွေကို အသုံးပြုလိုပါက ဒီအတိုင်းရေးမယ်ဆိုရင် import ထဲမှာ မပါဝင်တဲ့ အတွက် Error တက်မှာ ဖြစ်ပါတယ်။ အသုံးပြုချင်တယ်ဆိုရင်တော့ မိမိကိုယ်တိုင် import လုပ်ပြီး ရေးသားရမှာ ဖြစ်ပါတယ်။

အထက်ပါအတိုင်း java.time.LocalDate ကို import လုပ်ပြီး ရေးသားပါမှ​ အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။

Shortcuts

Console Program အတော်များများမှာ Shortcuts တွေဟာ မရှိမဖြစ် လိုအပ်တဲ့ Feature တစ်ခုဖြစ်ပါတယ်။ JShell မှာလဲ Code Snippest တွေကို အလွယ်တကူရေးသားနိုင်အောင် Shortcuts တွေကို ပြင်ဆင်ထားတာကို တွေ့ရပါတယ်။

ဘယ်လို Shortcuts တွေကို အသုံးပြုနိုင်တယ်ဆိုတာကို သိရှိလိုပါက /help shortcuts ဒါမှမဟုတ် /? shortcuts command ကို အသုံးပြုနိုင်ပါတယ်။

အထက်ပါအတိုင်း JShell မှာ အသုံးပြုနိုင်တဲ့ Shortcuts ၃ မျိုးရှိတာကို တွေ့ရပါတယ်။ OS အပေါ်မှာ မူတည်ပြီး အသုံးပြုနိုင်တဲ့ Key တွေ မတူညီနိုင်တာ ဖြစ်တဲ့ အတွက် အသုံးပြုခါနီးမှာ /help နဲ့ ပြန်ကြည့်သင့်ပါတယ်။


Tab Key


Tab Key ဟာ အမတန် အသုံးဝင်တဲ့ Shortcut တစ်မျိုးဖြစ်ပါတယ်။ Code Complete လို Function မျိုးကိုလဲရရှိနိုင်သလို၊ method တွေရဲ့ Argument တွေနဲ့ Constructor Overload တွေကိုလဲ သိရှိနိုင်ပါတယ်။

အထက်ပါအတိုင်း String လို့ရိုက်ပြီး Tab Key ကို နှိပ်လိုက်ပါက String နဲ့စတဲ့ Type တွေကို ဖေါ်ပြပေးနိုင်တာကို တွေ့ရပါမယ်။

တဖန် String. ဆိုပြီး Tab Key ကို နှိပ်လိုက်ပါက String Class နဲ့ အသုံးပြုနိုင်တဲ့ static Method တွေကို ဖေါ်ပြပေးနိုင်တာကို တွေ့ရပါတယ်။

အထက်ပါအတိုင်း new StringBuffer( လို့ရိုက်ပြီး Tab Key ကို နှိပ်လိုက်ပြန်ရင်လဲ StringBuffer ရဲ့ Override လုပ်ထားတဲ့ Constructor တွေကို ဖေါ်ပြပေးနိုင်တာကို တွေ့ရပါမယ်။

တဖန် sb.append( ဆိုပြီး Tab Key ကိုနှိပ်ရင်လဲ Overload လုပ်ထားတဲ့ Method တွေကို ဖေါ်ပြပေးမှာ ဖြစ်တဲ့ အတွက် မိမိရေးသားလိုတဲ့ Method ကို အသုံးပြုပြီး အလွယ်တကူရေးသားနိုင်မှာ ဖြစ်ပါတယ်။



Shift + Tab + i


အထက်ပါ Short Cut ကတော့ import တွေကို အကူအညီပေးနိုင်တဲ့ Shortcut ဖြစ်ပါတယ်။

အထက်ပါအတိုင်း import မလုပ်ရသေးတဲ့ LocalDate ကို ရိုက်ပြီးတာနဲမ Shft + Tab ကို တွဲပြီး နှိပ်ပါမယ်။ လွှတ်ပြီးတာနဲ့ i ကို ရိုက်လိုက်ရင် ဘာရွေးမလဲဆိုတာကို ဖေါ်ပြပေးမှာ ဖြစ်ပါတယ်။

အဲ့ဒီနေရာမှာ 0 ကို ရွေးခဲ့ရင် ဘာမှ လုပ်မှာ မဟုတ်ပဲ၊ 1 ကို ရွေးခဲ့ရင် java.time.LocalDate ကို import လုပ်မှာ ဖြစ်ပါတယ်။ ထိုကဲ့သို့ Shortcut ကို အသုံးပြုပြီးလဲ import တွေကို အလွယ်တကူ အသုံးပြုနိုင်မှာ ဖြစ်ပါတယ်။


Shift + Tab + v


Variable တွေကို Create လုပ်ပေးနိုင်တဲ့ Shortcut ဖြစ်ပါတယ်။ Expression တစ်ခုကို ရေးသားပြီး အဖြေကို ကြည့်ပြီးမှ Variable တစ်ခုမှာ Assign လုပ်လိုတဲ့ အခါမျိုးမှာ အသုံးဝင်ပါတယ်။

အထက်ပါအတိုင်း LocalDate.now() ရဲ့ ရလဒ်ကိုစစ်ပြီးတော့မှ Up Arrow ကို အသုံးပြုပြီး LocalDate.now() ကို ပြန်ပြီး Console မှာ ဖေါ်ထားပါမယ်။ ပြီးတော့ ချက်ချင်းဆိုသလိုပဲ Shift + Tab ကိုနှိပ်ပါမယ်။ ချက်ချင်းပြန်လွှတ်ပြီး v ကို နှိပ်ပါမယ်။

အထက်ပါအတိုင်း LocalDate = LoalDate.now() ဆိုပြီး LocalDate နဲ့ = ရဲ့ကြား Variable Name နေရာမှာ Cursor ကို ချထားပေးမှာ ဖြစ်ပါတယ်။ အဲ့ဒီနေရာမှာ နှစ်သက်တဲ့ Variable Name ကိုပေးပြီး Variable အသစ်တစ်ခုကို ရေးသားနိုင်မှာ ဖြစ်ပါတယ်။

Expression ရဲ့ ရလဒ်ကို စစ်ဆေးပြီးမှ Variable အသစ်တစ်ခုကို ရေးသားလိုတဲ့ အခါမျိုးမှာ အသုံးဝင်မှာ ဖြစ်ပါတယ်။


/exit or Ctl + d


နောက်ဆုံး JShell ကို အဆုံးသတ်လိုတဲ့ အခါမျိုးမှာ /exit Command ဒါမှမဟုတ် CTL + d Shortcut ကို အသုံးပြုပြီး JShell REPL ကို အဆုံးသတ်စေနိုင်မှာ ဖြစ်ပါတယ်။

ဆက်ပါဦးမည်

မင်းလွင်