Syntax နှင့် Data Types

Java ဟာ စည်းကမ်းကြီးတဲ့ Language တစ်ခုပါ။ Code ရေးတဲ့အခါ လိုက်နာရမယ့် အခြေခံ စည်းမျဉ်းတွေကို အရင်ဆုံး လေ့လာကြည့်ရအောင်။

ပထမဆုံး Java Program

Java မှာ Code မှန်သမျှကို Class ထဲမှာပဲ ရေးရပါတယ်။ ပြီးတော့ Program စတင် အလုပ်လုပ်ဖို့အတွက် main ဆိုတဲ့ Method (Function) တစ်ခု မဖြစ်မနေ လိုအပ်ပါတယ်။

// Main ဆိုတာ Class နာမည်ပါ (ဖိုင်နာမည်နဲ့ တူရပါမယ် - Main.java)
public class Main {

    // ဒါက Program စတင် အလုပ်လုပ်မယ့် နေရာပါ
    public static void main(String[] args) {
        // Screen ပေါ်မှာ စာထုတ်ပြတာပါ
        System.out.println("မင်္ဂလာပါ Java!");
    }
}

သတိပြုရန်:

Java မှာ စာကြောင်းတိုင်းရဲ့ အဆုံးမှာ Semicolon ; မဖြစ်မနေ ထည့်ပေးရပါတယ်။
Class နာမည်တွေကို အမြဲတမ်း အကြီးစာလုံး (Capital Letter) နဲ့ စရပါတယ်။

Variables (ကိန်းရှင်များ)

Python မှာလို Variable နာမည်ပေးပြီး တန်းသုံးလို့ မရပါဘူး။ Java မှာ Variable တစ်ခု မကြေညာခင် “ဒါက ဘာအမျိုးအစား (Data Type) လဲ” ဆိုတာကို အရင်ပြောပြရပါတယ်။

// မှန်ကန်သော ရေးနည်း
int age = 20;
String name = "Aung Aung";

// မှားယွင်းသော ရေးနည်း (Error တက်ပါမယ်)
// age = 20; (ဘာအမျိုးအစားလဲ မပြောထားလို့ပါ)

Data Types (ဒေတာ အမျိုးအစားများ)

Java မှာ အဓိက Data Type တွေကို အုပ်စု (၂) စု ခွဲထားပါတယ်။

1. Primitive Data Types (အခြေခံ အမျိုးအစားများ)

ဒါတွေက Java မှာ မူလကတည်းက ပါတဲ့ အခြေခံ အကျဆုံး အမျိုးအစားတွေပါ။

int (Integer): ကိန်းပြည့်တွေအတွက် သုံးပါတယ်။
```
int count = 100;
```
double: ဒသမကိန်းတွေအတွက် သုံးပါတယ်။
```
double price = 99.99;
```
boolean: အမှန်/အမှား (True/False) အတွက် သုံးပါတယ်။ (Python လို အကြီးစာလုံးနဲ့ မစပါဘူး)
```
boolean isStudent = true;
```
char (Character): စာလုံး တစ်လုံးတည်းအတွက် သုံးပါတယ်။ Single Quote '' နဲ့ ရေးရပါတယ်။
```
char grade = 'A';
```

2. Non-Primitive (Reference) Data Types

ဒါတွေကတော့ Object တွေ ဖြစ်ပါတယ်။ အသုံးအများဆုံးကတော့ String ပါ။

String: စာသားတွေအတွက် သုံးပါတယ်။ Double Quote "" နဲ့ ရေးရပါတယ်။ (S ကို အကြီးနဲ့ ရေးရပါတယ်)
```
String message = "Hello World";
```

Type Casting (အမျိုးအစား ပြောင်းလဲခြင်း)

တစ်ခါတလေ Data Type တစ်ခုကနေ နောက်တစ်ခုကို ပြောင်းချင်တဲ့အခါ သုံးပါတယ်။

1. အလိုအလျောက် ပြောင်းသွားခြင်း (Widening Casting) အသေးကနေ အကြီးကို ပြောင်းတာပါ။ (ဥပမာ - int ကနေ double ကို ပြောင်းတာ)

int myInt = 9;
double myDouble = myInt; // အလိုလို 9.0 ဖြစ်သွားပါတယ်

2. ကိုယ်တိုင် ပြောင်းပေးရခြင်း (Narrowing Casting) အကြီးကနေ အသေးကို ပြောင်းတာပါ။ Data ပျောက်ဆုံးနိုင်တဲ့အတွက် ကိုယ်တိုင် () ထဲမှာ ထည့်ရေးပေးရပါတယ်။

double myDouble = 9.78;
int myInt = (int) myDouble; // 9 ပဲ ကျန်ခဲ့ပါမယ် (ဒသမ နောက်က ကောင်တွေ ပျောက်သွားမယ်)

Java ရဲ့ စည်းကမ်းကြီးမှုက အစပိုင်းမှာ ရှုပ်သလို ထင်ရပေမယ့်၊ Project ကြီးတွေ ရေးတဲ့အခါ Error တွေကို ကြိုတင် ကာကွယ်ပေးနိုင်တဲ့အတွက် အရမ်း အကျိုးကျေးဇူး များပါတယ်။