Java: Data Types

• The fundamental unit of information in a computer is a bit.
• A bit has two states: on (1) or off (0).
• Bits are commonly grouped into bytes, each consisting of 8 bits.
• A single byte can represent 256 (2^8) different values.

Data Types in Java

• Java, like many programming languages, uses data types to represent and store different kinds of data as variables.
• Each data type requires a specific amount of memory, measured in bytes.

Integer Data Types

• The byte integer data type represents numbers from -128 to 127, corresponding to the 256 states of 8 bits.
• Java offers several integer data types with varying sizes and ranges:
• byte: 8 bits, range: -2^7 to 2^7-1, approximate range: ±100
• short: 16 bits, range: -2^15 to 2^15-1, approximate range: ±30000
• int: 32 bits, range: -2^31 to 2^31-1, approximate range: ±2,000,000,000
• long: 64 bits, range: -2^63 to 2^63-1, approximate range: ±9×10^18
• The int type is suitable for most tasks and is often the default choice for integers.
• Integer constants should not include decimal points or separators like commas or spaces.

Real Data Types

• Real data types in Java:
• float: 32 bits, precision: at least 6 decimal places, approximate range: ±3.4×10^38
• double: 64 bits, precision: at least 15 decimal places, approximate range: ±1.8×10^308.
• Historically, float was used for memory and speed, double is recommended for most real number calculations due to improved performance in modern computers.
• Valid floating-point constants can be written with or without a decimal point.
• Floating-point constants can be expressed in scientific notation (e.g., 5.6e2 represents 5.6 × 10^2).

Character Data Type

• Java uses Unicode to represent characters, using 16 bits (2 bytes) per character.
• Unicode allows representing 65536 different characters, accommodating most of the world's writing systems.
• Characters in Java are of type char.

Identifiers

• Identifiers are names used to keep track of variables, methods, or classes.
• Rules for creating identifiers:
• Must start with a letter, alphabet, digit (0-9), or underscore (_).
• The first character cannot be a digit.
• Conventions for identifiers:
• Classes: PascalCase (e.g., MyClass)
• Variables and methods: camelCase (e.g., myVariable, calculateValue)
• Certain reserved words cannot be used as identifiers (e.g., abstract, assert, boolean, break, byte, etc.).

Declaring Variables

• Declaration statements creates variables, specifying the type and identifier.
• Syntax: <type> <identifier>; (e.g., int count; or float radius, circumference, area;)
• Declaration statements are terminated by a semicolon (;).

Assigning Values to Variables

• Assigning a value to a variable makes it useful.
• Simplest way is through the assignment statement.
• Several ways to assign value to variables:
• During the variable declaration: int total = 15;
• Immediately after declaring: int total; total = 15;
• Later in the program: int total; ... total = 15;
• Using the value from another variable: int a = 5; int b; b = a;

String Variables

• Java is object-oriented, having eight primitive data types and unlimited objects.
• String object is useful.
• String variables can be declared and assigned values similarly to primitive types.
• String variables hold a reference to a string object stored elsewhere in memory, not the string itself.
• Once string is created, its value cannot be changed i.e. immutable objects.
• A variable refers to a different string (String firstName = "Bob"; firstName = "Doug").

Converting Between (Numeric) Data Types

• When assigning a value to a variable, the data type must match the value.
• Numeric data types can be converted from smaller to larger data types.
• Legal conversions: byte -> short -> char -> int -> long -> float -> double
• Java can be forced to accept type conversion with called a cast.
• Syntax: <variable> = (<data type>) <questionable data>;

Output of Variables

• The print and println methods output combinations of variables.
• Variable must have been assigned a value before outputting it.

Constants

• Java associates an identifier with a constant value, a variable with the final modifier.
• Constants are named in all uppercase.
• Syntax: final int CLASS_SIZE = 30;
• final char TERMINATOR ='*';
• Value cannot be changed after assignment.