Java Basics by Brandon Black

1. Java Basics
Brandon Black
CS401
Slides adapted from Silver Webbuzz

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:
• 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, 1024786074
– 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. 75-77 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 = 100 + var1;
• Method call
<method ID>(<expression>,<expression>,...);
System.out.println(“Answer is “ + var1);
• We’ll discuss others later

7. 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”;
incompatible types found: java.lang.String
required: int
int i = "hello";
^

8. 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. 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. 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=1+2+3+4;
• 1+2+3+4 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
S2
Hello

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
• 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 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 10 13 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