Malay

Tutorial Java

Pernyataan Kawalan Java

Pengaturcaraan Berorientasikan Objek

Kelas terbina dalam Java

Pengurusan Fail Java

Ralat & Pengecualian Java

Java Multithreading

Segerak Java

Rangkaian Java

Koleksi Java

Antara muka Java

Struktur Data Java

Algoritma Koleksi Java

Java Lanjutan

Java pelbagai

Rujukan Kelas Java

Mengerti Mesin Virtual Java (JVM): Panduan untuk Pemula

Helo pelanggan masa depan pembangun Java! Hari ini, kita akan menyusuri perjalanan yang menarik ke dunia Mesin Virtual Java, atau JVM untuk singkat. Jangan khawatir jika anda belum pernah menulis satu baris kod sebelum ini – kita akan mula dari permulaan dan kerjakan ke atas. Pada akhir tutorial ini, anda akan mempunyai pemahaman yang kuat tentang apa itu JVM dan bagaimana ia bekerja. Jadi, ambil secawan kopi (atau teh, jika itu yang anda suka), dan mari kita melompat masuk!

Java Virtual Machine (JVM)

Apa itu JVM (Mesin Virtual Java)?

Bayangkan anda cuba untuk berkomunikasi dengan seseorang yang berbicara dalam bahasa yang berbeza. Anda perlukan seorang penterjemah, kan? Walau bagaimanpun, JVM adalah seperti penterjemah untuk kod Java anda. Ia mengambil kod yang anda tulis dan menterjemahkannya kepada sebuah bahasa yang komputer anda dapat memahami dan menjalankan.

Di sini ada satu analogi yang menarik: Pikirkan JVM sebagai remote control universal. Seperti mana remote control universal dapat bekerja dengan jenis TV yang berbeza, JVM membolehkan program Java dijalankan pada jenis komputer yang berbeza tanpa perlu ditulis semula untuk setiap satu. Menarik, kan?

Arsitektur JVM (Mesin Virtual Java)

Sekarang kita tahu apa yang JVM lakukan, mari kita lihat di bawah rakitnya dan lihat bagaimana ia dibina. Arsitektur JVM adalah seperti dapur yang teratur, dengan seksyen yang berbeza bertanggungjawab untuk tugas-tugas khusus.

Subsistem Pemuat Kelas

Ini adalah seperti pembeli rakit JVM. Ia pergi keluar dan mendapatkan kelas dan antara muka yang program anda perlukan, membawa mereka ke JVM, dan memastikan mereka siap untuk digunakan.

Kawasan Data masa-jalannya

Pikirkan ini sebagai rakuan dapur di mana semua bahan (data) diletakkan dan diatur. Ia termasuk:

  1. Kawasan Method: Buku resepi di mana semua informasi kelas disimpan.
  2. Heap: rakuan besar di mana semua objek dibuat dan disimpan.
  3. Stack: atas di mana metode yang sedang dijalankan diletakkan.
  4. Pendaftar PC: Pemantau masa juru masak, mengambil kira arahan yang sedang dijalankan.
  5. Stack Metode Asli: Kawasan khusus untuk metode yang ditulis dalam bahasa yang bukan Java.

Enjin Eksekusi

Ini adalah juru masak dapur JVM. Ia mengambil bahan (bytecode) dan memasaknya menjadi sesuatu yang komputer dapat memahami dan menjalankan.

Komponen Arsitektur JVM (Mesin Virtual Java)

Mari kita pecahkan down komponen ini sedikit lagi:

1. Subsistem Pemuat Kelas

Pemuat kelas memiliki tiga bahagian utama:

  1. Memuat: Membaca fail .class dan menghasilkan data binari.
  2. Penyambungan: Mengesahkan, mempersedia dan (pilihan) menyelesaikan rujukan simbolik.
  3. Pemulaan: Menjalankan penyedia awal dan menginisialisasi medan statik.

2. Kawasan Data masa-jalannya

Kami telah memberitahu tentang ini, tetapi mari tambahkan beberapa detail lagi:

  1. Kawasan Method: Menyimpan struktur kelas, metode, pembangun dan lain-lain.
  2. Heap: Di mana semua objek tinggal. Ia dikawal oleh pengumpul kotoran.
  3. Stack: Menyimpan variabel lokal dan hasil separuh. Setiap thread memiliki rakuan sendiri.
  4. Pendaftar PC: Menyimpan alamat arahan yang sedang dijalankan.
  5. Stack Metode Asli: Mirip dengan rakuan Java, tetapi untuk metode asli.

3. Enjin Eksekusi

Enjin eksekusi memiliki tiga komponen utama:

  1. Penterjemah: Membaca bytecode dan menjalankannya baris demi baris.
  2. Kompiler JIT: Mengkompilkan keseluruhan metode ke kode asli untuk eksekusi yang lebih cepat.
  3. Pengumpul Kotoran: Secara automatik membebaskan memori dengan menghapus objek yang tidak digunakan.

Sekarang, mari lihat beberapa kod yang dijalankan untuk memahami bagaimana JVM bekerja:

public class HelloJVM {
public static void main(String[] args) {
System.out.println("Hello, JVM!");
}
}

Apabila anda menjalankan program ini, ini adalah apa yang terjadi di belakang layar:

  1. Pemuat kelas memuat kelas HelloJVM.
  2. Metode utama ditebus ke atas rakuan.
  3. Enjin eksekusi menginterpretasikan bytecode.
  4. "Hello, JVM!" dicetak ke konsol.
  5. Metode utama selesai dan dikeluarkan dari rakuan.

Cukup kemas, bukan? JVM menangani semua itu untuk kita, menterjemahkan kod Java kami yang sederhana menjadi sesuatu yang komputer dapat memahami dan menjalankan.

