Java Programming

Who is this class for?

 There is no assumption that you know any
Java or other OO programming language. If
you do, you may find the first few weeks
boring.

 You must have programming experience.

We will not spend very much time on
syntax, procedural constructs, operators,
etc. It is assumed that you can pick this up.
History of Java
 First version released in 1995

 Eight major versions released since then

– JDK 1.0 (1996) JDBC, Distributed Objects
– JDK 1.1 (1997) New Event Model
– J2SE 1.2 (1998) Swing
– J2SE 1.3 (2000) Cleanup
– J2SE 1.4 (2002)
– J2SE 5.0 (2004) Generics
– J2SE 6.0 (2006)
– J2SE 7.0 (2011)
Five Design Principles of Java
 simple, object-oriented and familiar
 robust and secure
 architecture-neutral and portable
 execute with "high performance
 interpreted, threaded, and dynamic
What is/isn’t Java?
 Read chapter 1 of Core Java
– Discussion is very balanced
 Basically, compared to C Java is a relatively high-level
language with many built-in features for portably
doing useful things such as:
– Multithreading
– Writing distributed programs
– Writing GUI clients
– Error handling
– Extending Web servers
– Embedding programs in Web browsers
– Connecting to commercial databases
Programming with Java
Java vs. C
 Equally importantly, Java has many core
language features that make it much more
natural to express abstraction, develop
software frameworks, etc.

 Also, many core language features which

ease debugging and promote reuse.
Compiling/running first java
program
 Create source code file (call it for example
MyFirstProgram.java).
 To compile:
prompt >> javac MyFirstProgram.java
 This produces byte code file named
MyFirstProgram.class
 To run:
prompt >> java MyFirstProgram
Observations
 .class file is not machine code. It is intermediate
form called Java Byte code. Can run on any
platform as long as platform has a Java Virtual
Machine (JVM).
 The second step on previous slide invokes the
JVM to interpret the byte code on the given
platform.
 In theory, byte code can be moved to another
platform and be run there without recompiling –
this is the magic of applets.
 Leave off the .class part when invoking the JVM.
Observations
 This is an old-fashioned command-line
program. Java also supports GUI
applications and web-browser hosted
programs called applets.
 After the first couple of weeks we will use
graphical rather than scripting front-ends.
Writing first program
 To keep things simple our first few
programs will all be written as just a single
main program.
 In java, the file in which your program
resides must contain a .java extension (e.g.
MyFirstProgram.java).
Writing first program
 Then, the program must be wrapped in a
class definition which is the same as the file
basename (MyFirstProgram). Careful, Java
is case-sensitive.
class MyFirstProgram { … }
 Finally, main is defined similar to C, but
with a few more modifiers:
public static void main(String[] args){ … }
These are all required. No shortcuts.
Writing first program
 Just as in C, main(..) is the principle entry point
into the program. When you say
java Program
Java looks in Program for a procedure named
main. This is where the program starts.
 To print to stdout in java use:
System.out.println(“ …”);
 MyFirstProgram.
Basic Programming
Constructs

What you should learn on your own

Breakdown of a java program
 Strategy to start is write evertything in a
single main program and very quickly
review the basics of java syntax (very little
time here).
 Then we break into procedures.
 Then class/packages.
Single-threaded program
 For a single thread of execution, each line
of code is executed sequentially (as in C).
 Each statement is terminated with a
semicolon.
 Unlike C, declarations can occur anywhere
within a program.
 Basic operators, control statements almost
exactly like C. A few minor differences.
 Best to just look at some examples.
Java Data Types
 Sizes fully specified by Java standard.
 Java is a very strongly typed language
 Integer types
– int (4 bytes signed)
– short (2 bytes signed)
– long (8 bytes signed) use suffix L (eg 1000000000L)
– byte (1 byte signed)
 Floating-point types
– float (4 bytes) use suffix F (eg 1.28F)
– double( 8 bytes)
Additional Data Types
 char
– Two-byte unicode
– Assignment with ‘ ‘
• e.g. char c = ‘h’;
 boolean
