ประเภทดั้งเดิมใน Java: พวกมันไม่ใช่แบบดั้งเดิม

การแนะนำ

การพัฒนาแอปพลิเคชันถือได้ว่าเป็นการทำงานกับข้อมูลบางอย่าง หรือค่อนข้างจะเป็นการจัดเก็บและประมวลผลข้อมูลนั้น วันนี้ผมอยากจะพูดถึงประเด็นสำคัญประการแรก ข้อมูลถูกเก็บไว้ใน Java อย่างไร? ที่นี่เรามีสองรูปแบบที่เป็นไปได้: ประเภทข้อมูลอ้างอิงและดั้งเดิม เรามาพูดถึงประเภทของประเภทดั้งเดิมและความเป็นไปได้ในการทำงานกับพวกมัน (ไม่ว่าจะพูดอะไรก็ตาม นี่คือรากฐานของความรู้ของเราเกี่ยวกับภาษาการเขียนโปรแกรม) ชนิดข้อมูลดั้งเดิมของ Javaเป็นรากฐานของทุกสิ่ง ไม่ ฉันไม่ได้พูดเกินจริงเลย Oracle มีบทช่วยสอนแยกต่างหากสำหรับพื้นฐานโดยเฉพาะ: ประเภทข้อมูลดั้งเดิม ประวัติเล็กน้อย ในตอนแรกก็ไม่มีศูนย์ แต่ศูนย์ก็น่าเบื่อ แล้วบิต ก็ปรากฏตัว ขึ้น ทำไมเขาถึงเรียกอย่างนั้น? ตั้งชื่อตามคำย่อว่า " bi nary digi t " (เลขฐานสอง) นั่นคือมันมีเพียงสองความหมายเท่านั้น และเนื่องจากมันเป็นศูนย์ จึงสมเหตุสมผลที่ตอนนี้จะเป็น 0 หรือ 1 และชีวิตก็สนุกสนานมากขึ้น เศษเริ่มรวมตัวกันเป็นฝูง และฝูงแกะเหล่านี้เริ่มถูกเรียกว่าไบต์ (ไบต์) ในโลกสมัยใหม่ ไบต์ = 2 ยกกำลังสาม กล่าวคือ 8. แต่ปรากฎว่าไม่ได้เป็นเช่นนั้นเสมอไป มีการเดาตำนานและข่าวลือมากมายเกี่ยวกับที่มาของชื่อไบต์ บางคนคิดว่ามันเป็นเรื่องของการเข้ารหัสในยุคนั้น ในขณะที่คนอื่นๆ คิดว่าการอ่านข้อมูลในลักษณะนี้จะได้กำไรมากกว่า ไบต์คือหน่วยความจำที่เล็กที่สุดที่สามารถระบุตำแหน่งได้ เป็นไบต์ที่มีที่อยู่เฉพาะในหน่วยความจำ มีตำนานว่า ByTe เป็นตัวย่อของ Binary Term ซึ่งเป็นคำเครื่องจักร คำพูดของเครื่อง - พูดง่าย ๆ คือจำนวนข้อมูลที่โปรเซสเซอร์สามารถประมวลผลได้ในการดำเนินการครั้งเดียว ก่อนหน้านี้ ขนาดคำของเครื่องจะเหมือนกับหน่วยความจำที่เล็กที่สุดที่สามารถระบุตำแหน่งได้ ใน Java ตัวแปรสามารถเก็บเฉพาะค่าไบต์เท่านั้น อย่างที่ผมได้กล่าวไว้ข้างต้น มีตัวแปรสองประเภทใน Java:

• ประเภทดั้งเดิมของ Java จะเก็บค่าของไบต์ข้อมูลโดยตรง (เราจะดูประเภทของข้อมูลพื้นฐานเหล่านี้โดยละเอียดด้านล่าง)
• ประเภทการอ้างอิง จัดเก็บไบต์ของที่อยู่ของวัตถุใน Heap นั่นคือผ่านตัวแปรเหล่านี้ เราสามารถเข้าถึงวัตถุได้โดยตรง (ประเภทของรีโมทคอนโทรลสำหรับวัตถุ)

จาวาไบต์

ดังนั้น ประวัติศาสตร์จึงให้ไบต์แก่เรา ซึ่งเป็นจำนวนหน่วยความจำขั้นต่ำที่เราสามารถใช้ได้ และประกอบด้วย 8 บิต ชนิดข้อมูลจำนวนเต็มที่น้อยที่สุดใน Java คือไบต์ นี่เป็นประเภท 8 บิตที่ลงนาม มันหมายความว่าอะไร? มานับกัน 2^8 ได้ 256 แต่ถ้าเราอยากได้จำนวนลบล่ะ? และนักพัฒนา Java ตัดสินใจว่ารหัสไบนารี่ "10000000" จะแสดงถึง -128 นั่นคือบิตที่สำคัญที่สุด (บิตซ้ายสุด) จะระบุว่าตัวเลขนั้นเป็นลบหรือไม่ ไบนารี่ “0111 1111” เท่ากับ 127 นั่นคือ 128 ไม่สามารถกำหนดได้ในทางใดทางหนึ่ง เนื่องจาก มันจะเป็น -128 การคำนวณทั้งหมดได้รับในคำตอบนี้: เหตุใดช่วงของไบต์ -128 ถึง 127 ใน Java เพื่อให้เข้าใจถึงวิธีการรับตัวเลขคุณควรดูภาพ: ดังนั้น ในการคำนวณขนาด 2^(8-1) = 128 ซึ่งหมายความว่าขีดจำกัดขั้นต่ำ (และมีเครื่องหมายลบ) จะเป็น -128 และค่าสูงสุดคือ 128 – 1 (ลบศูนย์) นั่นคือจำนวนสูงสุดจะเป็น 127 อันที่จริง เราไม่ได้ทำงานกับประเภทไบต์บ่อยนักใน "ระดับสูง" นี่คือการประมวลผลข้อมูล "ดิบ" เป็นหลัก ตัวอย่างเช่น เมื่อทำงานกับการส่งข้อมูลบนเครือข่าย เมื่อข้อมูลเป็นชุด 0 และ 1 ที่ส่งผ่านช่องทางการสื่อสารบางประเภท หรือเมื่ออ่านข้อมูลจากไฟล์ นอกจากนี้ยังสามารถนำมาใช้เมื่อทำงานกับสตริงและการเข้ารหัสอีกด้วย รหัสตัวอย่าง:

public static void main(String []args){
        byte value = 2;
        byte shortByteValue = 0b10; // 2
        System.out.println(shortByteValue);
        // Начиная с JDK7 мы можем разделять литералы подчёркиваниями
        byte minByteValue = (byte) 0B1000_0000; // -128
        byte maxByteValue = (byte) 0b0111_1111; // 127
        byte minusByteValue = (byte) 0b1111_1111; // -128 + 127
        System.out.println(minusByteValue);
        System.out.println(minByteValue + " to " + maxByteValue);
}

อย่างไรก็ตาม อย่าคิดว่าการใช้ประเภทไบต์จะลดการใช้หน่วยความจำ ไบต์ส่วนใหญ่จะใช้เพื่อลดการใช้หน่วยความจำเมื่อจัดเก็บข้อมูลในอาร์เรย์ (เช่น การจัดเก็บข้อมูลที่ได้รับผ่านเครือข่ายในบัฟเฟอร์บางตัว ซึ่งจะถูกนำไปใช้เป็นอาร์เรย์ไบต์) แต่เมื่อดำเนินการกับข้อมูล การใช้ไบต์จะไม่เป็นไปตามความคาดหวังของคุณ นี่เป็นเพราะการใช้งาน Java Virtual Machine (JVM) เนื่องจากระบบส่วนใหญ่เป็น 32 หรือ 64 บิต ไบต์และระยะสั้นระหว่างการคำนวณจะถูกแปลงเป็น int 32 บิต ซึ่งเราจะพูดถึงในภายหลัง ทำให้การคำนวณง่ายขึ้น สำหรับรายละเอียดเพิ่มเติม โปรดดูที่การเพิ่มไบต์จะแปลงเป็น int เนื่องจากกฎของภาษา Java หรือเนื่องจาก jvm . คำตอบยังมีลิงก์ไปยัง JLS (ข้อกำหนดภาษา Java) นอกจากนี้ การใช้ไบต์ผิดที่อาจทำให้เกิดช่วงเวลาที่น่าอึดอัดได้:

