Today’s lecture
 Review of Chapter 1
 Go over homework exercises for chapter 1
Simple Java Program
file: HelloWorld.java
public class HelloWorld {
public static void main (String[] args) {
//our code will all go here…
System.out.println("Hello, World!");
}
}
Each word of this should make sense by the semester's end! For now it
is boilerplate code—just the template we'll use to write code.
Whitespace
 Whitespace means the 'blank' characters:
space, tab, newline characters.
 White Space is (almost) irrelevant in Java.
 Java does not care about indentation
 However, indentation is highly recommended!
 Java uses curly braces, { and } to replace
indentation
 Follow the indentation pattern you had for Python, for
readability
 The computer will only care about { }, however
Good Whitespace Example
public class GoodSpacing {
public static void main (String[] args) {
int x = 5;
int y = 12;
System.out.println("x+y = "+ (x+y));
}
}
indentation levels for each block: class,
method definitions, control structures…
Types!
 Java is strongly typed: every
expression has a specific type that is known
at compile time.
 Java has two kinds of types:
 primitive types (containing literal values)
 reference types (containing objects of some
class). These are complex types.
 Variable types must be declared before use
Type declaration
public class GoodSpacing {
public static void main (String[] args) {
int x = 5;
int y = 12;
System.out.println("x+y = "+ (x+y));
}
}
x is declared to be of type integer
args is declared to be a list of strings
main is declared to return void (nothing)
the println method returns void
Primitive Types
boolean: truth values: true, false
char: a character in single-quotes: 'a' 'H' '\n' '5’
integers: byte, short, int, long
floating point: float, double
void is technically not a type, but is used to represent
when a method doesn’t return a value
Specific Integer Types
Java provides integral numbers of different 'widths' (different numbers
of bits), and different ranges of values:
byte
short
int
long
(8 bits)
(16 bits)
(32 bits)
(64 bits)
-128
to
127
-32768 to
32767
-2147483648 to 2147483647
(-263) to
(263-1)
char
(16 bits)
0 to 65535 (all positive)
(a character is actually stored in memory as an integer)
You don’t have to memorize any of these ranges, just be aware they exist
Floating Point Numbers
Approximating the real #s: called floating point numbers.
internal binary representation: like scientific notation.
sign
exponent
S: sign bit.
fraction
E: bias-adjusted exponent.
M: adjusted fractional value.
value = (-1)S * 2E * M
Also representable: infinity (+/−), NaN ("not a number")
float: 32-bit representation.
double: 64-bit representation.
(1 sign, 8 exp, 23 frac)
(1 sign, 11 exp, 52 frac)
Reference Types
strings: String
language-defined: System, Math
user-defined: Person, Address, Animal
arrays: int[], String[], Person[], double[][]
int[] myArray = {1, 5, 7};
int[] otherArray = new int[];
Person jill = new Person();
new is a keyword that we can use to create all reference types
arrays and strings are special in Java; other ways to create without new
Creating Variables
 Variables must be declared and initialized before use.
 Declaration: creates the variable. It includes a type and a name.
The variable can only hold values of that type.
int x;
char c; double[][] grid;
Person p;
 Initialization: assign an expr. of the variable's type to it.
x=7+8;
c='M';
grid={{0,1},{2,3}};
p= new Person();
 Both: we can declare and instantiate all at once:
int x = 5;
char c = 'S';
Person p = new Person();
Casting
 a cast is a conversion from one type to another. We
cast things by placing the type in parentheses in front
of it:
(int) 3.14
 One use: forcing floating-point division.
int x=3, y=4;
double z = ((double)x)/y;
System.out.println(z);
Strings
 Can be declared as
String cat = “Fluffy”;
String cat = new String(“Fluffy”);
 Can be added with + operator (concatenation)
“Hello” + “ “ + “world”
 Can mix types
String cat = “Hi” + 3 + ‘ ‘ + false;
int number = 5 + 3;
Java Comments
There are two main styles of comments in Java:
 Single-Line: from // to the end of the line.
 Multi-Line: all content between /* and */, whether it spans
multiple lines or part of one line.
JavaDoc: convention of commenting style that helps
generate code documentation/API. More on this later.
Expressions, Statements
Expression: a representation of a calculation that can be
evaluated to result in a single value. There is no
indication what to do with the value.
Statement: a command, or instruction, for the computer
to perform some action. Statements often contain
expressions.
Basic Expressions
 literals (all our primitive types)
 operation expressions:
<
+
&
<=
|
>
*
&&
>= == != (relational ops)
/
%
(math ops)
||
!(boolean ops)
 parenthesized expressions ( expr )
 variables (can store primitive types or reference types)
 method calls that return a value (are not void)
Programming TRAP
 Only use == and != for primitive types
 We will learn how to compare reference types later
Expression Examples
Legal:
x++
x%2==1
numPeople
(2+3)*4
(3>x) && (! true)
(x<y)&&(y<z)
drawCard()
y!=z
Illegal:
x>y>z 4 && false
7(x+y)
x=3
Basic Statements
 Declaration: announce that a variable exists.
 Assignment: store an expression's result into a
variable.
 method invocations (may be stand-alone)
 blocks: multiple statements in { }'s
 control-flow: if-else, for, while, …
(next lecture)
Statement Examples
int x;
//
x = 15;
//
int y = 7;
//
x = y+((3*x)−5);
//
operators
x++;
//
System.out.println(x);//
if (true):{
int x = 50;
int y = 3;
x = x + y;
}
declare x
assignment to x
decl./assign. of y
assign. with
increment (x = x+1)
method invocation
//if statement
Print Statement
 println is a method of the PrintStream class, that
can print anything on a single line:
System.out.println(“Hello World!);
 System.out is the standard buffer for printing to the
screen
User Input
 Create a Scanner object and get the next value:
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
String string = scan.nextLine();
 System.in is the standard buffer for keyboard input
Questions?