Lecture 2: Variables, Operators, Expressions, Statements, I/O

What You Will Learn Today

1. basic C-like building blocks of the Java language, including:
   1. variables and data types
   2. naming and coding conventions
   3. operators and expressions
   4. statements and comments
2. input and output
   1. using the System command
   2. using a dialog box
   3. using the console

Constants and Variables

• Constants and variables are both areas in memory where data is stored.
• The value of a variable can change, the value of a constant cannot.
• Constants in Java are called final variables.
• Constants and variables are generally assigned with a statement format like x = a;

Data Types

• byte short int and long are integer types with size 1, 2, 4 and 8 bytes, respectively.
  • a byte can store 8 bits of information, or 2⁸=256 different values; an int can store 2³² values
  • To see the size of any variable, use the sizeof() operator, e.g. sizeof(int) or sizeof(a).
  • Integer types are initialized to 0.
• float is a floating point number which has a decimal point.
• double has more decimal digits than float and is used for accuracy.
• boolean variables can have only two values: true or false; unlike in C they are not equivalent to 1 and 0.
• All data types can be represented as and converted to objects.

Characters

• char is a character (letter, number, punctuation, symbol, or control character, e.g. 'a', '3', '!', '%', '\n').
  • control characters include space ' ', tab '\t', newline '\n' and return '\r'.
• The ASCII character set represents characters by numbers 0 to 127 decimal (7 bits)
  • characters are actually stored as integers and can be used in arithmetic,
    e.g. '0' is 48, '9' is 57, 'A' is 65, 'Z' is 90, 'a' is 97, 'z' is 122, 'Z' - 'A' gives 25
  • The extended ASCII character set uses 0 to 255 or 00 to FF hexadecimal (one byte)
  • EBCDIC is a similar but different character set used on IBM mainframe computers
• The unicode character set uses two bytes and can represent many international characters
  • ASCII codes can be converted to Unicode by adding 00 to the beginning, e.g. A3 becomes \u00A3

Declaration and Assignment

• a declaration allocates memory for a variable, e.g. int a;
• an assignment gives a value to a variable, e.g. a = 3;
  • it is possible to combine the two to save space and initialize a variable, e.g. int a = 3;
• final variables (constants) must be assigned when declared, e.g. final float PI = 3.14;
• always use final variables instead of putting "magic numbers" (numeric constants except -1, 0, 1, 2) into code

Keywords and Identifiers

• A keyword is a lowercase word that is part of the core Java language, e.g. (see Big Java Appendix A4 for definitions):
  • abstract boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient try void volatile while
• An identifier is the name of a variable, method or object.
  • Either it already exists in a library or you are creating and naming it anew.
  • Do not use a keyword as an identifier, or you will probably get a confusing error message when you try to compile.
  • Do not use an existing identifier as a new identifier, or the compiler will tell you it already exists and you can't redefine it.

Recommended Naming Conventions

• constants should be in all capital letters, with underscore to separate words, e.g. PI, TAX_RATE
• variables and methods should be small letters, using capitals to separate words, e.g. sales, payRate
• class names should start with an uppercase letter, e.g. class Tree
• some characters are not allowed; none of the above may contain spaces or begin with a number
• most constants and variables should have meaningful names, but i, j, k, m and n can be used for integers, e.g. in iteration

Recommended Coding Style

• indentation should be three spaces (I personally prefer two; whether you choose two or three, be consistent!)
• braces {} should line up horizontally or vertically (so it is easy to find the matching brace)
• a method should use at most 30 lines of code (if it is too long, break it into two methods)
• for more information on coding guidelines, see Big Java Appendix A1

Arithmetic, Logical and Comparison Operators

• arithmetic operators include + - * / (addition, subtraction, multiplication, division)
  • % is the modulus operator (integer remainder after division)
• logical operators return true or false
  • logical operators include &&, ||, ! (and, or and not)
• comparison operators compare two arguments and return true or false
  • comparison operators include == != < > <= >=
    (equal, not equal, less than, greater than, less than or equal, greater than or equal)

Unary, Binary and Ternary Operators

• unary operators take one argument, e.g. integer or logical negation of x to produce -x or !x
• binary operators take two arguments, e.g. x+y and most other operators
• ternary operators take three arguments
  • Java has only one ternary operator, the selection operator with the format test ? valueIfTrue : valueIfFalse
  • if test is true then return valueIfTrue else return valueIfFalse
  • the following two lines are equivalent ways to use a mark to determine whether a grade is pass or fail:
    • if (mark >=50) grade = "pass"; else grade = "fail";
    • grade = mark >= 50 ? "pass" : "fail";

Incrementing and Decrementing

• the increment operator ++ increases a variable by one, the decrement operator -- decreases a variable by one
• prefix operator comes before the variable and is incremented first, e.g. ++x, postfix after, e.g. x++
• x = 3; a = x++; // a is set to 3, then x is incremented to 4
• x = 3; a = ++x; // x is incremented to 4, then a is set to 4

Assignment Operators

• the assignment operator = assigns a value to a variable, e.g. x = a; assigns x the value of a
• x += 3; is a short way of writing x = x + 3; similar assignment operators include += -= *= /=

Type Conversion using Casts

• casting is converting one variable or object type to another using the format (TypeName) variable
• e.g. (int) 3.14 converts the floating point number 3.14 to an integer 3

Statements

• simple statements end with a semicolon, e.g. int x;
• block statements are grouped within brackets
  • e.g. while (x<10) { System.out.println(x); x++; }
// while x is less than 10, print and increment x
• compound statements are conditional or looping statements (if, switch, while, for, etc.) which also include a simple or block statement.
• null statements (just a semicolon) are used to do nothing,
  • e.g. for (;;) System.out.println("hello"); // print hello forever (press Ctrl-C to exit program)
• notice that you can have more than one statement on one line, or a single statement on more than one line

Comments

• comments are used to document a program so other programmers can more easily understand the code
• /* C-style comment
can be on more than one line */
• // C++-style comment is on one line
• /** Javadoc comment (C-style comment which begins with two stars) */
• good documentation is brief but clearly explains what each section of code does
• every program should have a comment at the top with file name, purpose, author and modification date
• programs you submit in this class should also have course name and homework assignment number

Command-Line Text Output

• Output to the screen is done through the System object
• System.out.println("text"); // print text and the newline character
• System.out.print("text"); // print text; the following text will be on the same line
• Input is more difficult and will be explained later. For now, you can use the following code:

Dialog Box Input

/**
get a string from the user using a dialog box
DialogString.java
@author Greg Vogl
2003-09-21
input: a string using a dialog box
output: the string
*/
import javax.swing.JOptionPane; // Swing is a Java SDK graphics library that contains the dialog box
public class DialogString
{
  public static void main (String[] args)
  {
    String input = JOptionPane.showInputDialog("Enter a string");
    System.out.println("You entered: " + input);
    System.exit(0); // needed to exit a program with a GUI thread
  }
}

Console Input

/**
get a string from the user using the command line
ConsoleString.java
@author Greg Vogl
2003-09-21
input: a string using the command line
output: the string
@throws IOException to handle bad strings
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class ConsoleString
{
  // main() must be able to throw an I/O exception to handle bad strings
  public static void main (String[] args) throws IOException 
  {
    System.out.println("Enter a string:");
    BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
    String input = console.readLine(); // get a string from the user
    System.out.println("You entered: " + input); // display the string to the screen
  }
}

To Do After Class

• Copy the above programs and paste into an editor, save, compile and run.
• Look at some of the examples and ideas.
• Assignment 1 is due next week.