public static void main(String []args){
        for (byte i = 1; i <= 200; i++) {
            System.out.println(i);
        }
}

จะมีวงที่นี่ เนื่องจากค่าตัวนับถึงค่าสูงสุด (127) จึงเกิดโอเวอร์โฟลว์และค่าจะกลายเป็น -128 และเราจะไม่มีวันออกจากวงจรนี้

สั้น

ขีดจำกัดของค่าไบต์ค่อนข้างน้อย ดังนั้นสำหรับประเภทข้อมูลถัดไป เราจึงตัดสินใจเพิ่มจำนวนบิตเป็นสองเท่า นั่นคือตอนนี้ไม่ใช่ 8 บิต แต่เป็น 16 นั่นคือ 2 ไบต์ สามารถคำนวณค่าได้ในลักษณะเดียวกัน 2^(16-1) = 2^15 = 32768 ซึ่งหมายความว่ามีช่วงตั้งแต่ -32768 ถึง 32767 ซึ่งไม่ค่อยได้ใช้ในกรณีพิเศษใดๆ ตามที่เอกสารภาษา Java บอกเรา: “ คุณสามารถใช้ตัวสั้นเพื่อบันทึกหน่วยความจำในอาร์เรย์ขนาดใหญ่ได้”

ภายใน

เราก็เลยมาถึงแบบที่ใช้บ่อยที่สุด มันกินพื้นที่ 32 บิต หรือ 4 ไบต์ โดยทั่วไปแล้วเราจะเพิ่มเป็นสองเท่าต่อไป ช่วงของค่าอยู่ระหว่าง -2^31 ถึง 2^31 – 1

ค่า int สูงสุด

ค่าสูงสุดของ int 2147483648 คือ 1 ซึ่งไม่น้อยเลย ตามที่ระบุไว้ข้างต้นเพื่อเพิ่มประสิทธิภาพการคำนวณเพราะว่า จะสะดวกกว่าสำหรับคอมพิวเตอร์ยุคใหม่โดยคำนึงถึงความลึกของบิตในการนับ ข้อมูลสามารถแปลงเป็น int โดยปริยายได้ นี่เป็นตัวอย่างง่ายๆ:

byte a = 1;
byte b = 2;
byte result = a + b;

รหัสที่ไม่เป็นอันตรายดังกล่าว แต่เราได้รับข้อผิดพลาด: “ข้อผิดพลาด: ประเภทที่เข้ากันไม่ได้: การแปลงที่สูญเสียไปจาก int เป็นไบต์” คุณจะต้องแก้ไขให้เป็น byte result = (byte)(a + b); และอีกหนึ่งตัวอย่างที่ไม่เป็นอันตราย จะเกิดอะไรขึ้นถ้าเรารันโค้ดต่อไปนี้?

int value = 4;
System.out.println(8/value);
System.out.println(9/value);
System.out.println(10/value);
System.out.println(11/value);

และเราก็จะได้ข้อสรุป

2
2
2
2

*เสียงตกใจ* ความจริงก็คือเมื่อทำงานกับค่า int ส่วนที่เหลือจะถูกละทิ้ง เหลือเพียงส่วนทั้งหมด (ในกรณีเช่นนี้ ควรใช้ double จะดีกว่า)