Perintah Kawalan Java

Sekarang kita telah memahami JVM, mari lihat beberapa perintah kawalan Java dasar. Ini adalah seperti rakit penyuruh kod anda, mengawal aliran eksekusi.

Perintah If-Else

int age = 18;
if (age >= 18) {
System.out.println("Anda boleh untuk mengundi!");
} else {
System.out.println("Maaf, anda terlalu muda untuk mengundi.");
}

Kod ini memeriksa jika umur adalah 18 atau lebih tua. Jika ya, ia mencetak "Anda boleh untuk mengundi!". Jika tidak, ia mencetak "Maaf, anda terlalu muda untuk mengundi."

Perintah For

for (int i = 0; i < 5; i++) {
System.out.println("Bilangan: " + i);
}

Loop ini akan mencetak nombor 0 hingga 4. Ia seperti memberitahu JVM, "Lakukan ini 5 kali, dan setiap kali, gunakan nombor yang berbeza."

Pemrograman Berorientasi Objek

Java adalah bahasa pemrograman berorientasi objek, yang berarti ia semua tentang mencipta dan mengurus objek. Mari kita cipta satu kelas yang ringkas untuk mempersembahkan:

public class Dog {
String name;
int age;

public void bark() {
System.out.println(name + " berkata: Woof!");
}
}

public class DogTest {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.name = "Buddy";
myDog.age = 3;
myDog.bark();
}
}

Dalam contoh ini, kita telah mencipta satu kelas Dog dengan sifat (nama dan umur) dan satu metode (bark). Kita kemudian mencipta satu objek Dog di dalam metode utama dan membuatnya untuk berbark. JVM mengurus memori untuk objek ini dan menangani pemanggilan metode apabila kita memberitahu anjing untuk berbark.

Kelas Terbina-dalam Java

Java datang dengan satu set kelas terbina-dalam yang menyediakan banyak fungsi di atas rakuan. Mari lihat beberapa:

String

String greeting = "Hello, JVM!";
System.out.println(greeting.length()); // Cetak: 11
System.out.println(greeting.toUpperCase()); // Cetak: HELLO, JVM!

ArrayList

import java.util.ArrayList;

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
System.out.println(fruits); // Cetak: [Apple, Banana, Cherry]

Kelas-kelas terbina-dalam ini adalah sebahagian dari API Java, dan JVM tahu bagaimana untuk bekerja dengan mereka secara efisien.

Pengendalian Fail Java

Java memudahkan kerja dengan fail. Di sini ada satu contoh yang ringkas untuk menulis ke fail:

import java.io.FileWriter;
import java.io.IOException;

public class FileWriteExample {
public static void main(String[] args) {
try {
FileWriter writer = new FileWriter("output.txt");
writer.write("Hello, JVM! Ini adalah satu fail.");
writer.close();
System.out.println("Berjaya menulis ke fail.");
} catch (IOException e) {
System.out.println("Satu ralat berlaku.");
e.printStackTrace();
}
}
}

Kod ini mencipta satu fail baru yang dipanggil "output.txt" dan menulis satu mesej kepadanya. JVM menangani semua detail tingkat rendah dari interaksi dengan sistem fail.

Ralat & Penyataan Java

Dalam Java, ralat dan penyataan adalah cara JVM memberitahu kita bahwa sesuatu yang salah telah berlaku. Mari lihat satu contoh yang ringkas:

public class ExceptionExample {
public static void main(String[] args) {
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Tidak boleh bagi dengan nol!");
}
}
}

Dalam kes ini, kita cuba untuk membagi dengan nol, yang tidak dibenarkan dalam matematik. JVM tangkap ini dan melemparkan penyataan ArithmeticException, yang kita tangkap dan kendalikan dengan mencetak satu mesej.

Multithreading Java

Multithreading adalah seperti dapat untuk memasak beberapa hidangan pada satu masa di dapur JVM kita. Di sini ada satu contoh yang ringkas:

public class MultithreadingExample extends Thread {
public void run() {
System.out.println("Thread " + Thread.currentThread().getId() + " sedang berjalan");
}

public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
MultithreadingExample thread = new MultithreadingExample();
thread.start();
}
}
}

Kod ini mencipta dan memulakan 5 thread, masing-masing yang mencetak ID mereka. JVM mengurus thread-thread ini, mengalokasikan masa CPU kepada setiap satu.

Sinkronisasi Java

Apabila beberapa thread mengakses sumber yang sama, kita perlu berhati-hati. Sinkronisasi adalah seperti memiliki kunci pada pintu dapur supaya hanya satu juru masak boleh masuk pada satu masa:

public class SynchronizationExample {
private int count = 0;

public synchronized void increment() {
count++;
}

public static void main(String[] args) {
SynchronizationExample example = new SynchronizationExample();
example.doWork();
}

public void doWork() {
Thread t1 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++) {
increment();
}
}
});

Thread t2 = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++) {
increment();
}
}
});

t1.start();
t2.start();

try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Bilangan adalah: " + count);
}
}

Dalam contoh ini, kita ada dua thread yang menambah nilai pengiraan yang sama. Kata kunci synchronized memastikan hanya satu thread yang boleh mengakses metode increment() pada satu masa, mencegah keadaan larian.

Itulah untuk perjalanan kita yang pusing di atas Mesin Virtual Java dan beberapa konsep Java yang penting! Ingat, JVM selalu ada, bekerja di belakang layar untuk memastikan program Java anda berjalan lancar di atas platform yang berbeza. Terus untuk praktis, terus untuk mengkod, dan suatu hari nanti anda akan menjadi seorang master Java!

Credits: Image by storyset

Tutorial Sebelumnya:
Java vs C++
Tutorial Seterusnya:
Java - JDK vs JRE vs JVM