Session 2 Lecture Notes for First Course in Java
course homepage      course calendar

LECTURE

ABC's of the Java Programming Language

Statements and Expressions

Statements

A statement is a command that you write in your program.
A statement must end with a semicolon (;) so that the parser in the Java compiler (javac) knows you end this point to be the end of your statement.

System.out.println("Hello Luke"); // pass a string argument to a method

double bodyTemperature = 98.6;  // assign a value to a primitive variable

HumanBeing.inalienableRight = pursuitOfHappiness;  // assign a value to a property of an object

Comments

Comments are for human code readers. The compiler ignores comments.
Insert comments in your code that you, and others who will use your code, know what the code is about.
It is more common for code to have too few comments than too many comments.

In the preceding statements, a comment follows each statement. 
Two slash characters (//) define the comment through the end of the current line.

/* A slash followed by an asterisk
defined the beginning of a multi-line comment,
which ends with the reverse, an asterisk, followed by a slash */ 

Expressions

An expression is a statement that returns a value. 
In both examples below, the Java virtual machine will:

1. Perform a calculation or an evaluation.
2. Return a return value.

sum = priceOfItem1 + priceOfItem2; // the return value is stored in the variable sum

selfEvidentTruth = HumanBeing.IsCreatedEqual();  // boolean return value must be true or false

Declarations and Assignments

A declaration is a statement that lets the compiler know that we are going to use a variable to refer to a value of a certain type.

An assignment gives (assigns) a value to a variable. Typically, in Java, we assign a value to a variable when we declare that variable.

For example,

int temperature = 70; // Fahrenheit
float drunk = .01; // in percent
final int BOILING_POINT = 212; // a constant
// We will learn about arrays in detail later.
// What follows is an array of characters 
// for the 7 days of the week.
// (Single quotes are for chars.)
// Each element has a unique index. 
// The first 's' (Sunday) has the index of zero.
// The second 's' (Saturday) has the index of 6.
char[] daysOfTheWeek = {'s', 'm', 't', 'w', 't', 'f', 's'};
// Use double quotes for strings.
String[] myDays = {"Sunday", "Monday", "Tuesday"};

Literals

A literal is different from a variable. Whereas a variable is name for a storage area for a value that can change, a literal is the direct representation of a value.

double sum = 382.36;
String firstName = "Luke"; // string literal inside quotation marks
boolean isExpensive = false;

Here are character literals you might use:

// character literal inside single quote marks
'\n'     new line
'\t'    tab

Variables

A variable in a program is something with a name, the value of which can vary.

Syntax: Data type + variable name

The syntax to declare a variable is to specify the type, then specify the name of the variable.

You can also assign a value to the variable when you declare it.

<type> <name> [= <value>];

// brackets mean optional

The syntax to assign a value to a variable is to put the name of the variable, followed by an equal sign (=) and the new value. The equal sign is the assignment operator.

<name> = <value>;

Constants

A constant (also called a constant variable) is a variable which is assigned a value once and cannot be changed afterward (during execution of the program). 
The compiler optimizes a constant for memory storage and performance.
The keyword final signals the declaration of a constant:

• final int TOUCHDOWNPOINTS = 7;
• final double DEUTSCHMARKSPEREURO = 3.16726

Examples of constants

• the number pi (3.1415927...)
• the number of French francs in a Euro
• boiling point as 100 degree centigrade
• freezing point as 0 centigrade

Conventions for variables, classes, and methods

varName;  // not capitalized initially, but each subsequent word in the name is capitalized

methodName(); // not capitalized initially, but each subsequent word in the name is capitalized

CONST_NAME // all capital letters with underscore to separate words in the name

ClassName // initial capital letter and capital letter for each word in the name

Scope of a variable

The concept of scope (Day 5, p. 114) is fundamental. 
Scope is the block of code in which a variable exists and is available for use.
The scope (or visibility) of a variable depends upon WHERE you declare it. 
You might declare a variable within a block of code that is a:

• class (static variable)
• instance
• local logic and looping structures

local variable

A data item known within a block, but inaccessible to code outside the block. For example, any variable defined within a method is a local variable and can't be used outside the method.

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/scope.html

Sun's tutorial exposes a common error involving the concept of scope:

if (...) {
    int i = 17;
    ...
}
System.out.println("The value of i = " + i);    // error

QUESTION: Can you use have an instance variable with exactly the same name as a local variable?

Variable Types

A variable is a name for a piece of memory that stores a value. Each variable must have a name. 

Unlike JavaScript and Visual Basic, Java is a strongly typed programming language, which means that you must declare the data type of a variable.

A variable can be any of the following types:

• primitive
• reference (any object)
  • string
  • array
  • user-defined type, such as Bank of America's CommercialCustomer

Background information (not part of Java per se)

Numbers are represented in memory using bits, a bit is the smallest unit that a computer can work with. 
A bit has two possible values, 0 or 1.
Everything in a computer is represented using different numbers of bits.
A number is represented by a series of bits which represent different powers of 2.

An 8 bit number (byte):

Variable Types - Primitives

A given variable is either a primitive (basic type) or an object. 
Each primitive data type has a range of values, which determines its size in memory

Sun's Java Tutorial contains a program that outputs the largest value of the primitive types.
http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

Copy by value versus copy by reference

Java stores each primitive type in a fixed amount of memory and Java directly manipulates the values for primitives. 
However, objects and arrays do not have a standard size, and they can become quite large. Therefore, Java manipulates these reference types by reference. Whereas the reference types do not have a standard size, the references to reference types do have a standard size.

Reference types differ from primitives in the way values are copied and compared.

• When you work with a primitive data type, such as an integer, you are working directly with values and no Java object is involved. So the statement x = y actually copies the value of y into x. 
• When you work with reference types (objects), the variable does not contain the object.
  The variable is a reference to that object in memory. 
  So the statement x = y does not copy the object, but only copies the reference. 
  There is still only one object, but it now has two references. 
  We will cover this in more detail next week.

Arrays

David will explain arrays. For now, just be aware that an array stores multiple variables of 

• the same type
• a specific number of indices ("slots")
• you access an element by using its index

Examples of possible arrays

• days of the week
• zipcodes of your top customers 
• table of sines and cosines in trigonometry

Operators 

In the geeky language of programming (and mathematics), we say that operators operate on operands.
In the case of sum =  cost1 + cost2  for example, the operators are the addition operator (+) and the assignment operator (=). The operands are that on which the operators operate, namely, the variables cost1, cost2, and sum.

If you write a Java statement such as:

int totalDaysInYear = 365;
The assignment operator (=) assigns the  integer value of 365 to the variable named totalDaysInYear.

Point location = new Point(4,3);
The assignment operator (=) assigns x- and y-coordinate values.
The new operator creates a new instance of a class and returns a reference to that instance.
(More on this next week.) 

arithmetic operators

The arithmetic operators return a number.

numeric return value = <operand1> <operator> <operand2>;
example: myLongString = myShortString + myOtherString;

• + addition
  • adds two numbers
  • concatenates two strings
• - subtraction
  • subtract one number from another
• * multiplication
  • multiply two numbers
• / division
  • divide two numbers
• % modulus
  • the remainder of an integer division
  • 5 % 3 = 2 Because 5/3 = 1 and leaves 2.
  • myRemainder = 5 % 3;
  • example: Suppose I have a machine that lets people input 1-cent coins and returns to them the corresponding amount of 5-cent coins. I could use modulus to determine if my machine has to give the user one-cent pieces because the user's input sum modulus five returns the number of 1-cent coins.

  Note: These are binary operators because they operate on two things. How many binary operators are there in the following application?

class Weather {
    public static void main(String[] arguments) {
        float fah = 86;
        System.out.println(fah);
        // To convert Fahrenheit into Celsius
        // Begin by subtracting 32
        fah = fah - 32;
        // Divide the answer by 9
        fah = fah / 9;
        // Multiply that answer by 5
        fah = fah * 5;
        System.out.println(fah);

        float cel = 33;
        System.out.println(cel);
        // To convert Celsius into Fahrenheit
        // Begin by multiplying it by 9
        cel = cel * 9;
        // Divide the answer by 5
        cel = cel / 5;
        // Add 32 to the answer
        cel = cel + 32;
        System.out.println(cel);
    }
}

arithmetic - unary minus operator

The unary minus operator ( - ) converts a positive value into a negative value.

How about this case? What will be the value of y?

Assignment operators

Here's some handy shortcuts:

x += y; // x = x + y

x -= y // x = x - y

x *= y; // x = x * y

x /= y; // x = x / y

Here's some more complete reference tables:

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/opsummary.html#assignment

 

Operator	Use	Description
?:	op1 ? op2 : op3	If op1 is true, returns op2. Otherwise, returns op3.
[]	type []	Declares an array of unknown length, which contains type elements.
[]	type[ op1 ]	Creates and array with op1 elements. Must be used with the new operator.
[]	op1[ op2 ]	Accesses the element at op2 index within the array op1. Indices begin at 0 and extend through the length of the array minus one.
.	op1.op2	Is a reference to the op2 member of op1.
()	op1(params)	Declares or calls the method named op1 with the specified parameters. The list of parameters can be an empty list. The list is comma-separated.
(type)	(type) op1	Casts (converts) op1 to type. An exception will be thrown if the type of op1 is incompatible with type.
new	new op1	Creates a new object or array. op1 is either a call to a constructor, or an array specification.
instanceof	op1 instanceof op2	Returns true if op1 is an instance of op2

Incrementing and Decrementing

These short cut unary operators increment or decrement a number by one. 

Operator	Use	Description
++	op++	Increments op by 1; evaluates to the value of op before it was incremented
++	++op	Increments op by 1; evaluates to the value of op after it was incremented
--	op--	Decrements op by 1; evaluates to the value of op before it was decremented
--	--op	Decrements op by 1; evaluates to the value of op after it was decremented

Note the difference between prefix versus post-fix.

Comparison operators

Logical operators test a condition by comparing values and return a boolean value (true or false).

• == equal (two adjacent equal signs)
  if (sum = = 100) { // do something ...
  WARNING: Testing for identical values with = = is different from assigning a value with =
• != not equal
  if (sum != 100) { // do something ...
• > greater than
  if (sum > 100) { // do something ...
• < less than
  if (sum < 100) { // do something ...
• >= greater than or equal to
  if (sum >= 100) { // do something ...
• <= less than or equal to
  if (sum <= 100) { // do something ...

Here's two comparison operators in a sequence:
isBigSum = sum > 100; 
The variable isBigSum gets the value true only if the sum is greater than 100. 

Logical operators

• & - ampersand is the logical and operator
  boolean isAllExpensive = (cost1 >= 100) & (cost2 >= 100);
  Both cost1 and cost2 must be >= 100 to return true and both cost1 and cost2 are evaluated
• && - double ampersand is the logical and operator that can "shortcircuit" when appropriate
  boolean isAllExpensive = (cost1 >= 100) && (cost2 >= 100);
  // Both cost1 and cost2 must be >= 100 to return true and if cost1 fails the test, cost2 is NOT evaluated
• | or
  boolean hasExpensive = (cost1 >= 100) | (cost2 >= 100);
  Either cost1 or cost2 must be >= 100 to return true and both cost1 and cost2 are evaluated
• || or - double "pipe" s the logical or operator that can "shortcircuit" when appropriate
  boolean isAllExpensive = (cost1 >= 100) || (cost2 >= 100);
  Either cost1 or cost2 must be >= 100 to return true and if cost1 passes the test, cost2 is NOT evaluated

Note: Do not confuse the two forward slashes of comments (//) with the two "pipes" of one of the logical operators (||).

Truth table

Operator Precedence

Multiplication occurs before addition

total = 2 + 3 * 4; // evaluates to (3 * 4) + 2, which is 14
total = (2 + 3) * 4; // evaluates to 5 * 4, which is 20

Fortunately, whatever you put in parenthesis has precedence over what is not in parenthesis.

Table 3.6 on p. 79 gives a complete list of operator precedence.

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/expressions.html
The Java programming language allows you to construct compound expressions and statements from various smaller expressions as long as the data types required by one part of the expression matches the data types of the other. Here's an example of a compound expression:

x * y * z

x + y / 100     //ambiguous

(x + y)/ 100    //unambiguous, recommended

x + y / 100
x + (y / 100) //unambiguous, recommended

The following table shows the precedence assigned to the operators. The operators in this table are listed in precedence order: the higher in the table an operator appears, the higher its precedence. Operators with higher precedence are evaluated before operators with a relatively lower precedence. Operators on the same line have equal precedence.

postfix operators	[] . (params) expr++ expr--
unary operators	++expr --expr +expr -expr ~ !
creation or cast	new (type)expr
multiplicative	* / %
additive	+ -
shift	<< >> >>>
relational	< > <= >= instanceof
equality	== !=
bitwise AND	&
bitwise exclusive OR	^
bitwise inclusive OR	|
logical AND	&&
logical OR	||
conditional	? :
assignment	= += -= *= /= %= &= ^= |= <<= >>= >>>=

When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated in left-to-right order. Assignment operators are evaluated right to left.

String Arithmetic

David will explain string arithmetic. Here, I just show what it looks like because it is part of the Day 3 chapter (p. 80).
System.out.println(fah + " degrees Fahrenheit is ...");
System.out.println(fah + " degrees Celsius\n");
System.out.println(cel + " degrees Celsius is ...");
System.out.println(cel + " degrees Fahrenheit");

Homework Assignments for 1 April:  

1. Day 3, p. 84, 1st bullet: Write a program that displays two numbers and uses the / and % operators to display the result and remainder after they are divided. Use the \t character escape code to separate the result and remainder in your output.
   
2. Day 5, p. 131, 2nd bullet: Create a class that takes words for the first 10 numbers (one up to ten) and converts them into a single long integer. Us a switch statement for the conversion and command-line arguments for the words.

_________________________
course homepage      course calendar