"Hi, Amigo!"

"Hi, Rishi!"

"You've already mastered the basics of Java syntax, so now I want to give you some more details."

"Today, we'll talk about primitive types and how much memory they occupy. This knowledge will come in handy, maybe even today. Here are the basic types:"

Type | Size, bytes |
Value range | Default value | Description |
---|---|---|---|---|

byte | 1 | -128 .. 127 | 0 | The smallest integer, 1 byte |

short | 2 | -32,768 .. 32,767 | 0 | Short integer, 2 bytes |

int | 4 | -2*10^{9} .. 2*10^{9} |
0 | Integer, 4 bytes |

long | 8 | -9*10^{18} .. 9*10^{18} |
0L | Long integer, 8 bytes |

float | 4 | -10^{127} .. 10^{127} |
0.0f | Fractional number, 4 bytes |

double | 8 | -10^{1023} .. 10^{1023} |
0.0d | Fractional number that is twice the size of a float, 8 bytes |

boolean | 1 | true, false | false | Boolean type (only true or false) |

char | 2 | 0..65,535 | '\u0000' | Characters, 2 bytes, all unsigned values |

Object | 4 | Any reference or null. | null | Stores references to instances of Object or classes that descend from Object |

"Let me tell you more about each type."

"The byte type is the smallest integer type. Variables of this type occupy just 1 byte of memory. A byte can store values in the range between -128 and 127."

"Why do we need such a small type? Why can't we always use int?"

"We could. But if you're creating large arrays whose elements never need to store values greater than 100, why not use this type? Does that make sense?"

"A **short** is twice as long as a byte, and it also only stores integers. The biggest positive number it can store is 32,767. The biggest negative number it can store is -32,768."

"The **int** type you are already familiar with. It can store integers in the range ±2,000,000,000."

"The **float** type was created to store real (fractional) numbers. Its size is 4 bytes."

"Fractional numbers are stored in a rather interesting form."

"For example, the number 987654.321 can be represented as 0.987654321*10^{6}. This means that it can be represented as two numbers in memory: 0.987654321 (**mantissa, or significand**) and 6 (**base-10 exponent**)."

"What do we need that for?"

"This approach lets us use 4 bytes to store numbers much greater than what an int can store. To do this, we have to sacrifice accuracy. Only a portion of those bytes are used to store the mantissa, which means that these numbers only store 6-7 decimal places. Less significant decimal places are discarded."

"These numbers are also called **float**ing-point numbers. This is where the name the **float** type came from."

"I see."

"The **double** type is similar to **float**, but twice as long (hence the name), taking up 8 bytes. It can accommodate a larger mantissa and more significant digits. If you need to store real numbers, always try to use this type."

"**char** is a hybrid type. Its values can be interpreted both as numbers (which can be added or subtracted) and characters. This is possible because even if characters have a visual representation, the computer mainly sees them as numbers. And it's more convenient to treat them as numbers. One more thing: the **char** type is always positive. It can't hold negative values."

"The **boolean** type is a logical type that can store only two values: **true** or **false **."

"Despite its presence in this chart, the **Object** type isn't a primitive type. It's the base class for all classes in Java. First, all classes are derived from it and therefore contain its methods. Second, an Object variable can store references to objects of any type, including null (**a null** reference)."

"I've learned a lot today. Thank you for the lesson, Rishi."