Jenis primitif vs rujukan dalam Java dan kebolehubahan Strings

Di Java kami mempunyai dua jenis data (atau pembolehubah): primitif dan bukan primitif (juga dipanggil rujukan).

Jenis primitif mempunyai nilai literalnya yang disimpan dalam Tindanan, memori storan sementara dan jangka pendek, yang diuruskan oleh Java Virtual Machine (JVM). [baca lebih lanjut tentang jenis ingatan di sini]

Pembolehubah primitif dibahagikan kepada empat kumpulan:

1. Jenis integer: digunakan untuk menyimpan integer (tanpa bahagian perpuluhan). Ia adalah: bait, pendek, int, panjang. Panjang mempunyai huruf "L" atau "l" di hujung nombor, untuk pembezaan.

2. Jenis titik terapung:: Digunakan untuk menyimpan nombor dengan bahagian perpuluhan (nombor nyata). Mereka adalah: terapung, berganda. Terapung mempunyai huruf "F" atau "f" di hujung nombor, untuk pembezaan.

3. Jenis aksara: Digunakan untuk menyimpan aksara tunggal (seperti huruf, digit atau simbol): char. Ia dimulakan dengan petikan tunggal '', bukannya berganda "".

4. Jenis Boolean: Digunakan untuk menyimpan nilai logik (benar atau salah): bool

Lihat jadual di bawah untuk julat nilai yang ada pada setiap jenis, sebagai tambahan kepada nilai "lalai" mereka:

Dalam format saintifik, E mewakili eksponen. Contohnya, 1.23E+10 bersamaan dengan 1.23 x 10^10

Apakah nilai lalai? Ia adalah nilai yang akan diandaikan oleh pembolehubah jika ia belum dimulakan. Walau bagaimanapun, untuk menganggap nilai ini, ia perlu global atau malar (akhir).

public final boolean isTrue;

Dalam baris kod ini, pembolehubah "isTrue" tidak dimulakan, tetapi pengkompil tidak akan membentangkan ralat, kerana ia akan menganggap nilai lalai "palsu" untuk pembolehubah Boolean.

Di sini, amaran penting: jika skop pembolehubah adalah setempat, iaitu, jika ia telah diisytiharkan dalam fungsi, kami, pengaturcara, akan dipaksa untuk memberikan nilai kepadanya. Jika tidak, akan berlaku ralat kompilasi.

public void teste(){
        int i = 2;
        int j;

        if (i < 10){
            j = 5;
        }

        System.out.println(j);
    }

Dalam contoh ini, walaupun kita tahu bahawa "2 < 10" mengembalikan "true", pengkompil, yang tidak pernah melaksanakan kod yang ia menterjemah semasa prosesnya, tidak mengetahui bahawa keadaan itu benar dan pembolehubah primitif "j" akan sentiasa dimulakan. Dengan cara ini, apabila cuba menjalankan kod, ralat kompilasi akan muncul: "ralat: pembolehubah j mungkin tidak dimulakan".

Alamat ingatan

Jenis data kedua dalam Java dipanggil rujukan. Pembolehubah ini menyimpan rujukan, iaitu, alamat memori objek, bukannya menyimpan nilainya secara langsung, seperti yang berlaku dengan jenis primitif. Storan ini berlaku dalam memori Heap.

Jenis rujukan ialah kelas, antara muka, enum dan objek, secara umum.

Di sini, tambahan. String yang kami gunakan secara meluas dalam kod kami ialah kelas, bukan jenis primitif. Ambil perhatian bahawa walaupun nama itu menggunakan huruf besar, seperti konvensyen penamaan untuk kelas di Java.

String malah mempunyai kaedah, seperti length(), yang mengembalikan saiz teks yang disimpan di dalamnya, charAt(int index), yang mengembalikan indeks aksara dalam teks, atau substring(int beginIndex, int endIndex), yang mengembalikan sekeping rentetan.

Tetapi, jika anda ingin memudahkan memanipulasi data primitif, Java juga membenarkannya. Untuk ini, ia mempunyai kelas Wrapper, yang sudah dilengkapi dengan satu siri kaedah terbina dalam untuk berfungsi dengan jenis asas.

Pembungkus pada asasnya mempunyai nama yang sama dengan pembolehubah primitif, walau bagaimanapun, dengan huruf pertama ditulis dengan huruf besar:

• Bait ke bait
• Seluar pendek untuk seluar pendek
• Integer kepada int
• Lama ke lama
• Apung untuk terapung
• Berganda kepada berganda
• Watak kepada watak
• Boolean kepada boolean

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao < 0) {
            System.out.println(num1 + " é menor que " + num2);
        } else if (resultadoComparacao > 0) {
            System.out.println(num1 + " é maior que " + num2);
        } else {
            System.out.println(num1 + " é igual a " + num2);
        }
    }
}

Dalam kod contoh ini, pembalut int digunakan untuk menukar rentetan kepada nombor (Integer.parse) dan kemudian membandingkannya dengan nombor lain (Integer.compare).

String, bagaimanapun, mempunyai keistimewaan yang tidak dimiliki oleh kelas lain. Dia tidak berubah.

Mari kita renungkan melalui contoh asas ini:

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

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

Dalam kes ini, ambil perhatian bahawa, walaupun String "text2" menunjuk kepada "text1", perubahan dalam "text2" tidak menggambarkan perubahan dalam "text1". Sekarang, apabila Objek "test2", yang menunjuk kepada "test1" mempunyai sifat berubah, perubahan ini juga ditunjukkan dalam "test1".

Hei, tetapi bukankah pembolehubah rujukan menyimpan alamat memori, bukannya nilai literal? Ya. Mereka menyimpannya. Apa yang berlaku ialah pembangun bahasa Java membuat keputusan untuk membiarkan pembolehubah String tidak berubah. Ini bermakna, setelah ditakrifkan, nilai objek String tidak boleh diubah secara tidak langsung oleh objek lain.

Dalam contoh, oleh itu, kami tidak mengubah nilai objek yang dirujuk text1 sebelum ini (memandangkan String tidak boleh diubah). Sebaliknya, kami mencipta objek String baharu dengan nilai "Pelik" dan membuat text1 menunjuk ke objek baharu ini. Text2 masih akan menunjuk kepada objek "Hello" asal dan itulah sebabnya ia mengekalkan nilai "Hello".

Ringkasnya, memberikan nilai baharu pada rentetan tidak mengubah suai nilai objek sedia ada, ia hanya menukar rujukan kepada objek baharu.

Objek kelas tersuai, seperti TestClass, boleh diubah. Kedua-dua rujukan test1 dan test2 menghala ke objek yang sama, jadi menukar keadaan salah satu daripadanya mencerminkan pada yang lain.

Atas ialah kandungan terperinci Jenis primitif vs rujukan dalam Java dan kebolehubahan Strings. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!