انواع اولیه در جاوا: آنقدرها هم ابتدایی نیستند

معرفی

توسعه برنامه را می توان کار با برخی داده ها یا بهتر است بگوییم ذخیره و پردازش آنها در نظر گرفت. امروز می خواهم به اولین جنبه کلیدی بپردازم. اطلاعات در جاوا چگونه ذخیره می شود؟ در اینجا ما دو فرمت ممکن داریم: انواع داده مرجع و اولیه . بیایید در مورد انواع انواع اولیه و امکانات کار با آنها صحبت کنیم (هر چه که می توان گفت، این اساس دانش ما از یک زبان برنامه نویسی است). انواع داده های ابتدایی جاوا پایه ای هستند که همه چیز بر آن استوار است. نه، اصلاً اغراق نمی کنم. Oracle یک آموزش جداگانه دارد که به موارد اولیه اختصاص داده شده است: انواع داده های اولیه کمی تاریخچه. در ابتدا صفر بود. اما صفر خسته کننده است. و سپس بیت ظاهر شد . چرا او را چنین نامیدند؟ این نام از مخفف " bi nary digi t " (عدد باینری) به این نام گرفته شد. یعنی فقط دو معنا دارد. و از آنجایی که صفر بود، منطقی است که اکنون یا 0 است یا 1. و زندگی سرگرم کننده تر شده است. تکه ها شروع به جمع شدن در گله کردند. و این دسته ها شروع به بایت (بایت) نامیدند . در دنیای مدرن، بایت = 2 به توان سوم، یعنی. 8. اما معلوم شد که همیشه اینطور نبوده است. حدس ها، افسانه ها و شایعات زیادی در مورد اینکه نام بایت از کجا آمده است وجود دارد. برخی از مردم فکر می کنند که همه چیز مربوط به رمزگذاری های آن زمان است، در حالی که برخی دیگر فکر می کنند که خواندن اطلاعات از این طریق سود بیشتری دارد. یک بایت کوچکترین بخش آدرس پذیر حافظه است. بایت هایی هستند که آدرس های منحصر به فردی در حافظه دارند. افسانه ای وجود دارد که ByTe مخفف Binary Term - یک کلمه ماشینی است. کلمه ماشین - به زبان ساده، این مقدار داده ای است که پردازنده می تواند در یک عملیات پردازش کند. قبلاً اندازه کلمه ماشین با کوچکترین حافظه آدرس پذیر یکسان بود. در جاوا، متغیرها فقط می توانند مقادیر بایت را ذخیره کنند. همانطور که در بالا گفتم، دو نوع متغیر در جاوا وجود دارد:

• انواع اولیه جاوا به طور مستقیم مقدار بایت های داده را ذخیره می کنند (در ادامه به انواع این اولیه ها با جزئیات بیشتری نگاه خواهیم کرد).
• یک نوع مرجع، بایت های آدرس شی را در Heap ذخیره می کند، یعنی از طریق این متغیرها مستقیماً به خود شی دسترسی پیدا می کنیم (نوعی کنترل از راه دور برای شی)

بایت جاوا

بنابراین، تاریخ به ما یک بایت داد - حداقل مقدار حافظه ای که می توانیم استفاده کنیم. و از 8 بیت تشکیل شده است. کوچکترین نوع داده عدد صحیح در جاوا بایت است. این یک نوع 8 بیتی امضا شده است. چه مفهومی داره؟ بیا بشماریم. 2^8 برابر 256 است. اما اگر عدد منفی بخواهیم چه می شود؟ و توسعه دهندگان جاوا تصمیم گرفتند که کد باینری "10000000" نشان دهنده -128 باشد، یعنی مهم ترین بیت (سمت چپ ترین بیت) نشان می دهد که آیا عدد منفی است یا خیر. باینری "0111 1111" برابر است با 127. یعنی 128 را نمی توان به هیچ وجه تعیین کرد، زیرا 128- خواهد بود. محاسبه کامل در این پاسخ آورده شده است: چرا محدوده بایت ها در جاوا 128- تا 127 است؟ برای درک چگونگی به دست آوردن اعداد، باید به تصویر نگاه کنید: بر این اساس، برای محاسبه اندازه 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);
}