ยาว

เรายังคงเพิ่มเป็นสองเท่า เราคูณ 32 ด้วย 2 และได้ 64 บิต ตามธรรมเนียมนี่คือ 4 * 2 นั่นคือ 8 ไบต์ ช่วงของค่าอยู่ระหว่าง -2^63 ถึง 2^63 – 1 มากเกินพอ ประเภทนี้ช่วยให้คุณนับจำนวนมากและมากได้ มักใช้เมื่อต้องทำงานกับเวลา หรือในระยะทางไกลๆ เป็นต้น หากต้องการระบุว่าตัวเลขนั้นยาว ให้วางตัวอักษร L – Long หลังตัวเลข ตัวอย่าง:

long longValue = 4;
longValue = 1l; // Не ошибка, но плохо читается
longValue = 2L; // Идеально

ฉันอยากจะก้าวไปข้างหน้าด้วยตัวเอง ต่อไป เราจะพิจารณาความจริงที่ว่ามี wrappers ที่สอดคล้องกันสำหรับวัตถุดั้งเดิม ซึ่งทำให้สามารถทำงานกับวัตถุดั้งเดิมเป็นวัตถุได้ แต่มีคุณสมบัติที่น่าสนใจ นี่คือตัวอย่าง: การใช้คอมไพเลอร์ออนไลน์ Tutorialspoint เดียวกัน คุณสามารถตรวจสอบรหัสต่อไปนี้:

public class HelloWorld {

     public static void main(String []args) {
        printLong(4);
     }

    public static void printLong(long longValue) {
        System.out.println(longValue);
    }
}

รหัสนี้ใช้งานได้โดยไม่มีข้อผิดพลาด ทุกอย่างเรียบร้อยดี แต่ทันทีที่ประเภทในเมธอด printLong ถูกแทนที่จาก long เป็น Long (เช่น ประเภทนั้นไม่ใช่แบบดั้งเดิม แต่เป็นวัตถุ) Java ก็ไม่ชัดเจนว่าเรากำลังส่งพารามิเตอร์ใด เริ่มสันนิษฐานว่ามีการส่ง int และจะมีข้อผิดพลาด ดังนั้นในกรณีของวิธีการใด ๆ จำเป็นต้องระบุ 4L อย่างชัดเจน มักใช้ long เป็น ID เมื่อทำงานกับฐานข้อมูล

Java float และ Java สองเท่า

ประเภทเหล่านี้เรียกว่าประเภทจุดลอยตัว นั่นคือสิ่งเหล่านี้ไม่ใช่ประเภทจำนวนเต็ม ประเภท float คือ 32 บิต (เช่น int) และ double เรียกว่าประเภทความแม่นยำสองเท่า ดังนั้นจึงเป็น 64 บิต (คูณด้วย 2 เหมือนที่เราต้องการ) ตัวอย่าง:

public static void main(String []args){
        // float floatValue = 2.3; lossy conversion from double to float
        float floatValue = 2.3F;
        floatValue = 2.3f;
        double doubleValue = 2.3;
        System.out.println(floatValue);
        double cinema = 7D;
}

และนี่คือตัวอย่างความแตกต่างของค่า (เนื่องจากความแม่นยำของประเภท):

public static void main(String []args){
        float piValue = (float)Math.PI;
        double piValueExt = Math.PI;
        System.out.println("Float value: " + piValue );
        System.out.println("Double value: " + piValueExt );
 }

