Compiling and Running: javac, Bytecode and the JVMکۆمپایلکردن و جێبەجێکردن: javac، بایتکۆد و ئامێری گریمانەیی Java

Every Java program goes through the same cycle, and you need a JDK installed for it (Install a JDK). You write the source code in any text editor or IDE, save it as a .java file, compile it with javac, and run the bytecode with java.

هەموو بەرنامەیەکی Java بە هەمان خولدا تێدەپەڕێت و بۆ ئەمە کەرەستەیەکی گەشەپێدانی Javaـی (Java Development Kit) جێگیرکراوت پێویستە (کەرەستەیەکی گەشەپێدانی Java جێگیر بکە). کۆدی سەرچاوە (Source code) لە هەر دەستکاریکەرێکی دەق (Text editor) یان IDEـێکدا دەنووسیت، وەک فایلێکی .java پاشەکەوتی دەکەیت، بە javac کۆمپایلی دەکەیت و بایتکۆدەکە بە java جێبەجێ دەکەیت.

Mistakes send you back to the editor. A compile error means: fix the code and compile again. A runtime error or a wrong result means: change the code, compile it again and run it again.

هەڵەکان دەتگەڕێننەوە بۆ دەستکاریکەرەکە. هەڵەی کاتی کۆمپایلکردن (Compile-time error) واتە: کۆدەکە چاک بکە و دووپاتە کۆمپایل بکەرەوە. هەڵەی کاتی جێبەجێکردن (Runtime error) یان ئەنجامی هەڵە واتە: کۆدەکە بگۆڕە، دووپاتە کۆمپایلی بکەرەوە و دووپاتە جێبەجێی بکەرەوە.

Save the source code with the extension .java, under exactly the name of its public class: public class Welcome goes into Welcome.java — same letters, same capitals. Keep the programs of this track in one folder (for example examples), so the .class files appear next to their sources.

کۆدی سەرچاوە وەک فایلێکی .java پاشەکەوت بکە، ڕێک بە ناوی کلاسی (Class) publicـەکەی: public class Welcome دەچێتە ناو Welcome.java — هەمان پیت و هەمان پیتە گەورەکان. بەرنامەکانی ئەم ڕێڕەوە لە یەک فۆڵدەردا (Directory) هەڵبگرە (بۆ نموونە examples)، بۆ ئەوەی فایلەکانی .class لە تەنیشت فایلەکانی سەرچاوەیان دەربکەون.

javac Welcome.java reads the source file, checks it against Java's rules and translates it into bytecode, which it writes into a new file, Welcome.class. Bytecode is like machine instructions, but for no real processor: it is architecture-neutral, so any computer with a Java Virtual Machine can run it. When javac prints nothing at all, the compile worked.

javac Welcome.java فایلی (File) سەرچاوە دەخوێنێتەوە، بەراورد بە یاساکانی Java دەیپشکنێت و وەریدەگێڕێت بۆ بایتکۆد، کە لە فایلێکی نوێدا دەینووسێت: Welcome.class. بایتکۆد وەک ڕێکارنامەکانی (Instruction) ئامێر وایە، بەڵام بۆ هیچ CPUـێکی ڕاستەقینە نییە: سەربەخۆیە لە جۆری ئامێر، بۆیە هەر کۆمپیوتەرێک (Computer) کە ئامێری گریمانەیی Javaـی (Java Virtual Machine) هەبێت دەتوانێت جێبەجێی بکات. کاتێک javac هیچ شتێک چاپ ناکات، کۆمپایلکردنەکە سەرکەوتوو بووە.

If a class uses another class of yours, javac compiles that one too. Compiling Shop.java, which uses a class Tea from Tea.java, gives both Shop.class and Tea.class. Classes inside packages are compiled and run a little differently (Packages).

ئەگەر کلاسێک کلاسێکی تری خۆت بەکار بهێنێت، javac ئەویش کۆمپایل دەکات. کۆمپایلکردنی Shop.java، کە کلاسێکی Tea لە Tea.java بەکار دەهێنێت، هەم Shop.class و هەم Tea.class دەدات. ئەو کلاسانەی لە ناو پاکێجێکدان (Package) تۆزێک بە جیاوازی کۆمپایل و جێبەجێ دەکرێن (پاکێجەکان).

java Welcome starts a Java Virtual Machine, which loads Welcome.class and runs its main method. After java you type the class name: no .java and no .class. The same Welcome.class would run in the same way on any other computer with a JVM.

java Welcome ئامێرێکی گریمانەیی Java دەست پێ دەکات، کە Welcome.class بار دەکات و کردارەکەی main (Main function) جێبەجێ دەکات. دوای java ناوی کلاسەکە دەنووسیت: بێ .java و بێ .class. هەمان Welcome.class بە هەمان شێوە لەسەر هەر کۆمپیوتەرێکی تر کە JVMـی هەبێت جێبەجێ دەبێت.

Adding .class is one of the most common first mistakes:

زیادکردنی .class یەکێکە لە باوترین یەکەم هەڵەکان:

Here is the whole cycle typed in a terminal on macOS or Linux. cd moves into the folder with the file (Folders and cd) and ls lists the files; on Windows' Command Prompt you type dir instead of ls.

ئەمە هەموو خولەکەیە کە لە تێرمیناڵێکی macOS یان Linux نووسراوە. cd دەچێتە ناو ئەو فۆڵدەرەی فایلەکەی تێدایە (فۆڵدەرەکان و cd) و ls لیستی فایلەکان پیشان دەدات؛ لە Command Promptـی Windowsـدا لە جیاتی ls دەنووسیت dir.

On Windows the same commands work in Command Prompt, and javac and java print exactly the same messages:

لەسەر Windows هەمان فەرمانەکان لە Command Promptـدا کار دەکەن و javac و java ڕێک هەمان پەیام چاپ دەکەن:

A .class file is not text. Every one starts with the same four bytes, CA FE BA BE — Java's "magic number" — followed by a version number: 00 3D is 61, the number for Java 17. The JDK tool javap -c shows the bytecode instructions in a readable form:

فایلێکی .class دەق نییە. هەموویان بە هەمان چوار بایت دەست پێ دەکەن، CA FE BA BE — «ژمارە سیحراوییەکەی» Java — و دوای ئەوان ژمارەی وەشانێک دێت: 00 3D دەکاتە ⁦61⁩، ژمارەی ⁦Java 17⁩. ئامرازی javap -cـی JDK ڕێکارنامەکانی بایتکۆد بە شێوەیەکی خوێندراوە پیشان دەدات:

The main part is our one line of Java: getstatic fetches System.out, ldc loads the text, invokevirtual calls println, and return ends main. The first part, Welcome(), is a constructor that javac adds by itself (The default constructor). Here Welcome.java is 124 bytes and Welcome.class is 424 bytes. Because anyone can do this with a .class file, a compiled program is not a locked box: see Reverse Engineering.

بەشی main هەمان ئەو یەک دێڕەیە کە بە Java نووسیمان: getstatic System.out دەهێنێت، ldc دەقەکە بار دەکات، invokevirtual println بانگ دەکات و return main تەواو دەکات. بەشی یەکەم، Welcome()، دروستکەرێکە (Constructor) کە javac خۆی زیادی دەکات (دروستکەری بنەڕەتی). لێرەدا Welcome.java ⁦124⁩ بایتە و Welcome.class ⁦424⁩ بایت. لەبەر ئەوەی هەر کەسێک دەتوانێت ئەمە لەگەڵ فایلێکی .class بکات، بەرنامەیەکی کۆمپایلکراو سندووقێکی قفڵدراو نییە: بڕوانە ئەندازیاریی پێچەوانە.

When you type java Welcome, the JVM first uses a program called the class loader to find Welcome.class and load its bytecode into memory. Java's core classes, such as String and System, are already loaded while the JVM starts up. The program's other classes, such as your own, are loaded one by one, when they are first needed.

کاتێک java Welcome دەنووسیت، ئامێری گریمانەیی Java سەرەتا بەرنامەیەک بەکار دەهێنێت بە ناوی بارکەری کلاس بۆ دۆزینەوەی Welcome.class و بارکردنی بایتکۆدەکەی بۆ ناو بیرگە (Memory). کلاسە سەرەکییەکانی Java، وەک String و System، لە کاتی دەستپێکردنی JVMـدا بار کراون. کلاسەکانی تری بەرنامەکە، وەک هی خۆت، یەک بە یەک بار دەکرێن، کاتێک یەکەمجار پێویست دەبن.

After a class is loaded, the JVM's bytecode verifier checks that the bytecode is valid and keeps to Java's safety rules: every instruction is real, values are used with the right types, and no jump leaves its method. A broken or tampered .class file is refused with a VerifyError before any of it runs. Only then does the JVM run main, interpreting the bytecode and compiling the busiest parts to machine code (just-in-time compiling).

دوای ئەوەی کلاسێک بار کرا، پشکنەری بایتکۆدـی JVM دەپشکنێت کە بایتکۆدەکە دروستە و یاساکانی سەلامەتیی Java دەپارێزێت: هەموو ڕێکارنامەیەک ڕاستەقینەیە، نرخەکان (Value) بە جۆری ڕاست بەکار دێن و هیچ بازدانێک لە میتۆدەکەی (Method) خۆی دەرناچێت. فایلێکی .classـی تێکچوو یان دەستکاریکراو پێش ئەوەی هیچ بەشێکی جێبەجێ بێت بە VerifyError ڕەت دەکرێتەوە. تەنیا ئەو کاتە JVM main جێبەجێ دەکات، بایتکۆدەکە وەردەگێڕێت و بەشە زۆر بەکارهاتووەکان دەکات بە کۆدی ئامێر (Machine code) (کۆمپایلکردنی کاتی جێبەجێکردن).

You can watch this happen. The class Helper below prints a line at the moment the JVM sets it up (the static { … } block runs once, when the class is first used; you will meet static again later). Look at the order of the output:

دەتوانیت سەیری ڕوودانی ئەمە بکەیت. کلاسی Helperـی خوارەوە لەو کاتەدا دێڕێک چاپ دەکات کە JVM ئامادەی دەکات (بلۆکی static { … } یەکجار جێبەجێ دەبێت، کاتێک کلاسەکە یەکەمجار بەکار دێت؛ static دواتر دووپاتە دەبینیتەوە). سەیری ڕیزبەندیی دەرخستەکە (Output) بکە:

main starts comes first: Helper was not needed before line 4. One file gave two class files, Lazy.class and Helper.class, and each is loaded only when it is needed — which makes Java programs start faster.

main starts یەکەمە: پێش دێڕی 4 پێویست بە Helper نەبوو. یەک فایل دوو فایلی کلاسی دا: Lazy.class و Helper.class. هەریەکەیان تەنیا کاتێک بار دەکرێت کە پێویست بێت — ئەمەش وا دەکات بەرنامەکانی Java خێراتر دەست پێ بکەن.

Editors and IDEs run the same two steps for you. In VS Code, click Run above main (or Run Java at the top right of the editor); in IntelliJ IDEA, click the green arrow next to main. The output appears in a panel at the bottom. Behind the button, the editor compiles the file and starts a JVM — exactly what javac and java do.

دەستکاریکەرەکان و ژینگە کۆکراوەکانی گەشەپێدان هەمان دوو هەنگاو بۆت ئەنجام دەدەن. لە VS Code، Run لە سەرووی main دابگرە (یان Run Java لە سەرەوەی لای ڕاستی دەستکاریکەرەکە)؛ لە IntelliJ IDEA، تیرە سەوزەکەی تەنیشت main دابگرە. دەرخستەکە لە بەشێکی خوارەوەدا دەردەکەوێت. لە پشت دوگمەکەوە، دەستکاریکەرەکە فایلەکە کۆمپایل دەکات و JVMـێک دەست پێ دەکات — ڕێک ئەوەی javac و java دەیکەن.

Since JDK 11 the java launcher can also run a one-file program straight from its source code: it compiles the file in memory and runs it at once. No .class file is written.

لە ⁦JDK 11⁩ـەوە دەستپێکەری java دەتوانێت بەرنامەیەکی یەک فایلی ڕاستەوخۆ لە کۆدی سەرچاوەکەیەوە جێبەجێ بکات: فایلەکە لە بیرگەدا کۆمپایل دەکات و یەکسەر جێبەجێی دەکات. هیچ فایلێکی .class نانووسرێت.

The compile still happens, so a syntax error still stops the program: the launcher prints the javac message and then error: compilation failed. On JDK 17 a program made of several files must be compiled with javac (or a build tool); since JDK 22 the launcher can also run a program whose classes sit in several .java files.

کۆمپایلکردنەکە هەر ڕوو دەدات، بۆیە هەڵەیەکی داڕستن (Syntax error) هێشتا بەرنامەکە ڕادەگرێت: دەستپێکەرەکە پەیامی javac و پاشان error: compilation failed چاپ دەکات. لەسەر ⁦JDK 17⁩، بەرنامەیەک کە لە چەند فایلێک پێک دێت دەبێت بە javac (یان ئامرازێکی دروستکردن) کۆمپایل بکرێت؛ لە ⁦JDK 22⁩ـەوە دەستپێکەرەکە دەتوانێت ئەو بەرنامانەش جێبەجێ بکات کە کلاسەکانیان لە چەند فایلێکی .javaـدان.

To try a single line of Java without writing a class, start JShell with the command jshell (it comes with every JDK since 9). It reads one line, runs it and shows the result at once; results get names such as $2. Type /exit to leave.

بۆ تاقیکردنەوەی یەک دێڕی Java بەبێ نووسینی کلاسێک، JShell بە فەرمانی jshell دەست پێ بکە (لە ⁦JDK 9⁩ـەوە لەگەڵ هەموو JDKـێک دێت). دێڕێک دەخوێنێتەوە، جێبەجێی دەکات و یەکسەر ئەنجامەکە پیشان دەدات؛ ئەنجامەکان ناوی وەک $2 وەردەگرن. بۆ دەرچوون /exit بنووسە.

Every message below is the real output of JDK 17. The first two rows are what Windows and macOS show, because their disks ignore capital letters in file names; on Linux javac and java simply find no such file or class. Reading a javac message explains the parts of a message.

هەموو پەیامێکی خوارەوە دەرخستەی ڕاستەقینەی ⁦JDK 17⁩ـە. دوو ڕیزی یەکەم ئەوەن کە Windows و macOS پیشانی دەدەن، چونکە دیسکەکانیان گوێ بە پیتی گەورە لە ناوی فایلدا نادەن؛ لەسەر Linux، javac و java بە سادەیی ئەو فایل یان کلاسە نادۆزنەوە. خوێندنەوەی پەیامێکی javac بەشەکانی پەیامێک ڕوون دەکاتەوە.