به هر حال، فکر نکنید که استفاده از نوع بایت باعث کاهش مصرف حافظه می شود. بایت عمدتاً برای کاهش مصرف حافظه هنگام ذخیره داده ها در آرایه ها استفاده می شود (به عنوان مثال، ذخیره داده های دریافتی از طریق شبکه در برخی از بافرها، که به عنوان یک آرایه بایت پیاده سازی خواهد شد). اما هنگام انجام عملیات روی داده، استفاده از بایت انتظارات شما را برآورده نمی کند. این به دلیل پیاده سازی ماشین مجازی جاوا (JVM) است. از آنجایی که اکثر سیستم ها 32 یا 64 بیتی هستند، بایت و کوتاه در حین محاسبات به یک int 32 بیتی تبدیل می شوند که در ادامه در مورد آن صحبت خواهیم کرد. این کار محاسبات را آسان تر می کند. برای جزئیات بیشتر، ببینید آیا افزودن بایت به دلیل قوانین زبان جاوا یا jvm به int تبدیل می شود؟ . پاسخ همچنین حاوی پیوندهایی به JLS (مشخصات زبان جاوا) است. علاوه بر این، استفاده از بایت در مکان نامناسب می تواند منجر به لحظات ناخوشایند شود:

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 است. این به ندرت برای موارد خاص استفاده می شود. همانطور که اسناد زبان جاوا به ما می گوید: " می توانید از یک کوتاه برای ذخیره حافظه در آرایه های بزرگ استفاده کنید ."

بین المللی

بنابراین ما به پرکاربردترین نوع رسیدیم. 32 بیت یا 4 بایت طول می کشد. به طور کلی، ما به دو برابر شدن ادامه می دهیم. محدوده مقادیر از -2^31 تا 2^31 - 1 است.

حداکثر مقدار int

حداکثر مقدار int 2147483648 1 هست که اصلا کم نیست. همانطور که در بالا گفته شد، برای بهینه سازی محاسبات، زیرا برای رایانه های مدرن، با در نظر گرفتن ظرفیت بیت آنها، شمارش راحت تر است؛ داده ها را می توان به طور ضمنی به int تبدیل کرد. در اینجا یک مثال ساده آورده شده است:

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

چنین کد بی ضرری است، اما ما این خطا را دریافت می کنیم: "خطا: انواع ناسازگار: تبدیل احتمالی با ضرر از int به بایت." شما باید آن را به نتیجه بایت = (بایت) (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; // Идеально

دوست دارم از خودم جلو بزنم. در مرحله بعد، ما این واقعیت را در نظر خواهیم گرفت که لفاف های متناظری برای اولیه ها وجود دارد که کار با چیزهای اولیه را به عنوان اشیا ممکن می کند. اما یک ویژگی جالب وجود دارد. در اینجا یک مثال آورده شده است: با استفاده از همان کامپایلر آنلاین 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 جایگزین شود (یعنی نوع نه اولیه، بلکه شیء می شود)، برای جاوا مشخص نمی شود که چه پارامتری را ارسال می کنیم. شروع می کند به این که یک int در حال انتقال است و یک خطا وجود دارد. بنابراین، در مورد یک روش، باید به صراحت 4L را نشان داد. اغلب از long به عنوان شناسه هنگام کار با پایگاه داده استفاده می شود.

جاوا شناور و جاوا دوبل

به این انواع، انواع ممیز شناور می گویند. یعنی اینها انواع عدد صحیح نیستند. نوع 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 کلاس ریاضی نگاه کنید. چیز دیگری که باید مهم و جالب باشد این است: حتی مستندات می‌گویند: « این نوع داده هرگز نباید برای مقادیر دقیق، مانند ارز استفاده شود. برای این کار، به جای آن باید از کلاس java.math.BigDecimal استفاده کنید. Numbers and Strings BigDecimal و سایر کلاس های مفید ارائه شده توسط پلتفرم جاوا را پوشش می دهد. " یعنی پول شناور و دو برابر نیازی به محاسبه ندارد. مثالی در مورد دقت با استفاده از مثال کار در ناسا: جاوا 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);
}

در مورد بی نهایت واضح است. NaN چیست؟ این عدد نیست ، یعنی نتیجه قابل محاسبه نیست و عدد نیست. این یک مثال است: ما می خواهیم جذر -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);
}

در اینجا یک مرور کلی دیگر در مورد اعداد ممیز شناور وجود دارد: نقطه نظر شما کجاست؟

جاوا بولین

نوع بعدی Boolean (نوع منطقی) است. فقط می تواند مقادیر true یا false را که کلمات کلیدی هستند بپذیرد. در عملیات منطقی مانند حلقه‌های while و در شاخه‌بندی با استفاده از if، switch استفاده می‌شود. چه چیزهای جالبی را می توانید در اینجا پیدا کنید؟ خوب، مثلاً، از نظر تئوری، ما فقط به 1 بیت اطلاعات نیاز داریم، 0 یا 1، یعنی درست یا نادرست. اما در واقعیت، Boolean حافظه بیشتری را اشغال خواهد کرد و این بستگی به اجرای خاص JVM دارد. به طور معمول این هزینه همان int است. گزینه دیگر استفاده از BitSet است. در اینجا توضیح کوتاهی از کتاب Java Fundamentals آورده شده است: BitSet

کاراکتر جاوا

