1. Slides adapted from Dr. Ramirez
Java Basics
PJ Dillon
CS401
Slides adapted from Dr. Ramirez

2. Identifiers
Keywords
Lexical elements (or identifiers) that have a special, predefined meaning in the language
Cannot be redefined or used in any other way in a program
Ex: public, private, if, class, throws
See p. 32 in LL for complete list

3. Identifiers Other Identifiers Defined by programmer
Java API defines quite a few for us
e.g. System, Scanner, String, out
are used to represent names of variables, methods and classes
Cannot be keywords
We could redefine those defined in Java API if we wanted to, but this is generally not a good idea
Java IDs must begin with a letter, followed by any number of letters, digits, _ (underscore) or $ characters
Similar to identifier rules in most programming langs

4. Identifiers Important Note: Naming Convention:
Java identifiers are case-sensitive – this means that upper and lower case letters are considered to be different – be careful to be consistent!
Ex: ThisVariable and thisvariable are NOT the same
Naming Convention:
Many Java programmers use the following conventions:
Classes: start with upper case, then start each word with an upper case letter
Ex: StringBuffer, BufferedInputStream, ArrayIndexOutOfBoundsException
Methods and variables: start with lower case, then start each word with an upper case letter
Ex: compareTo, lastIndexOf, mousePressed

5. Literals Values that are hard-coded into a program
They are literally in the code!
Different types have different rules for specifying literal values
They are fairly intuitive and similar across most programming languages
Integer
An optional +/- followed by a sequence of digits
Ex: 1024, -78,
Character
A single character in single quotes
Ex: ‘a’, ‘y’, ‘q’
String
A sequence of characters contained within double quotes
Ex: “This is a string literal”
See p for more literals

6. Statements Units of declaration or execution
A program execution can be broken down into execution of the program’s individual statements
Every Java statement must be terminated by a semicolon (;)
Variable declaration statement
<type> <variable>, <variable>, …;
Ex: int var1, var2;
Assignment statement
<variable> = <expression>;
Ex. var1 = 100;
var2 = var1;
Method call
<method ID>(<expression>,<expression>,...);
System.out.println(“Answer is “ + var1);
We’ll discuss others later

7. incompatible types found: java.lang.String
Variables
Memory locations that are associated with identifiers
Values can change throughout the execution of a program
In Java, must be specified as a certain type or class
The type of a variable specifies its properties: the data it can store and the operations that can be performed on it
Ex: int type: discuss
Java is fairly strict about enforcing data type values
You will get a compilation error if you assign an incorrect type to a variable: Ex: int i = “hello”;
Ex: int type: can store values to
Has operations +, –, *, /, %
Study of various data types is a large part of the CS 0445 Data Structures course (blatant plug for CS 0445)
incompatible types found: java.lang.String
required: int
int i = "hello"; ^

8. possible loss of precision found : double
Variables
Note: For numeric types, you even get an error if the value assigned will “lose precision” if placed into the variable
Generally speaking this means we can place “smaller” values into “larger” variables but we cannot place “larger” values into “smaller” variables
Ex: byte < short < int < long < float < double
Ex: int i = 3.5;
possible loss of precision found : double
required: int
int i = 3.5; ^
Ex: double x = 100;
This is ok

9. statements in the box to
Variables
Floating point literals in Java are by default double
If you assign one to a float variable, you will get a “loss of precision error” as shown in the previous slide
If you want to assign a “more precise” value to a “less precise” variable, you must explicitly cast the value to that variable type
int i = 5;
int j = 4.5;
float x = 3.5;
float y = (float) 3.5;
double z = 100;
i = z;
y = z;
z = i;
j = (long) y;
j = (byte) y;
Error check each of the
statements in the box to
the right

10. Variables In Java, variables fall into two categories: Primitive Types
Simple types whose values are stored directly in the memory location associated with a variable
Ex: int var1 = 100;
There are 8 primitive types in Java:
byte, short, int, long, float, double, char, boolean
See Section 2.3 and ex2a.java for more details on the primitive numeric types
var1
100

11. Variables Reference Types (or class types)
Types whose values are references to objects that are stored elsewhere in memory
Ex: String s = new String(“Hello There”);
There are many implications to using reference types, and we must use them with care
Different objects have different capabilities, based on their classes
We will discuss reference types in more detail in Chapter 3 when we start looking at Objects s
Hello There

12. cannot resolve symbol symbol : variable x location : class classname
Variables
In Java, all variables must be declared before they can be used Ex: x = 5.0;
This will cause an error unless x has previously been declared as a double variable
Java variables can be initialized in the same statement in which they are declared
Ex: double x = 5.0;
Multiple variables of the same type can be declared and initialized in a single statement, as long as they are separated by commas
Ex: int i = 10, j = 20, k = 45;
cannot resolve symbol symbol : variable x location : class classname
x = 5.0; ^

13. Operators and Expressions
Expressions are parts of statements that
Describe a set of operations to be performed
Are evaluated at run time
Ultimately result in a single value, the result of the computation
Result replaced the expression in the statement
Ex: Consider the assignment statement : x= ;
is evaluated to be 10 when the program is run
X ultimately gets assigned the value 10
Operators describe the operations that should be done
Simple numeric operations
Other more advanced operations (to be discussed later)

14. Operators and Expressions
Numeric operators in Java include
+, –, *, /, %
These are typical across most languages
A couple points, however:
If both operands are integer, / will give integer division, always producing an integer result – discuss implications
The % operator was designed for integer operands and gives the remainder of integer division
However, % can be used with floating point as well
int i, j, k, m;
i = 16; j = 7;
k = i / j; // answer?
m = i % j; // answer?

