Basic Building Blocks

Getting Started: Basics of Java

Components of Java Programs

statements - A statement is some action or sequence of actions, given as a command in code. A statement ends with a semi-colon (;).
blocks - A block is a set of statements enclosed in set braces { }. Blocks can be nested.
classes - A class is a blueprint for building objects in Java. Every Java program has at least one class. Programmers can define new classes, and there are some built-in classes in Java, as well as libraries of classes and objects available for use.
methods - A method is a function (i.e. subroutine) that belongs to a class.
the main method - Every Java application must have a main method, which defines where the program begins. In Java, the main method belongs to a class. Any class can have a main method. The main method looks like this:
```
  public static void main(String[] args)
  {
    // statements
  }
```

Statements

Statements in Java are made up of:

reserved words - words that have pre-defined meanings in the Java language
identifiers - words that are created by programmers for names of variables, functions, classes, etc.
operators - special symbols that perform certain actions on their operands
- A unary operator has one operand
- A binary operator has two operands
literals - literal values written in code, like strings or numbers

integer literal - an actual integer number written in code (4, -10, 18)
float literal - an actual decimal number written in code (4.5, -12.9, 5.0)
character literal - a character in single quotes: ('F', 'a', '\n')
string literal - a string in double quotes: ("Hello", "Bye", "Wow!\n")

Escape Sequences

String and character literals can contain special escape sequences that represent single characters that cannot be represented with a single character in code.

Escape Sequence	Meaning
`\n`	newline
`\t`	tab
`\b`	backspace
`\r`	carriage return
`\"`	double quote
`\'`	single quote
`\\`	backslash

Basic Console Output

Basic console output in Java uses the built-in object System.out. Primary output methods:

print - prints information sent to it
println - prints information and advances to next line

Example that illustrates print and println

In calls to print and println, multiple items can be printed in a single call through the use of the + operator, which represents string concatenation when at least one of its operands is a string. (If both operands are numeric items, the + operator is addition).

Example of string concatenation in output
Example of string concatenation vs. addition in output

Comments

Comments are used to improve the readability of code. Comments are ignored by the compiler. There are two styles of comments in Java:

block style - comment enclosed in a block that starts with /* and ends with */
```
    /* This is a comment */ 
```
Line style - comment follows the double slash marker //. Everything after this mark, to the end of the line, is a comment.
```
    int x;    // This is a comment 
    x = 3;    // This is a comment 
```

Variables

Every variable has a:

Name -- identifier chosen by the programmer
Type -- specified in the declaration of the variable
Size -- determined by the type
Value -- the data stored in the variable's memory location

Rules for names of identifiers

identifiers can consist only of letters, digits, and underscores, and the dollar sign
identifier name must start with a letter, underscore, or dollar sign $
case sensitive!
reserved words cannot be used as identifiers
an identifer can be any length

Built-in Data Types

char - used for storing single characters (letters, digits, special symbols, etc).
boolean - has two possible values, true or false
integer types - for storage of integer values
- byte - 8 bits
- short - 16 bits
- int - 32 bits
- long - 64 bits
floating point types - for storage of decimal numbers (i.e. a fractional part after the decimal)
- float - 32 bits
- double - 64 bits

Declaring Variables

Format:

  datatype variableName

Always starts with a type!

  int x;
  float y;
  char ch;
  bool answer;
  int x = 5;	        // can initialize variable on the declaration line
  char item = 'A';
  int a, b, c;           // can also list several variables in one declaration 
                         //  statement, separated by commas
  float a=3.4, b=5.1, c;

A variable can be declared constant by using the keyword final - must initialize in the same statement

  final double PI = 3.14159;

Console Input

Input is a trickier matter than output in Java, because there is not an easy built-in object for handling console input. A class called MyInput is provided here, which contains three methods called readInt, readDouble, and readString for reading these types of data from the keyboard. For now, do not worry about how this class works. Simply use this class in programs that need to do basic console input.

The MyInput class

Arithmetic Operators

The basic operators are: + , - , * , / , %
These do arithmetic as expected (addition, subtraction, etc). Division is a special case. For integers, the / operator gives the quotient of a division, and the % operator, called the modulus operator, gives the remainder.

  int remainder = 19 % 5;    // gives the result 4
  int quotient = 19 / 5;     // gives the result 3

This example illustrates the arithmetic operations in Java

Order of Operations

Unary Operations are first, ie -1+3 evaluates the -1 first
Then *, /, and % have equal precedence
After any of the above have been evaluated, addition and subtraction is done.
Associativity on arithmetic operators at the same level are as usual -- left to right.

Assignment Operator

Format:

  variable = expression

Note that the right side can be an expression (i.e. a computation involving values, variables, operators, etc), which can be evaluated down to a single value. The left side must be a storage location (i.e. a variable).

  // Valid assignment examples
  x = 5;
  y = 2.34;
  option = 'X';
  x = a*(3/y)+z;

  3 = x;	  // ILEEGAL.  (backwards)
  a + 2 = b;	  // ILLEGAL.  Not a variable on the left

The assignment operator's associativity is right to left:

  a = b = c = d = 5;

In the above statement, the operation d = 5 executes first, and the value of the assignment (5) is returned, to be used as the operand for the next assignment operator.

Shortcut Operators

  v += e;    means    v = v + e; 
  v -= e;    means    v = v - e; 
  v *= e;    means    v = v * e; 
  v /= e;    means    v = v / e; 
  v %= e;    means    v = v % e;

Increment and Decrement

++x and x++ used to increment x (equivalent to x = x + 1)
--x and x-- used to decrement x (equivalent to x = x - 1)

++x is pre-increment. The increment is done before x is used in the rest of the expression.
x++ is post-increment. The increment is done after x is used in the rest of the expression.

Pre-decrement and post-decrement work in a similar fashion.

Note: This only matters if the variable is actually used in another expression. These two statements by themselves have the exact same effect:

  x++;	// increment x
  ++x;  // increment x

Examples of pre-increment and post-increment

  int a = 5, b = 3;
  int c = b * ++a;	// After this statement, c is 18, a is 6

  int x = 6, y = 4;
  int d = x - y++;	// After this statement, d is 2, y is 5

Type Conversions

When working with mixed types, conversions can take one of two forms:

Automatic type conversion
Cast operations

  int i1 = 5, i2;
  short s = 3;
  double d1 = 23.5, d2;
  float f = 12.3;
  byte b = 10;

  d2 = i1;	  // automatically allowed
  i1 = b;	  // automatically allowed
  s = (short)i1;  // requires cast operation (some data may be lost)
  i2 = (int)d1;	  // requires cast operation (decimal data may be lost)

  d2 = f + d1;	  // automatically allowed
  i2 = b + s;	  // automatically allowed

More Code Examples

These are simple program examples from the textbook (chapter 2)