ประเภทดั้งเดิมเหล่านี้ใช้ในคณิตศาสตร์เป็นต้น นี่คือข้อพิสูจน์ ซึ่งเป็นค่าคงที่สำหรับการคำนวณตัวเลข PI โดยทั่วไปคุณสามารถดู API ของคลาส Math ได้ สิ่งอื่นๆ ที่ควรมีความสำคัญและน่าสนใจมีดังนี้ แม้แต่ในเอกสารก็บอกว่า: “ ห้ามใช้ประเภทข้อมูลนี้กับค่าที่แม่นยำ เช่น สกุลเงิน คุณจะต้องใช้คลาส java.math.BigDecimal แทน Numbers and Strings ครอบคลุมถึง BigDecimal และคลาสที่มีประโยชน์อื่น ๆ ที่แพลตฟอร์ม Java มอบให้ " นั่นคือไม่จำเป็นต้องคำนวณเงินลอยตัวและสองเท่า ตัวอย่างเกี่ยวกับความแม่นยำโดยใช้ตัวอย่างงานที่ NASA: Java BigDecimal การจัดการกับการคำนวณที่มีความแม่นยำสูง ก็สัมผัสได้ด้วยตัวคุณเอง:

public static void main(String []args){
        float amount = 1.0000005F;
        float avalue = 0.0000004F;
        float result = amount - avalue;
        System.out.println(result);
}

ทำตามตัวอย่างนี้แล้วเติม 0 หน้าเลข 5 และ 4 แล้วคุณจะเห็นความสยดสยองทั้งหมด) มีรายงานในภาษารัสเซียที่น่าสนใจเกี่ยวกับการลอยและสองเท่าในหัวข้อ: https://youtu.be/1RCn5ruN1fk ตัวอย่างการทำงาน ด้วย BigDecimal สามารถดูได้ที่นี่: สร้างเซ็นต์ด้วย BigDecimal อย่างไรก็ตาม float และ double สามารถส่งคืนได้มากกว่าตัวเลข ตัวอย่างเช่น ตัวอย่างด้านล่างจะคืนค่า Infinity:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        System.out.println(positive_infinity);
}

และอันนี้จะกลับมา NAN:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        double negative_infinity = -15.0 / 0;
        System.out.println(positive_infinity + negative_infinity);
}

มันชัดเจนเกี่ยวกับอนันต์ น่านคืออะไร? นี่ไม่ใช่ตัวเลขซึ่งหมายความว่าไม่สามารถคำนวณผลลัพธ์ได้และไม่ใช่ตัวเลข ตัวอย่าง: เราต้องการคำนวณรากที่สองของ -4 รากที่สองของ 4 คือ 2 นั่นคือ 2 จะต้องยกกำลังสอง แล้วเราจะได้ 4 จะต้องยกกำลังสองอะไรจึงจะได้ -4? มันจะไม่ทำงานเพราะ... หากมีจำนวนบวกก็จะยังคงอยู่ และถ้ามันเป็นลบ แล้วลบทีละลบก็จะได้บวก นั่นคือมันคำนวณไม่ได้

public static void main(String []args){
        double sqrt = Math.sqrt(-4);
        System.out.println(sqrt + 1);
        if (Double.isNaN(sqrt)) {
           System.out.println("So sad");
        }
        System.out.println(Double.NaN == sqrt);
}

นี่เป็นภาพรวมที่ดีอีกประการหนึ่งในหัวข้อจำนวนจุดลอยตัว: จุดของคุณอยู่ที่ไหน?

จาวาบูลีน

ประเภทถัดไปคือบูลีน (ประเภทลอจิคัล) โดยจะยอมรับเฉพาะค่าจริงหรือเท็จซึ่งเป็นคีย์เวิร์ดเท่านั้น ใช้ในการดำเนินการทางลอจิคัล เช่น while loop และในการแตกแขนงโดยใช้ if, switch คุณจะพบสิ่งที่น่าสนใจอะไรบ้างที่นี่? ตัวอย่างเช่น ตามทฤษฎีแล้ว เราต้องการข้อมูลเพียง 1 บิตเท่านั้น 0 หรือ 1 นั่นคือจริงหรือเท็จ แต่ในความเป็นจริงแล้ว Boolean จะใช้หน่วยความจำมากขึ้นและจะขึ้นอยู่กับการใช้งาน JVM ที่เฉพาะเจาะจง โดยทั่วไปแล้วจะมีค่าใช้จ่ายเท่ากับ int อีกทางเลือกหนึ่งคือการใช้ BitSet นี่เป็นคำอธิบายสั้น ๆ จากหนังสือ Java Fundamentals: BitSet

