kata kunci berganda Java

Kata kunci berganda Java , seperti dalam mana-mana bahasa lain, menunjukkan format komputer untuk mewakili nombor titik terapung, menduduki 64 bit, atau 8 bait, dalam ingatan. Dalam artikel ini kita akan bercakap tentang berganda dan melihat beberapa contoh.

Titik terapung dan pengkomputeran: penerangan matematik pendek

Nombor pecahan sama ada tetap atau titik terapung. Pilihan pertama boleh diwakili sebagai pecahan biasa, di mana pengangka (nombor itu sendiri) dan penyebut (faktor skalanya) akan menjadi integer. Sebagai contoh, nombor 2.7 ialah 27 dengan faktor skala 10, 3.14 - 314 dengan faktor 100. Walau bagaimanapun, pendekatan ini tidak begitu tepat dari sudut pengiraan, oleh itu, mereka sering menggunakan perwakilan titik terapung. Dalam pengkomputeran, aritmetik titik terapung ialah perwakilan aritmetik khas bagi nombor nyata sebagai anggaran untuk menyokong pertukaran antara julat dan ketepatan. Format utama untuk mewakili nombor titik terapung di Jawa dipanggil terapung. Namanya berasal dari titik terapung. Float ialah 32 bit, di mana 1 bit adalah bit bertanda, 8 bit untuk eksponen dan 23 bit untuk significand. Julatnya ialah ±3. 40282347E + 38F iaitu 6-7 digit bererti. Nama double berasal dari double float. Thejenis berganda adalah dua kali lebih besar daripada apungan : 8 bait berbanding 4. Ia juga dipanggil nombor nyata ketepatan berganda. Daripada 64 bit yang dikhaskan untuk nombor berganda, 1 adalah bit bertanda, 11 bit adalah untuk eksponen dan 52 bit adalah untuk significand. Pecahan berganda Java menyimpan nombor dalam julat ±1.79769313486231570E + 308 iaitu 15-16 digit bererti. Double ialah format yang lebih tepat. Jadi, jika anda perlu menyimpan nombor yang benar-benar besar memilih dua kali ganda daripada terapung adalah idea yang baik. By the way, kaedah matematik seperti sqrt, sin atau cos dan lain-lain lagi mengembalikan nilai berganda. Walau bagaimanapun, anda perlu membayar untuk ketepatan berganda dengan ingatan.

Mencipta pembolehubah berganda

Jenis berganda digunakan untuk menyimpan nombor nyata. Untuk mencipta pembolehubah dalam kod yang akan dapat menyimpan nombor nyata, anda perlu menggunakan arahan:

double name;

Di mana nama ialah nama pembolehubah.

double myPrice;  //here we create a variable called myPrice
double action; //and here -- action.

Anda juga boleh menggunakan trengkas untuk mencipta berbilang pembolehubah jenis double :

double name1, name2, name3;

Contoh kata kunci berganda Java

Mari berikan beberapa contoh menggunakan kata kunci berganda Java untuk mencipta pembolehubah.

double myPrice = 5.0;
double height = 180;
double x = 7.1, y = 3.0;

Di sini dalam myPrice pembolehubah kita mempunyai nilai 5.0, dalam ketinggian berubah - 180, dalam x kita meletakkan nilai 7.1, dan 3.0 dalam y .

Berganda sebagai integer

Di Java, pembolehubah berganda boleh diberikan kedua-dua nombor nyata dan integer. Apabila memberikan integer, ia hanya ditukar kepada nombor nyata. Walaupun kadangkala kehilangan sedikit ketepatan adalah mungkin.

double height = 180;
int k = 2;
int i = 5;
double myDouble = k*i;

Malah, pembolehubah ketinggian menyimpan nombor 180.0, dan pembolehubah myDouble menyimpan nombor 10.0.

Interaksi berganda dan integer

Di samping itu, jika integer dan nombor nyata terlibat dalam beberapa ungkapan, maka integer mula-mula ditukar kepada nombor nyata dan hanya kemudian berinteraksi dengan nombor nyata yang lain.

public class DoubleDemo {
   public static void main(String[] args) {
       int k = 2;
       double myDouble1 = 5;
       double myDouble = k*7.0;
       System.out.println(myDouble1);
       System.out.println(k*myDouble1);
       System.out.println(myDouble);
   }
}

Dalam contoh ini, outputnya ialah: Walaupun nombor myDouble1 dilambangkan sebagai 5 dan bukan 5.0, Java melihat nombor ini sebagai double , jadi ia sebenarnya kelihatan seperti 5.0. Jika kita mendarab int dan dua kali ganda, kita sentiasa mendapat dua kali ganda , walaupun sebenarnya nombor ini adalah integer. Kita boleh menetapkan pembolehubah jenis berganda kepada pembolehubah jenis int . Untuk melakukan ini, anda perlu membuat penukaran jenis eksplisit. Sudah tentu, bahagian pecahan akan dibuang, nombor itu akan dipotong kepada integer yang lebih kecil.

public class DoubleDemo {
   public static void main(String[] args) {
       double x = 57.789;
       int almostX;
       almostX = (int)x;
       System.out.println(almostX);
   }
}

Outputnya ialah: Akhir sekali, mari kita bercakap tentang perpecahan. Ini adalah perkara yang paling menarik. Anda mungkin telah menemui fakta bahawa jika anda membahagi dua integer, maka sebagai hasil pembahagian kita mendapat integer, walaupun mereka tidak boleh dibahagikan sama rata oleh satu sama lain:

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7/2;
       System.out.println(myDouble);
   }
}

Hasilnya ialah: Ini kerana mesin Java mula-mula membahagikan dua integer (dan mendapat 3), dan kemudian menyimpan nilai ini dalam pembolehubah jenis berganda, dan mendapat 3.0 sebagai hasilnya. Untuk mendapatkan bukan integer, tetapi pembahagian biasa, anda perlu menipu. Sebagai contoh, tulis salah satu nombor sebagai nombor nyata (kemudian keseluruhan ungkapan ditukar kepada nyata secara automatik). Jika kita bekerja dengan pembolehubah jenis integer, maka ia boleh didarab dengan 1.0. Ini tidak akan mengubah nilai, tetapi ia akan menukar jenis pembolehubah daripada int kepada double .

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7.0/2;
       int x = 5;
       int y = 2;
       System.out.println(myDouble);
       System.out.println(x*1.0/y);
   }
}

Outputnya ialah: