Các kiểu nguyên thủy trong Java: Chúng không phải là kiểu nguyên thủy

Giới thiệu

Phát triển ứng dụng có thể được coi là làm việc với một số dữ liệu, hay đúng hơn là lưu trữ và xử lý nó. Hôm nay tôi muốn đề cập đến khía cạnh quan trọng đầu tiên. Dữ liệu được lưu trữ trong Java như thế nào? Ở đây chúng ta có hai định dạng có thể có: kiểu dữ liệu tham chiếu và kiểu dữ liệu nguyên thủy . Hãy nói về các loại kiểu nguyên thủy và khả năng làm việc với chúng (dù người ta có thể nói gì, đây là nền tảng kiến ​​thức của chúng ta về ngôn ngữ lập trình). Các kiểu dữ liệu nguyên thủy của Java là nền tảng cho mọi thứ dựa trên đó. Không, tôi không phóng đại chút nào. Oracle có một Hướng dẫn riêng dành riêng cho kiểu dữ liệu nguyên thủy: Các kiểu dữ liệu nguyên thủy Một chút lịch sử. Ban đầu không có gì cả. Nhưng số 0 thì nhàm chán. Và rồi bit xuất hiện . Tại sao anh ta được gọi như vậy? Nó được đặt tên như vậy từ chữ viết tắt “ bi nary digi t ” (số nhị phân). Tức là nó chỉ có hai nghĩa. Và vì nó bằng 0 nên hợp lý là bây giờ nó là 0 hoặc 1. Và cuộc sống đã trở nên vui vẻ hơn. Các bit bắt đầu tập hợp thành đàn. Và những đàn này bắt đầu được gọi là byte (byte). Trong thế giới hiện đại, byte = 2 mũ ba, tức là 8. Nhưng hóa ra không phải lúc nào cũng như vậy. Có rất nhiều phỏng đoán, truyền thuyết và tin đồn về nguồn gốc của cái tên byte. Một số người cho rằng tất cả là do mã hóa thời đó, trong khi những người khác cho rằng đọc thông tin theo cách này sẽ có lợi hơn. Một byte là phần bộ nhớ có thể định địa chỉ nhỏ nhất. Đó là các byte có địa chỉ duy nhất trong bộ nhớ. Có truyền thuyết cho rằng ByTe là viết tắt của Binary Term - một từ máy. Từ máy - nói một cách đơn giản, đây là lượng dữ liệu mà bộ xử lý có thể xử lý trong một thao tác. Trước đây, kích thước từ của máy giống với bộ nhớ có thể định địa chỉ nhỏ nhất. Trong Java, các biến chỉ có thể lưu trữ các giá trị byte. Như tôi đã nói ở trên, có hai loại biến trong Java:

• các kiểu nguyên thủy java lưu trữ trực tiếp giá trị của byte dữ liệu (chúng ta sẽ xem xét các kiểu nguyên thủy này chi tiết hơn bên dưới);
• một kiểu tham chiếu, lưu trữ các byte địa chỉ của đối tượng trong Heap, nghĩa là thông qua các biến này, chúng ta có quyền truy cập trực tiếp vào chính đối tượng đó (một loại điều khiển từ xa cho đối tượng)

Byte Java

Vì vậy, lịch sử đã cho chúng ta một byte - lượng bộ nhớ tối thiểu mà chúng ta có thể sử dụng. Và nó bao gồm 8 bit. Kiểu dữ liệu số nguyên nhỏ nhất trong java là byte. Đây là loại 8 bit có dấu. Nó có nghĩa là gì? Hãy đếm. 2^8 là 256. Nhưng nếu chúng ta muốn số âm thì sao? Và các nhà phát triển Java đã quyết định rằng mã nhị phân "10000000" sẽ đại diện cho -128, nghĩa là bit có ý nghĩa nhất (bit ngoài cùng bên trái) sẽ cho biết số đó có âm hay không. Nhị phân “0111 1111” bằng 127. Nghĩa là, 128 không thể được chỉ định dưới bất kỳ hình thức nào, bởi vì nó sẽ là -128. Phép tính đầy đủ được đưa ra trong câu trả lời này: Tại sao phạm vi byte -128 đến 127 trong Java? Để hiểu cách lấy các con số, bạn nên nhìn vào hình ảnh: Theo đó, để tính kích thước 2^(8-1) = 128. Điều này có nghĩa là giới hạn tối thiểu (và nó có điểm trừ) sẽ là -128. Và tối đa là 128 – 1 (trừ 0). Nghĩa là, mức tối đa sẽ là 127. Trên thực tế, chúng tôi không thường xuyên làm việc với loại byte ở “mức cao”. Đây chủ yếu là việc xử lý dữ liệu "thô". Ví dụ: khi làm việc với việc truyền dữ liệu qua mạng, khi dữ liệu là tập hợp các số 0 và 1 được truyền qua một loại kênh liên lạc nào đó. Hoặc khi đọc dữ liệu từ tập tin. Chúng cũng có thể được sử dụng khi làm việc với chuỗi và mã hóa. Mã ví dụ:

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);
}

Nhân tiện, đừng nghĩ rằng việc sử dụng loại byte sẽ giảm mức tiêu thụ bộ nhớ. Byte chủ yếu được sử dụng để giảm mức tiêu thụ bộ nhớ khi lưu trữ dữ liệu theo mảng (ví dụ: lưu trữ dữ liệu nhận được qua mạng trong một số bộ đệm, sẽ được triển khai dưới dạng mảng byte). Nhưng khi thực hiện các thao tác trên dữ liệu, việc sử dụng byte sẽ không đáp ứng được mong đợi của bạn. Điều này là do việc triển khai Máy ảo Java (JVM). Vì hầu hết các hệ thống là 32 hoặc 64 bit, byte và short trong quá trình tính toán sẽ được chuyển đổi thành int 32 bit mà chúng ta sẽ nói đến sau. Điều này làm cho việc tính toán dễ dàng hơn. Để biết thêm chi tiết, hãy xem Việc thêm byte có chuyển đổi thành int do quy tắc ngôn ngữ java hay do jvm? . Câu trả lời cũng chứa các liên kết đến JLS (Đặc tả ngôn ngữ Java). Ngoài ra, việc sử dụng byte sai vị trí có thể dẫn đến những khoảnh khắc khó xử:

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

Sẽ có một vòng lặp ở đây. Vì giá trị bộ đếm đạt giá trị tối đa (127) nên sẽ xảy ra tràn và giá trị sẽ trở thành -128. Và chúng ta sẽ không bao giờ thoát ra khỏi chu kỳ đó.

ngắn

Giới hạn cho giá trị byte khá nhỏ. Do đó, đối với loại dữ liệu tiếp theo, chúng tôi quyết định tăng gấp đôi số bit. Tức là bây giờ nó không phải là 8 bit mà là 16. Tức là 2 byte. Các giá trị có thể được tính theo cách tương tự. 2^(16-1) = 2^15 = 32768. Điều này có nghĩa là phạm vi từ -32768 đến 32767. Nó rất hiếm khi được sử dụng cho bất kỳ trường hợp đặc biệt nào. Như tài liệu ngôn ngữ Java cho chúng ta biết: “ bạn có thể sử dụng một đoạn ngắn để tiết kiệm bộ nhớ trong các mảng lớn ”.

int

Vì vậy, chúng tôi đã đến loại được sử dụng thường xuyên nhất. Nó chiếm 32 bit, hoặc 4 byte. Nói chung, chúng tôi tiếp tục tăng gấp đôi. Phạm vi giá trị là từ -2^31 đến 2^31 – 1.

Giá trị int tối đa

Giá trị tối đa của int 2147483648 là 1, một con số không hề nhỏ chút nào. Như đã nêu ở trên, để tối ưu hóa tính toán, bởi vì Sẽ thuận tiện hơn cho các máy tính hiện đại, có tính đến độ sâu bit của chúng, để đếm; dữ liệu có thể được chuyển đổi hoàn toàn thành int. Đây là một ví dụ đơn giản:

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

Mã vô hại như vậy, nhưng chúng tôi nhận được lỗi: "lỗi: loại không tương thích: có thể mất dữ liệu chuyển đổi từ int sang byte." Bạn sẽ phải sửa nó thành byte result = (byte)(a + b); Và một ví dụ vô hại nữa. Điều gì xảy ra nếu chúng ta chạy đoạn mã sau?

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

Và chúng ta sẽ có được kết luận

2
2
2
2

*giọng hoảng loạn* Thực tế là khi làm việc với các giá trị int, phần còn lại sẽ bị loại bỏ, chỉ để lại toàn bộ phần (trong những trường hợp như vậy tốt hơn nên sử dụng double).

dài

Chúng tôi tiếp tục tăng gấp đôi. Chúng tôi nhân 32 với 2 và nhận được 64 bit. Theo truyền thống, đây là 4 * 2, nghĩa là 8 byte. Phạm vi giá trị là từ -2^63 đến 2^63 – 1. Quá đủ. Loại này cho phép bạn đếm số lượng lớn, lớn. Thường được sử dụng khi làm việc với thời gian. Hoặc trên một khoảng cách dài chẳng hạn. Để biểu thị rằng một số dài, hãy đặt chữ L – Long sau số đó. Ví dụ:

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

Tôi muốn vượt lên trước chính mình. Tiếp theo, chúng ta sẽ xem xét thực tế là có các hàm bao tương ứng cho các đối tượng nguyên thủy, giúp chúng ta có thể làm việc với các đối tượng nguyên thủy. Nhưng có một tính năng thú vị. Đây là một ví dụ: Sử dụng cùng trình biên dịch trực tuyến Tutorialspoint, bạn có thể kiểm tra đoạn mã sau:

public class HelloWorld {

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

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

Mã này hoạt động không có lỗi, mọi thứ đều ổn. Nhưng ngay khi kiểu trong phương thức printLong được thay thế từ long thành Long (tức là kiểu này không trở thành nguyên thủy mà là đối tượng), Java sẽ không rõ chúng ta đang truyền tham số nào. Nó bắt đầu cho rằng một int đang được truyền đi và sẽ có lỗi. Do đó, trong trường hợp của một phương pháp, cần phải chỉ ra rõ ràng 4L. Rất thường xuyên long được sử dụng làm ID khi làm việc với cơ sở dữ liệu.

Java nổi và Java kép

Những loại này được gọi là loại dấu phẩy động. Đó là, đây không phải là loại số nguyên. Loại float là 32 bit (như int) và double được gọi là loại có độ chính xác kép, do đó, nó là 64 bit (nhân với 2, tùy thích). Ví dụ:

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;
}

Và đây là một ví dụ về sự khác biệt về giá trị (do độ chính xác của kiểu):

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 );
 }

Ví dụ, những kiểu nguyên thủy này được sử dụng trong toán học. Đây là bằng chứng, một hằng số để tính số PI . Chà, nói chung, bạn có thể xem API của lớp Toán. Đây là điều quan trọng và thú vị khác: ngay cả tài liệu cũng nói: “ Loại dữ liệu này không bao giờ được sử dụng cho các giá trị chính xác, chẳng hạn như tiền tệ. Để làm được điều đó, bạn sẽ cần sử dụng lớp java.math.BigDecimal thay thế. Số và Chuỗi bao gồm BigDecimal và các lớp hữu ích khác do nền tảng Java cung cấp. " Nghĩa là, số tiền thả nổi và gấp đôi không cần phải tính toán. Một ví dụ về độ chính xác bằng cách sử dụng ví dụ về công việc tại NASA: Java BigDecimal, Xử lý các phép tính có độ chính xác cao Vâng, hãy tự mình cảm nhận:

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

Làm theo ví dụ này, sau đó thêm 0 trước số 5 và 4. Và bạn sẽ thấy hết sự kinh hoàng) Có một báo cáo thú vị bằng tiếng Nga về float và double về chủ đề: https://youtu.be/1RCn5ruN1fk Ví dụ về cách làm việc với BigDecimal có thể xem tại đây: Kiếm xu với BigDecimal Nhân tiện, float và double có thể trả về nhiều thứ hơn là chỉ một con số. Ví dụ: ví dụ dưới đây sẽ trả về Infinity:

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

Và cái này sẽ trả về 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);
}

Nó rõ ràng về vô cùng. NaN là gì? Đây không phải là số , nghĩa là kết quả không thể tính được và không phải là số. Đây là một ví dụ: Chúng tôi muốn tính căn bậc hai của -4. Căn bậc hai của 4 là 2. Nghĩa là, 2 phải bình phương và khi đó chúng ta được 4. Phải bình phương bao nhiêu để có -4? Nó sẽ không hiệu quả, bởi vì... nếu có số dương thì nó sẽ giữ nguyên. Và nếu nó âm, thì trừ đi từng điểm trừ sẽ cho điểm cộng. Nghĩa là nó không thể tính toán được.

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);
}

Đây là một cái nhìn tổng quan tuyệt vời khác về chủ đề số dấu phẩy động: Điểm của bạn ở đâu?

Boolean Java

Loại tiếp theo là Boolean (loại logic). Nó chỉ có thể chấp nhận các giá trị true hoặc false, đó là các từ khóa. Được sử dụng trong các hoạt động logic như vòng lặp while và trong phân nhánh bằng cách sử dụng if, switch. Bạn có thể tìm thấy điều thú vị gì ở đây? À, ví dụ, về mặt lý thuyết, chúng ta chỉ cần 1 bit thông tin, 0 hoặc 1, tức là đúng hoặc sai. Nhưng trên thực tế, Boolean sẽ chiếm nhiều bộ nhớ hơn và điều này sẽ phụ thuộc vào việc triển khai JVM cụ thể. Thông thường, chi phí này tương đương với int. Một tùy chọn khác là sử dụng BitSet. Đây là mô tả ngắn từ cuốn sách Cơ bản về Java: BitSet

ký tự Java

Bây giờ chúng ta đã đạt đến kiểu nguyên thủy cuối cùng. Vì vậy, dữ liệu trong char chiếm 16 bit và mô tả ký tự. Java sử dụng mã hóa Unicode cho char. Ký hiệu có thể được đặt theo hai bảng (bạn có thể xem tại đây ):

• Bảng ký tự Unicode
• Bảng ký tự ASCII

Ví dụ trong studio:

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

Nhân tiện, char, về cơ bản là một số, hỗ trợ các phép toán như tổng. Và đôi khi điều này có thể dẫn đến những hậu quả buồn cười:

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");
        }
    }

}

Tôi thực sự khuyên bạn nên kiểm tra IDE trực tuyến từ tutorialspoint . Khi tôi nhìn thấy câu đố này tại một trong những hội nghị, nó đã nâng cao tinh thần của tôi. Tôi hy vọng bạn cũng thích ví dụ này) CẬP NHẬT: Đây là tại Joker 2017, báo cáo: " Java Puzzlers NG S03 - Tất cả các bạn đến từ đâu?! "

chữ

Một chữ là một giá trị được chỉ định rõ ràng. Sử dụng hằng số, bạn có thể chỉ định các giá trị trong các hệ thống số khác nhau:

• Hệ thập phân: 10
• Hệ thập lục phân: 0x1F4, bắt đầu bằng 0x
• Hệ bát phân: 010, bắt đầu từ số 0.
• Hệ thống nhị phân (kể từ Java7): 0b101, bắt đầu từ 0b

Tôi sẽ tập trung nhiều hơn một chút vào hệ bát phân, vì nó buồn cười:

int costInDollars = 08;

Dòng mã này sẽ không biên dịch:

error: integer number too large: 08

Nó có vẻ như vô nghĩa. Bây giờ chúng ta hãy nhớ về hệ nhị phân và bát phân. Không có số 2 trong hệ nhị phân, bởi vì có hai giá trị (bắt đầu từ 0). Và hệ bát phân có 8 giá trị, bắt đầu từ 0. Tức là bản thân giá trị 8 không tồn tại. Vì vậy, đây là một lỗi thoạt nhìn có vẻ vô lý. Và cần nhớ, đây là quy tắc “tiếp theo” để dịch các giá trị:

Các lớp bao bọc

Các nguyên hàm trong Java có các lớp trình bao bọc riêng để bạn có thể làm việc với chúng dưới dạng đối tượng. Nghĩa là, đối với mỗi kiểu nguyên thủy có một kiểu tham chiếu tương ứng. Các lớp trình bao bọc là bất biến: điều này có nghĩa là khi một đối tượng được tạo, trạng thái của nó—giá trị của trường giá trị—không thể thay đổi. Các lớp trình bao bọc được khai báo là cuối cùng: các đối tượng, có thể nói, chỉ đọc. Tôi cũng muốn đề cập rằng không thể kế thừa từ các lớp này. Java tự động thực hiện chuyển đổi giữa các kiểu nguyên thủy và trình bao bọc của chúng:

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

Quá trình chuyển đổi kiểu nguyên thủy thành kiểu tham chiếu (int->Integer) được gọi là autoboxing và ngược lại được gọi là unboxing . Các lớp này cho phép lưu trữ một nguyên thủy bên trong một đối tượng và bản thân đối tượng đó sẽ hoạt động giống như một Đối tượng (à, giống như bất kỳ đối tượng nào khác). Với tất cả những điều này, chúng ta có được một số lượng lớn các phương thức tĩnh hữu ích và đa dạng, chẳng hạn như so sánh các số, chuyển đổi một ký tự thành ký tự, xác định xem một ký tự là chữ cái hay số, tìm kiếm số tối thiểu, v.v. Bộ chức năng được cung cấp chỉ phụ thuộc vào chính trình bao bọc. Một ví dụ về cách bạn triển khai trình bao bọc cho int:

public class CustomerInt {

   private final int value;

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

   public int getValue() {
       return value;
   }
}

Gói chính, java.lang, đã triển khai các lớp Boolean, Byte, Short, Character, Integer, Float, Long, Double và chúng ta không cần tạo bất cứ thứ gì của riêng mình mà chỉ cần sử dụng lại các lớp có sẵn những cái đó. Ví dụ: các lớp như vậy cho chúng ta khả năng tạo một Danh sách , bởi vì Danh sách chỉ nên chứa các đối tượng, còn đối tượng nguyên thủy thì không. Để chuyển đổi một giá trị của kiểu nguyên thủy, có các phương thức valueOf tĩnh, ví dụ: Integer.valueOf(4) sẽ trả về một đối tượng có kiểu Integer. Để chuyển đổi ngược, có các phương thức intValue(), longValue(), v.v. Trình biên dịch sẽ tự chèn các lệnh gọi đến valueOf và *Value, đây là bản chất của tính năng tự động đóng hộp và tự động hủy hộp. Ví dụ về tự động đóng gói và tự động giải nén được trình bày ở trên trông như thế nào:

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

Bạn có thể đọc thêm về tự động đóng gói và tự động giải nén trong bài viết này .

Dàn diễn viên

При работе с примитивами существует такое понятие 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 — хранят значения типа "истина/ложь".
• Ký tự - nhóm này bao gồm loại char.

Như văn bản trên đã chỉ ra, các kiểu nguyên thủy trong Java không quá nguyên thủy và cho phép bạn giải quyết nhiều vấn đề một cách hiệu quả. Nhưng điều này cũng giới thiệu một số tính năng mà chúng ta nên lưu ý nếu không muốn gặp phải những hành vi không thể đoán trước trong chương trình của mình. Như họ nói, bạn phải trả tiền cho mọi thứ. Nếu chúng ta muốn một phạm vi nguyên thủy có phạm vi “dốc” (rộng) - chẳng hạn như dài - chúng ta hy sinh việc phân bổ một phần bộ nhớ lớn hơn và theo hướng ngược lại. Bằng cách tiết kiệm bộ nhớ và sử dụng byte, chúng tôi nhận được phạm vi giới hạn từ -128 đến 127.