จาวาชาร์

ตอนนี้เรามาถึงประเภทดั้งเดิมสุดท้ายแล้ว ดังนั้นข้อมูลในถ่านจึงใช้พื้นที่ 16 บิตและอธิบายอักขระ Java ใช้การเข้ารหัส Unicode สำหรับถ่าน สัญลักษณ์สามารถตั้งค่าตามสองตาราง (คุณสามารถดูได้ที่นี่ ):

• ตารางอักขระ Unicode
• ตารางอักขระ ASCII

ตัวอย่างในสตูดิโอ:

public static void main(String[] args) {
    char symbol = '\u0066'; // Unicode
    symbol = 102; // ASCII
    System.out.println(symbol);
}

อย่างไรก็ตาม ถ่านโดยพื้นฐานแล้วเป็นตัวเลข รองรับการดำเนินการทางคณิตศาสตร์ เช่น ผลรวม และบางครั้งสิ่งนี้อาจนำไปสู่ผลลัพธ์ที่น่าตลก:

public class HelloWorld{

    public static void main(String []args){
        String costForPrint = "5$";
        System.out.println("Цена только для вас " +
        + costForPrint.charAt(0) + getCurrencyName(costForPrint.charAt(1)));
    }

    public static String getCurrencyName(char symbol) {
        if (symbol == '$') {
            return " долларов";
        } else {
            throw new UnsupportedOperationException("Not implemented yet");
        }
    }

}

ฉันขอแนะนำให้ตรวจสอบ IDE ออนไลน์จากTutorialspoint เมื่อฉันเห็นปริศนานี้ในการประชุมใหญ่ครั้งหนึ่ง มันทำให้ฉันรู้สึกดีขึ้น ฉันหวังว่าคุณจะชอบตัวอย่างเช่นกัน) อัปเดต:นี่คือที่ Joker 2017 รายงาน: " Java Puzzlers NG S03 - พวกคุณมาจากไหน! "

ตัวอักษร

ตัวอักษรคือค่าที่ระบุอย่างชัดเจน เมื่อใช้ตัวอักษร คุณสามารถระบุค่าในระบบตัวเลขต่างๆ ได้:

• ระบบทศนิยม: 10
• เลขฐานสิบหก: 0x1F4 เริ่มต้นด้วย 0x
• ระบบฐานแปด: 010 เริ่มต้นจากศูนย์
• ระบบไบนารี่ (ตั้งแต่ Java7): 0b101 เริ่มต้นที่ 0b

ฉันจะอาศัยระบบฐานแปดมากกว่านี้อีกหน่อย เพราะมันตลก:

int costInDollars = 08;

บรรทัดโค้ดนี้จะไม่คอมไพล์:

error: integer number too large: 08

ดูเหมือนเรื่องไร้สาระ ทีนี้มาจำเกี่ยวกับระบบเลขฐานสองและฐานแปดกันดีกว่า ไม่มีระบบคู่ในระบบไบนารี่เพราะว่า มีสองค่า (เริ่มจาก 0) และระบบฐานแปดมี 8 ค่า โดยเริ่มจากศูนย์ นั่นคือไม่มีค่า 8 ในตัวมันเอง ดังนั้นนี่เป็นข้อผิดพลาดที่เมื่อมองแวบแรกดูเหมือนไร้สาระ และอย่าลืมว่านี่คือกฎ "การติดตามผล" สำหรับการแปลค่า:

คลาส Wrapper

