Constants and Variables

Constants, Datatypes, and Variables

Constants

In IT 313, we will use five different types of Java constants: int, double, char, string, and boolean.

Integer
- int (integer) constants are positive, negative, or zero numbers that do not have a fractional part:
```
34  643938  -21  -38472874  0
```
- No commas are allowed in int constants.
- int constants are represented as 4 byte binary, which means that they have an approximate range of -2 billion to 2 billion. The exact range is -2³¹ to 2³¹ - 1.
- To force integer constants to be represented internally as 16 byte binary numbers, use the L suffix for long:
```
10000000000L    -10000000000L
```
- Integer constants can also be expressed in other bases: binary, octal, or hex. For example:
  
  Base Constant Base 10 Meaning
  
  2 0b11001110^* 206
  
  8 0457^** 111
  
  10 598 598
  
  16 0x3e^*** 62
  
  ^* Zero, lower case b prefix
  ^** Zero prefix
  ^*** Zero, lower case x prefix
- Important: that even if constant values are expressed in various bases, all integer Java constants are stored in memory as binary values.

Base	Constant	Base 10 Meaning
2	0b11001110^*	206
8	0457^**	111
10	598	598
16	0x3e^***	62

Floating Point

double (floating point) constants are positive or negative numbers with a fractional part, for example,
```
46.1982    0.00441   -237.1273   23.00
```
The constant 23.00 is a double constant, even though it could be converted to an int without loss of data.
No commas are allowed in floating point constants.

Floating point numbers can also be written in base 10 scientific notation with positive or negative exponents. Here are some examples:

Ruby Constant	Scientific Notation	Meaning
3.0e2	3.0 x 10²	300
5.98e24	5.98 x 10²⁴	Mass of Earth in Kilos
9.11e-31	9.11 x 10^-31	Mass of Electron in Kilos

By default, floating point constants are represented in memory using IEEE double precision floating point notation.
Double precision floating point contants take up 8 bytes (64 bits) in memory.
To force the constant to be represented in IEEE single precision floating point notation, use an F suffix for float:
See Wikipedia for more information about the IEEE 754 Floating Point Standard.
For general information about floating point arithmetic, check out this link:

Character
- char (character) constants are delimited by single quotes.
- char constants include all of the characters found on standard American keyboards.
- Examples are:
- Escape characters starting with a backslash are used to represent non-printable characters:
  
  Character Meaning
  
  '\'' Single Quote
  
  '\"' Double Quote
  
  '\\' Backslash
  
  '\t' Tab
  
  '\n' New Line
  
  '\r' Carriage Return
  
  '\f' Form Feed
  
  '\b' Backspace
  
  '\0' Null Character (Ascii Code 0)
- Unicode characters can also be represented in Java. Here are some examples:
  
  Character Appearence Language
  
  '\u03b1' α Greek
  
  '\u03b2' β Greek
  
  '\u03b3' γ Greek
  
  '\u05d0' ℵ Hebrew
  
  '\u221e' ∞ Math Symbol
- Here is the official Unicode site containing codes for all registered characters: unicode.org.
- Unicode characters are difficult to work with at the DOS command prompt. They are usually used for graphical applications or when reading from or writing to files on disk.
- Java can only handle two byte unicode characters. There are so many Chinese characters (more than 65,000) represented in Unicode so that occasionally four bytes are needed for such a Chinese character.
- See the Unicode1 and Unicode2 Examples in the unicode examples file.
String
- A String constant is a sequence of characters delimited by double quotes.
- Examples of string constants:
Boolean
- A boolean constant takes on either of the values true or false.

Character	Meaning
'\''	Single Quote
'\"'	Double Quote
'\\'	Backslash
'\t'	Tab
'\n'	New Line
'\r'	Carriage Return
'\f'	Form Feed
'\b'	Backspace
'\0'	Null Character (Ascii Code 0)

Character	Appearence	Language
'\u03b1'	α	Greek
'\u03b2'	β	Greek
'\u03b3'	γ	Greek
'\u05d0'	ℵ	Hebrew
'\u221e'	∞	Math Symbol

Datatypes

A datatype is a way of representing data internally in a computer.

Java uses these primitive datatypes:

Datatype	Representation	Default Value	Size (bytes)	Range	Sig. Digits
byte	Unsigned Integer	0	1	0 to 2^8-1 = 255
short	Signed Integer	0	2	-2^15 to -2^15-1
int	Signed Integer	0	4	-2^31 to -2^31-1
long	Signed Integer	0L	8	-2^63 to -2^63-1
double	Double Precision Floating Point	0.0	16	-1.79810^308 to 1.79810^308	14 or 15
float	Single Precision Floating Point	0.0	8	-3.40310^38 to 3.40310^38	7
char	Binary Unicode Code	'\0'	2	Unicode Character
String	String of Characters	""	4 or 8 byte Object Reference	String of length 2^31-1
boolean	false stored as 0 true stored as 1	false	1	false or true

Variables

A variable is a location in memory that contains data, which might be changed during the execution of a Java program. There are three aspects to a variable: (1) name, (2) address, (3) value.
The name of a Ruby variable must start with a letter (upper or lowercase) or underscore and consist entirely of letters, digits, or underscores.
There is no limit to the length of a Java variable name. However, names longer than about 12 characters become unwieldy. Here are some examples of Ruby variable names:
Java is case sensitive, which means that capitalization matters. The names numberOfCustomers and numberofcustomers represent two different variables.
By convention, Java spells local variable names in lower camel casing (first letter lower case, each new word starts with upper case) and uses upper camel casing to separate words (same as lower camel casing, but start with upper case letter). An example of a local variable name is numberOfCustomers.
The address of a variable is the location in the computer's memory where the data is stored. The Ruby interpreter keeps a symbol table that maintains the correspondence between the variable's name and its address, so the programmer need not be explicity concerned about the address and, in fact, does not have access to the address of a given variable.
The value of a variable is the piece of data currently stored at its address, which is interpreted according to the datatype of the variable. A variable can only contain one value at a time.

Java variables must be declared. For example:

int n;
double x, y;
char c, d;
String s, t;
boolean f;

These variables can be later assigned values like this:

n = 39;
x = 534.56;
y = 3.45e12;
c = 'a';
d = '\t';
s = "dog";
t = "cat";
f = false;

Variables may be initialized at the same time they are declared:

int n = 39;
double x = 534.36, y = 3.45e12;
char c = 'a', d = '\n';
String s = "dog", t = "cat";
boolean f = false;

The Assignment Operator

The assignment operator is used to assign a value on the right side of an expression to a variable on the left side. For example,
assigns the value 5 to the variable x.
Question: why is the following not a legal assignment?

The + operator

The + operator is an overloaded operator. It's behavior depends on the datatypes of its operands.
+ performs addition if both of its operators are numeric (integer or floating point).
+ performs concatenation if at least of its operators is String.

Here are some examples:

int n = 5, m = 7;
String s = "dog", t = "cat";
System.out.println(n + m);  // Output: 12
System.out.println(s + t);  // Output: dogcat
System.out.println(n + t);  // Output: 5cat
System.out.println(s + m);  // Output: dog7