– true or false
e.g. boolean x = true;
if (x){…};
Operators/Control Flow
 Almost exactly like regular ANSI C.
 +, *, -, /, %, ++, --, +=, etc.
 ==, !=, >, < , etc.
 if statements, for loops, while loops, do loops,
switch statements, etc.
 continue, break, return, System.exit(0).
 Read pp 54– in Core Java.
 No need to spend class time going over these.
Scoping
 Braces are used as in C to denote begin/end of
blocks
 Be careful of the following:
int j = 0;
if ( j <1 ){
int k = 2;
…
}
k = 3; //Error! k inaccessible here
 Declarations do not propogate upwards.
Adding datatypes -- classes
 Java has handful of built-in datatypes just
discussed (int, float, etc.)
 Just like in C, user typically creates own
homemade datatypes to work with particular
application (ie structs and enums).
 In Java these are called classes.
 Many class definitions come as a standard part of
the Java distribution. Most common Example is
String class.
Strings
 Java provides a class definition for a type called
String
 Since the String class is part of the java.lang
package, no special imports are required to use it
(like a header file in C).
 Just like regular datatypes (and like C), variables of
type String are declared as:
String s1;
String s2, s3; //etc.
 Note that String is uppercase. This is the Java
convention for classnames.
Strings
 Initializing a String is painless
s1 = “This is some java String”;
 Note that double quotes are required.
 Memory is allocated dynamically.
 Think of above method as shortcut for more
standard way (assuming s1 has been declared):
s1 = new String(“This is some java String”);
 new operator required to create memory for new
String object.
String methods
 Given a String object we can then access any
public String method or instance variable (field).
 Best to think of analogy with C. Given a variable
of some struct type, we can access any of the
struct’s members. If one of these members is a
pointer to a function, we can essentially call a
function using the struct. (x.doit(x,…))
 In Java, this idea is taken quite a bit further, but
the above analogy is a good start.
String Examples
 Best to see by way of example:
String s = new String(“Hello”);
Char c = s.charAt(3);
System.out.println(c);
 Method charAt called on String object s
taking single integer parameter.
 How might this look in a procedural
language with structures? (homework)
String class documentation
 Incredibly important!
– Each standard java class definition is fully documented
online
– You must become facile at reading/interpreting these
documents. This is how everything is done in Java.
– A little hard at first but then very simple. Makes
learning new functionality much easier (if it’s well
written).
– Make a link to
http://java.sun.com/j2se/1.3/docs/api/index.html
 Much of homework will come from interpreting
this page.
1d Arrays
 Arrays in Java are dynamic; they are
allocated with the new operator.
 Creating a (1d) array is a two-step process:
int[] x; //declare x to be an array of ints
//x has the value of null right now
x = new int[100]; //allocate 100 ints worth
 At this point the values of x are all zeroes.
 Assignment is then just like C.
1d Arrays
 Note that in Java, unlike C, the compiler will not
let you overrun the bounds of an array. Give it a
try.
 Note that you must use the new operator to size
the array. It cannot be done statically as in C.
Until this is done, the array reference has a value
of null.
 The array comes with a field called length which
stores the number of elements in the array. Try
printing x.length in the previous example. This is
a simple but nice convenience.
Misc tricks to get work done
Parsings Strings
 Recall that the args array is an array of Strings.
Thus, to accept key input as integers, float, etc. we
must convert.
 To convert to int, use the Integer.parseInt(String)
function.
Ex. String s1 = “32”;
int j = Integer.parseInt(s1); // j now holds 32
 Converting to double is analogous:
Ex. String s1 = “32”;
double j = Double.parseDouble(s1); // j now holds 32
Parsing Strings
 Note that the conversion methods are just regular
procedural functions. That is, no object was
created in order to call the method. The entity
before the ‘.’ is _not_ an object. More on this
later.
 What if the String is unparseable? (e.g. “andrew”
rather than “32”).
 Study the Integer and Double classes and look for
a description of the errors that are thrown by the
various methods. Does anything stand out? See
example Looper.java. More on this later.
Reading Keyboard input at
runtime
 How do we prompt for keyboard input at
runtime?
 Use java.io.Scanner class with standard
input stream.
 Scanner in = new Scanner(System.in);
while (in.hasNext()){
String arg = in.next();
}