Primitives ใน Java มีคลาส wrapper ของตัวเอง เพื่อให้คุณสามารถทำงานกับคลาสเหล่านั้นเป็นอ็อบเจ็กต์ได้ นั่นคือสำหรับประเภทดั้งเดิมแต่ละประเภทจะมีประเภทอ้างอิงที่สอดคล้องกัน คลาส Wrapper นั้นไม่เปลี่ยนรูป: ซึ่งหมายความว่าเมื่ออ็อบเจ็กต์ถูกสร้างขึ้น สถานะของวัตถุ—ค่าของฟิลด์ค่า—จะไม่สามารถเปลี่ยนแปลงได้ คลาส Wrapper ได้รับการประกาศให้เป็นคลาสสุดท้าย: อ็อบเจ็กต์ อ่านอย่างเดียว ฉันอยากจะพูดถึงด้วยว่าไม่สามารถสืบทอดจากคลาสเหล่านี้ได้ Java ทำการแปลงระหว่างประเภทดั้งเดิมและ wrappers โดยอัตโนมัติ:

Integer x = 9;          // autoboxing
int n = new Integer(3); // unboxing

กระบวนการแปลงประเภทดั้งเดิมเป็นประเภทอ้างอิง (int->Integer) เรียกว่าautoboxing และย้อนกลับเรียกว่าunboxing คลาสเหล่านี้ทำให้สามารถบันทึกวัตถุดั้งเดิมภายในวัตถุได้ และวัตถุเองก็จะทำงานเหมือนวัตถุ (ก็เหมือนกับวัตถุอื่น ๆ ) จากทั้งหมดนี้ เราได้วิธีการคงที่ที่มีประโยชน์และหลากหลายมากมาย เช่น การเปรียบเทียบตัวเลข การแปลงสัญลักษณ์ให้เป็นตัวพิมพ์ การกำหนดว่าสัญลักษณ์นั้นเป็นตัวอักษรหรือตัวเลข การค้นหาตัวเลขขั้นต่ำ เป็นต้น ชุดฟังก์ชันการทำงานที่ให้มาจะขึ้นอยู่กับตัว wrapper เท่านั้น ตัวอย่างการใช้งาน wrapper สำหรับ int ของคุณเอง:

public class CustomerInt {

   private final int value;

   public CustomerInt(int value) {
       this.value = value;
   }

   public int getValue() {
       return value;
   }
}

แพ็คเกจหลัก java.lang มีการใช้งานคลาส Boolean, Byte, Short, Character, Integer, Float, Long, Double อยู่แล้ว และเราไม่จำเป็นต้องสร้างคลาสใดๆ ขึ้นมาเอง แต่เพียงนำคลาสสำเร็จรูปกลับมาใช้ใหม่ คน ตัวอย่างเช่น คลาสดังกล่าวทำให้เราสามารถสร้างรายการได้ เนื่องจากรายการควรมีเฉพาะอ็อบเจ็กต์เท่านั้น ซึ่งไม่มีวัตถุพื้นฐาน ในการแปลงค่าประเภทดั้งเดิม มีวิธีคงที่ valueOf เช่น Integer.valueOf(4) จะส่งกลับวัตถุประเภท Integer สำหรับการแปลงกลับมีวิธีการ intValue(), longValue() ฯลฯ คอมไพเลอร์แทรกการเรียก valueOf และ *Value ด้วยตัวเอง นี่คือสาระสำคัญของ autoboxing และ autounboxing ตัวอย่างของการบรรจุอัตโนมัติและการเปิดบรรจุภัณฑ์อัตโนมัติที่นำเสนอข้างต้นมีลักษณะอย่างไร:

Integer x = Integer.valueOf(9);
int n = new Integer(3).intValue();

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับการ บรรจุ อัตโนมัติและการเปิดบรรจุภัณฑ์อัตโนมัติได้ ในบทความนี้

หล่อ

