Java for programmers a short Tutorial

Overview:

There is an abundance of java tutorials and if you are new to the language you really should spend a few hours going through the basics.

<http://java.sun.com/docs/books/tutorial/>

This session is no substitute for that. What it is, is a series of working examples that seeks to show the java way of doing certain tasks typically associated with languages like C. Our examples look at working on the command line in a UNIX enviroment and we look at command line arguements and rudimentry file IO.

Example Java programs

• a "Hello, World." application program

• receiving parameters from the command line
• displaying all of the command line parameters

• literals
• constants
• constant assignment may be deferred
• variables
• expressions
• can you guess what the output is *before* you run this one?

• reference tyoes behave differently from simple types (esp. w/r/t assignment and comparisons)
• for those C programmers out there, note that Java reference types are just like C pointer types
• normally you will use the "equals()" method to test for equality between object references

• incoming data is often in string form, which may be okay sometimes
• but if you need to do arithmetic, you need numeric types, so you must convert -- here's how (String->int)
• conversion may fail if you attempt to convert a non-number so you must handle this possibility
• conversion from String to double
• a situation where conversion is required

• when you mix types in expressions, Java promotes types... watch out for this!
• try to figure out the output of this before you run it!

• a "real" program example (temperature conversion)
• the same program tweaked a little

• basic output tools (print/println)
• character input
• filters make input much more convenient
• filters can be stacked like this too
• standard keyboard input
• it is a bit nicer with some prompts for the user
• sometimes it is better to prompt with print than println
• input/output is often used in conjunction with a program loop like this

• simple input from a file
• using a loop to read from a file
• reading from one file and writing into another
• more efficient copying of a file
• searching a file for a string (note the line-numbering input filter used here)
• Pieces of Bigger Project:

• simple input from over the Web (so easy!)
• using a loop to read from a Web document
• copying a Web document into a local file

• simple decision structures
• more simple decision structures
• compound statements
• a little more complex
• nested decision structures
• nested without using compound statements
• else if

• a counted loop
• counting backwards
• counting by twos
• nested loops
• creating an array, filling it manually, displaying it with a loop
• the same, except using a loop to fill it
• using a loop to search through the array looking for a particular value
• initializing using an array literal

• an uncounted, top-tested loop can run zero or more times (forever possibly)
• same thing, but by rearranging the loop contents we can make the program smaller
• check the "set-up" code on this one
• check the "increment" code on this one
• that's better -- this loop can count!
• counting is a very common application for loops, so there are special loops for that -- "for" loops
• a bottom-tested do/while loop (useful in many applications, like the first example above)

• calling a method with no parameters
• calling a method and passing a primitive type parameter
• what if we change it inside the method?
• two parameters (order of passing determines what goes where, and type matters))
• the same method may be called many times with different parameters -- this is *VERY* useful!
• carrying this one level deeper (called method calls another method)
• reference/object types behave differently as parameters, what happens when they are changed inside the method?
• how do arrays behave as parameters? (arrays are object types, even if their elements are primitive types)
• showing object types can be modified remotely
• methods may be given types, then they must return something of that type, and they must be called in a different way too
• return types have nothing to do with parameter types as this illustrates (an int comes in, but a String goes out)
• methods with return types can be used like any other expressions of their type
• methods encapsulate operations and give them names (like print and sum here) making code easier to read

• object instantiation, constructor, instance methods
• reference/object parameters can be changed inside methods they are passed to
• our old friend the keyboard object, revisited

• a home-made class (i.e., not found in the API)
• a program that uses this class

• adding a static method
• ( calling program)

• overriding the "equals()" method
• (calling program)

• a class representing the real world thing called a coin jar
• a calling program that creates a couple of coin jars and uses them

• same as the example above
• the PiggyBank class extends the CoinJar class -- can you see the true power of OO programming?
• (calling program -- makes a Piggy bank and uses it)

• not every error causes an exception
• but this one does
• catching it
• catching it when a method throws it
• throwing your own exceptions (of existing types)
• catching one you threw
• catching from a method called inside another method
• finally clause and code following
• bailing out in a handler
• using a custom-bult Exception class
• the custom-bult Exception class used in the example above

References:

• http://java.sun.com/j2se/1.4.2/docs/api/java/io/Writer.html
• http://java.sun.com/j2se/1.4.2/docs/api/java/io/Reader.html
• http://java.sun.com/docs/books/tutorial/
• http://java.sun.com/docs/books/tutorial/essential/io/index.html

http://java.sun.com/docs/books/tutorial/jdbc/basics/index.html