Java – Basic Datatypes

Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in the memory.

Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals, or characters in these variables.

There are two data types available in Java −

  • Primitive Data Types
  • Reference/Object Data Types

Primitive Data Types

There are eight primitive datatypes supported by Java. Primitive datatypes are predefined by the language and named by a keyword. Let us now look into the eight primitive data types in detail.

byte

  • Byte data type is an 8-bit signed two’s complement integer
  • Minimum value is -128 (-2^7)
  • Maximum value is 127 (inclusive)(2^7 -1)
  • Default value is 0
  • Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times smaller than an integer.
  • Example: byte a = 100, byte b = -50

short

  • Short data type is a 16-bit signed two’s complement integer
  • Minimum value is -32,768 (-2^15)
  • Maximum value is 32,767 (inclusive) (2^15 -1)
  • Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an integer
  • Default value is 0.
  • Example: short s = 10000, short r = -20000

int

  • Int data type is a 32-bit signed two’s complement integer.
  • Minimum value is – 2,147,483,648 (-2^31)
  • Maximum value is 2,147,483,647(inclusive) (2^31 -1)
  • Integer is generally used as the default data type for integral values unless there is a concern about memory.
  • The default value is 0
  • Example: int a = 100000, int b = -200000

long

  • Long data type is a 64-bit signed two’s complement integer
  • Minimum value is -9,223,372,036,854,775,808(-2^63)
  • Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1)
  • This type is used when a wider range than int is needed
  • Default value is 0L
  • Example: long a = 100000L, long b = -200000L

float

  • Float data type is a single-precision 32-bit IEEE 754 floating point
  • Float is mainly used to save memory in large arrays of floating point numbers
  • Default value is 0.0f
  • Float data type is never used for precise values such as currency
  • Example: float f1 = 234.5f

double

  • double data type is a double-precision 64-bit IEEE 754 floating point
  • This data type is generally used as the default data type for decimal values, generally the default choice
  • Double data type should never be used for precise values such as currency
  • Default value is 0.0d
  • Example: double d1 = 123.4

boolean

  • boolean data type represents one bit of information
  • There are only two possible values: true and false
  • This data type is used for simple flags that track true/false conditions
  • Default value is false
  • Example: boolean one = true

char

  • char data type is a single 16-bit Unicode character
  • Minimum value is ‘\u0000’ (or 0)
  • Maximum value is ‘\uffff’ (or 65,535 inclusive)
  • Char data type is used to store any character
  • Example: char letterA = ‘A’

default value of datatypes

Primitive Types
Type Name Wrapper class Value Range Size Default Value
byte java.lang.Byte integer −128 through +127 8-bit (1-byte) 0
short java.lang.Short integer −32,768 through +32,767 16-bit (2-byte) 0
int java.lang.Integer integer −2,147,483,648 through +2,147,483,647 32-bit (4-byte) 0
long java.lang.Long integer −9,223,372,036,854,775,808 through
+9,223,372,036,854,775,807
64-bit (8-byte) 0
float java.lang.Float floating point number ±1.401298E−45 through ±3.402823E+38 32-bit (4-byte) 0.0f[3]
double java.lang.Double floating point number ±4.94065645841246E−324 through
±1.79769313486232E+308
64-bit (8-byte) 0.0
boolean java.lang.Boolean Boolean true or false 1-bit (1-bit) false
char java.lang.Character UTF-16 code unit (BMP character
or a part of a surrogate pair)
'\u0000' through '\uFFFF' 16-bit (2-byte) '\u0000'

Using Underscore Characters in Numeric Literals

In Java SE 7 and later, any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, for example. to separate groups of digits in numeric literals, which can improve the readability of your code.

For instance, if your code contains numbers with many digits, you can use an underscore character to separate digits in groups of three, similar to how you would use a punctuation mark like a comma, or a space, as a separator.

The following example shows other ways you can use the underscore in numeric literals:

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi =  3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

You can place underscores only between digits; you cannot place underscores in the following places:

  • At the beginning or end of a number
  • Adjacent to a decimal point in a floating point literal
  • Prior to an F or L suffix
  • In positions where a string of digits is expected

The values of the integral types are integers in the following ranges:

  • For byte, from -128 to 127, inclusive

  • For short, from -32768 to 32767, inclusive

  • For int, from -2147483648 to 2147483647, inclusive

  • For long, from -9223372036854775808 to 9223372036854775807, inclusive

  • For char, from '\u0000' to '\uffff' inclusive, that is, from 0 to 65535

Reference Datatypes

reference type is a data type that’s based on a class rather than on one of the primitive types that are built in to the Java language. The class can be a class that’s provided as part of the Java API class library or a class that you write yourself.

Either way, when you create an object from a class, Java allocates the amount of memory the object requires to store the object. Then, if you assign the object to a variable, the variable is actually assigned a reference to the object, not the object itself. This reference is the address of the memory location where the object is stored.

 

Primitive vs. Reference Data Types

 

Primitives vs. References

  • primitive types are the basic types of data
    • byte, short, int, long, float, double, boolean, char
    • primitive variables store primitive values
  • reference types are any instantiable class as well as arrays
    • String, Scanner, Random, Die, int[], String[], etc.
    • reference variables store addresses

Assignment

  • copies the contents of RHS variable into LHS variable
    • primitives: the primitive value is copied
    • references: the address is copied
  • implications: for references the object is not copied, it is shared (reference variables are aliases)

Comparisons (e.g. ==)

  • compares the contents of the variables
    • primitives: the primitive values are compared
    • references: the addresses are compared
  • implications: for references the contents of the objects are not compared

Passing Parameters

  • terminology:
    • formal parameter: the parameter variable that is listed (along with its type) in the method declaration
    • actual parameter: the parameter that is given when the method is called
  • copies the contents of actual parameter into the formal parameter (i.e., pass-by-value)
    • primitives: the primitive value is copied
    • references: the address is copied
  • implications: for references the object is not copied, it is shared (i.e., actual parameter and formal parameter are aliases)
  • primitives: changing the formal parameter’s value doesn’t affect the actual parameter’s value
  • references: changing the formal parameter’s address doesn’t affect the actual parameter’s address but changing the formal parameter’s object does change the actual parameter’s object since they refer to the same object

Returning Values

  • returns a result to where the method was called
    • primitives: the primitive value is returned
    • references: the address is returned
  • recall: local variables and parameters are destroyed when the method finishes execution
  • implications: a locally created object can survive if it is returned or if it is stored in a data member

Java Literals

A literal is a source code representation of a fixed value. They are represented directly in the code without any computation.

Literals can be assigned to any primitive type variable. For example −

byte a = 68;
char a = 'A'

byte, int, long, and short can be expressed in decimal(base 10), hexadecimal(base 16) or octal(base 8) number systems as well.

Prefix 0 is used to indicate octal, and prefix 0x indicates hexadecimal when using these number systems for literals. For example −

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

String literals in Java are specified like they are in most other languages by enclosing a sequence of characters between a pair of double quotes. Examples of string literals are −

Example

"Hello World"
"two\nlines"
"\"This is in quotes\""

String and char types of literals can contain any Unicode characters. For example −

char a = '\u0001';
String a = "\u0001";

Java language supports few special escape sequences for String and char literals as well. They are −

Notation Character represented
\n Newline (0x0a)
\r Carriage return (0x0d)
\f Formfeed (0x0c)
\b Backspace (0x08)
\s Space (0x20)
\t tab
\” Double quote
\’ Single quote
\\ backslash
\ddd Octal character (ddd)
\uxxxx Hexadecimal UNICODE character (xxxx)

 

 

Leave a Reply

Your email address will not be published. Required fields are marked *