При работе с примитивами существует такое понятие How приведение типов, одно из не очень приятных свойств C++, тем не менее приведение типов сохранено и в языке Java. Иногда мы сталкиваемся с такими ситуациями, когда нам нужно совершать взаимодействия с данными разных типов. И очень хорошо, что в некоторых ситуациях это возможно. В случае с ссылочными переменными, там свои особенности, связанные с полиморфизмом и наследованием, но сегодня мы рассматриваем простые типы и соответственно приведение простых типов. Существует преобразование с расширением и преобразование сужающее. Всё на самом деле просто. Если тип данных становится больше (допустим, был int, а стал long), то тип становится шире (из 32 бит становится 64). И в этом случае мы не рискуем потерять данные, т.к. если влезло в int, то в long влезет тем более, поэтому данное приведение мы не замечаем, так How оно осуществляется автоматически. А вот в обратную сторону преобразование требует явного указания от нас, данное приведение типа называется — сужение. Так сказать, чтобы мы сами сказали: «Да, я даю себе отчёт в этом. В случае чего — виноват сам».

public static void main(String []args){
   int intValue = 128;
   byte value = (byte)intValue;
   System.out.println(value);
}

Whatбы потом в таком случае не говорor что «Ваша Джава плохая», когда получат внезапно -128 instead of 128 ) Мы ведь помним, что в byteе 127 верхнее meaning и всё что находилось выше него соответственно можно потерять. Когда мы явно превратor наш int в byte, то произошло переполнение и meaning стало -128.

Область видимости

Это то место в codeе, где данная переменная будет выполнять свои функции и хранить в себе Howое-то meaning. Когда же эта область закончится, переменная перестанет существовать и будет стерта из памяти и. How уже можно догадаться, посмотреть or получить ее meaning будет невозможно! Так что же это такое — область видимости? Область определяется "блоком" — вообще всякой областью, замкнутой в фигурные скобки, выход за которые сулит удаление данных объявленных в ней. Или How минимум — сокрытие их от других блоков, открытых вне текущего. В Java область видимости определяется двумя основными способами:

• Классом.
• Методом.

Как я и сказал, переменная не видна codeу, если она определена за пределами блока, в котором она была инициализирована. Смотрим пример:

int x;
x = 6;
if (x >= 4) {
   int y = 3;
}
x = y;// переменная y здесь не видна!

И How итог мы получим ошибку:

Error:(10, 21) java: cannot find symbol
  symbol:   variable y
  location: class com.javaRush.test.type.Main

Области видимости могут быть вложенными (если мы объявor переменную в первом, внешнем блоке, то во внутреннем она будет видна).

Заключение

Сегодня мы познакомorсь с восемью примитивными типами в Java. Эти типы можно разделить на четыре группы:

• Целые числа: byte, short, int, long — представляют собой целые числа со знаком.
• Числа с плавающей точкой — эта группа включает себе float и double — типы, которые хранят числа с точностью до определённого знака после запятой.
• Булевы значения — boolean — хранят значения типа "истина/ложь".
• อักขระ - กลุ่มนี้รวมถึงประเภทอักขระด้วย

ดังที่ข้อความด้านบนแสดงไว้ primitives ใน Java ไม่ใช่แบบดั้งเดิมและช่วยให้คุณสามารถแก้ไขปัญหาต่างๆ ได้อย่างมีประสิทธิภาพ แต่นี่ก็แนะนำคุณสมบัติบางอย่างที่เราควรจำไว้หากเราไม่ต้องการพบกับพฤติกรรมที่คาดเดาไม่ได้ในโปรแกรมของเรา อย่างที่พวกเขาพูดคุณต้องจ่ายทุกอย่าง หากเราต้องการสิ่งดั้งเดิมที่มีช่วง "ชัน" (กว้าง) - บางอย่างเช่นยาว - เราจะเสียสละการจัดสรรหน่วยความจำที่ใหญ่กว่าและไปในทิศทางตรงกันข้าม เมื่อบันทึกหน่วยความจำและใช้ไบต์ เราจะได้ช่วงที่จำกัดตั้งแต่ -128 ถึง 127