اکنون به آخرین نوع اولیه رسیده ایم. بنابراین، داده های موجود در char 16 بیت می گیرد و کاراکتر را توصیف می کند. جاوا از رمزگذاری یونیکد برای char استفاده می کند. نماد را می توان مطابق با دو جدول تنظیم کرد (شما می توانید آن را در اینجا ببینید ):

• جدول کاراکترهای یونیکد
• جدول کاراکتر ASCII

مثال در استودیو:

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

به هر حال، char که اساسا یک عدد است، از عملیات ریاضی مانند جمع پشتیبانی می کند. و گاهی اوقات این می تواند منجر به عواقب خنده دار شود:

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 - شما همه از کجا می آیید؟! "

تحت اللفظی

Literal یک مقدار مشخص شده است. با استفاده از لفظ، می توانید مقادیر را در سیستم های اعداد مختلف مشخص کنید:

• سیستم اعشاری: 10
• هگزادسیمال: 0x1F4، با 0x شروع می شود
• سیستم اکتال: 010، از صفر شروع می شود.
• سیستم باینری (از Java7): 0b101، از 0b شروع می شود

من کمی بیشتر در مورد سیستم هشتگانه صحبت می کنم، زیرا خنده دار است:

int costInDollars = 08;

این خط کد کامپایل نمی شود:

error: integer number too large: 08

به نظر مزخرف است. حال بیایید سیستم های باینری و اکتال را به یاد بیاوریم. در سیستم باینری هیچ دوتایی وجود ندارد، زیرا دو مقدار وجود دارد (از 0 شروع می شود). و سیستم اکتال دارای 8 مقدار است که از صفر شروع می شود. یعنی خود مقدار 8 وجود ندارد. بنابراین، این خطایی است که در نگاه اول پوچ به نظر می رسد. و به یاد داشته باشید، در اینجا قانون "پیگیری" برای ترجمه مقادیر وجود دارد:

کلاس های لفاف دار

ابتدایی ها در جاوا دارای کلاس های wrapper مخصوص به خود هستند تا بتوانید با آنها به عنوان شی کار کنید. یعنی برای هر نوع اولیه یک نوع مرجع مربوطه وجود دارد. کلاس های Wrapper تغییر ناپذیر هستند: این بدان معنی است که وقتی یک شی ایجاد می شود، وضعیت آن - مقدار فیلد مقدار - نمی تواند تغییر کند. کلاس های Wrapper به عنوان نهایی اعلام می شوند: اشیاء، به اصطلاح، فقط خواندنی. ضمناً اشاره کنم که امکان ارث بردن از این کلاس ها وجود ندارد. جاوا به طور خودکار تبدیل بین انواع اولیه و پوشش های آنها را انجام می دهد:

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

فرآیند تبدیل انواع اولیه به انواع مرجع (int->Integer) autoboxing و برعکس آن unboxing نامیده می شود . این کلاس ها ذخیره یک اولیه را در داخل یک شی ممکن می کنند و خود شی مانند یک شی (خوب، مانند هر شی دیگری) رفتار می کند. با همه اینها، تعداد زیادی روش استاتیک متنوع و مفید مانند مقایسه اعداد، تبدیل نماد به حروف بزرگ، تعیین حرف یا عدد بودن نماد، جستجوی حداقل تعداد و غیره به دست می‌آید. مجموعه عملکرد ارائه شده فقط به خود لفاف بستگی دارد. نمونه ای از پیاده سازی خود شما از یک 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 است و ما نیازی به ایجاد چیزی از خود نداریم، بلکه فقط از کلاس‌های آماده استفاده مجدد می‌کنیم. آنهایی که به عنوان مثال، چنین کلاس هایی به ما توانایی ایجاد مثلاً یک لیست را می دهند ، زیرا یک لیست فقط باید شامل اشیاء باشد، که بدوی نیست. برای تبدیل یک مقدار از یک نوع اولیه، متدهای static 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 — хранят значения типа "истина/ложь".
• شخصیت ها - این گروه شامل نوع کاراکتر است.

همانطور که متن بالا نشان داد، ابتدایی های جاوا چندان ابتدایی نیستند و به شما اجازه می دهند بسیاری از مسائل را به طور موثر حل کنید. اما این همچنین ویژگی هایی را معرفی می کند که اگر نمی خواهیم با رفتار غیرقابل پیش بینی در برنامه خود مواجه شویم باید آنها را در نظر داشته باشیم. همانطور که می گویند، شما باید برای همه چیز هزینه کنید. اگر بخواهیم اولیه‌ای با دامنه «شیب» (وسیع) - چیزی شبیه طولانی - داشته باشیم، تخصیص یک قطعه حافظه بزرگ‌تر و در جهت مخالف را قربانی می‌کنیم. با صرفه جویی در حافظه و استفاده از بایت ها، محدوده محدودی از 128- تا 127 به دست می آید.