15. Operators and Expressions
Precedence and Associativity
See chart on p. 81 and on p. 678
Recall that the precedence indicates the order in which operators are applied
Recall that the associativity indicates the order in which operands are accessed given operators of the same precedence
General guidelines to remember for arithmetic operators:
*, /, % same precedence, left to right associativity
+, – same (lower) precedence, also L to R
Ok, let’s do another example
ex2a.java

16. Operators and Expressions
Java has a number of convenience operators
Allow us to do operations with less typing
Ex:
X = X + 1; X++;
Y = Y – 5; Y –= 5;
See Sections 2.11 and 2.12 for more details
One point that should be emphasized is the difference between the prefix and postfix versions of the unary operators
What is the difference between the statements:
X++; ++X;

17. References What do we mean by “references”?
The data stored in a variable is just the “address” of the location where the object is stored
Thus it is separate from the object itself
Ex: If I have a Contacts file on my PC, it will have the address of my friend, Joe Schmoe (stored as Schmoe, J.)
I can use that address to send something to Joe or to go visit him if I would like
However, if I change that address in my Contacts file, it does NOT in any way affect Joe, but now I no longer know where Joe is located
However, I can indirectly change the data in the object through the reference
Knowing his address, I can go to Joe’s house and steal his plasma TV

18. Using Objects What do we mean by "objects"?
Let's first discuss classes
Classes are blueprints for our data
The class structure provides a good way to encapsulate the data and operations of a new type together
Instance data and instance methods
The data gives us the structure of the objects and the operations show us how to use them
Ex: A String

19. Using Objects
User of the class knows the general nature of the data, and the public methods, but NOT the implementation details
But does not need to know them in order to use the class
Ex: BigInteger
We call this data abstraction
Java classes determine the structure and behavior of Java objects
To put it another way, Java objects are instances of Java classes

20. More References
Back to references, let's now see some of the implications of reference variables
Declaring a variable does NOT create an object
We must create objects separately from declaring variables
StringBuffer S1, S2;
Right now we have no actual StringBuffer objects – just two variables that could access them
To get objects we must use the new operator or call a method that will create an object for us
S1 = new StringBuffer("Hello");
S1 now references an instance of a StringBuffer object but S2 does not

21. More References
So what value does S2 have?
For now we will say that we should not count on it to have any value – we must initialize it before we use it
If we try to access it without initializing it, we will get an error
Multiple variables can access and alter the same object
S2 = S1;
Now any change to S1 or S2 will update the same object S1
Hello S2

22. More References
Properties of objects (public methods and public instance variables) are accessed via "dot" notation
S1.append(" there Java maestros!");
S2 will also access the appended object
Comparison of reference variables compares the references, NOT the objects
StringBuffer S3 =
new StringBuffer("Hello there Java maestros!");
if (S1 == S2) System.out.println("Equal"); // yes
if (S1 == S3) System.out.println("Equal"); // no
What if we want to compare the objects?

23. More References We use the equals() method
This is generally defined for many Java classes to compare data within objects
We will see how to define it for our own classes soon
However, the equals() method is not (re)defined for the StringBuffer class, so we need to convert our StringBuffer objects into Strings in order to compare them:
if (S1.toString().equals(S3.toString()))
System.out.println("Same value"); // yes
It seems complicated but it will make more sense when we get into defining new classes

24. More references
Note the difference in the tests:
The == operator shows us that it is the same object
The equals method show us that the values are in some way the same (depending on how it is defined)
References can be set to null to initialize or reinitialize a variable
Null references cannot be accessed via the "dot" notation
If it is attempted a run-time error results
S1 = null;
S1.append("This will not work!");

25. More references Let's take a look at ex3.java Why?
The method calls are associated with the OBJECT that is being accessed, NOT with the variable
If there is no object, there are no methods available to call
Result is NullPointerException – common error so remember it!
Let's take a look at ex3.java

26. Program Input
We’ve already discussed basic output with the terminal window
System.out.println(“Area is “ + area);
Standard Output Stream
For now, we’ll get input from two sources
Standard Input Stream
Scanner class
Command Line Arguments

27. Streams
A Stream is a continuous, seemingly infinite supply of or sink for data
An ordered sequence of bytes flows in a specified direction
in from some source
can be sent out to some destination
Acts as a pipe connected to your program
A channel providing communication to and from the outside world
For now, we’ll concern ourselves with the two (three) given to us
Standard Input: System.in
Standard Output: System.out

28. Scanner
Scanner is a class that reads data from the standard input stream and parses it into tokens based on a delimiter
A delimiter is a character or set of characters that distinguish one token from another
By default the Scanner class uses white space as the delimiter
The tokens can be read in either as Strings
next()
nextLine()
Or they can be read as primitive types
Ex: nextInt(), nextFloat(), nextDouble()

29. Scanner
If read as primitive types, an error will occur if the actual token does not match what you are trying to read
Ex:
Please enter an int: hello
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at ex3.main(ex3.java:39)
These types of errors in Java are called exceptions
Java has many different exceptions
We'll look at exceptions in more detail later
Let’s try an example:
ex4a.java
ex4b.java

30. Command Line Args Remember the main() method
public static void main(String[] args)
args is an array of Strings corresponding to the list of arguments typed by the user when the interpreter was executed
javalab$ java myProg.class Steve
Passed in by the operating system
User must know the order and format of each argument
NOTE: Unlike C/C++, only the actual arguments are passed to the program
We’ll discuss arrays in more detail soon
For now, let’s do an example: ex4c.java