Java intro

1. Java intro Part 2

2. Access control in Java classes • Public members: accessible to any code that can access the class • Private members: accessible only within the class (no friend functions!) • Protected members: accessible by code in: • Same package • Subclass as inherited member • Used more often than private because it allows extensibility

3. Object creation • A variable of a class type is simply a reference to an object • A declaration is just a declaration, NOT a call to the object’s constructor • To call the constructor, invoke operator new • Allocates dynamic memory for objects • All objects are dynamic objects

4. Constructors in Java • Method with same name as class • Performs initializations of object members • Has no return type • May be overloaded • Can have multiple constructors • But no such thing as default arguments

5. Assignment in Java • For primitive data types, works in familiar manner: • variable represents memory location sized to hold specific data type • value is stored in memory location via assignment operator • example: int x; // allocates 4 bytes of memory x = 5; // stores value 0000 0000 0000 0101

6. Assignment in Java • For objects, variables represent locations that can hold references; Java’s oh-so-gentle way of saying “pointers” • An object reference is created when a constructor is called using the new operator • A variable of the object type stores the reference

7. Objects & assignment • Because variables hold references to objects, and not actual objects, two variables can refer to the same object, as in the example below: Greeter worldGreeter = new Greeter (“world”); Greeter anotherGreeter = worldGreeter;

8. Example continued // worldGreeter and anotherGreeter both store references to // the same object anotherGreeter.setName(“Cate”); // changes the String variable as referenced by both worldGreeter // and anotherGreeter; thus: String s = worldGreeter.sayHello(); System.out.println(s); // prints Hello Cate! instead of Hello world!

9. Copying an object • If it is not your intention to have two variables referencing the same object (it rarely is), can create a copy of an object to store in a second variable using the clone() method • Method is available for all library classes; we will see later how to define it for our own classes

10. clone() method • Returns generic data type Object • Use explicit casting to create reference to desired type • Example: Date aDate = new Date(); // stores reference to current date & time Date anotherDate = (Date)aDate.clone(); // creates new Object, casts as Date & assigns

11. Null references • Because all object variables contain object references, can assign value null to any object variable • This is useful because null is a value that can be tested; should assign null to any variable that doesn’t immediately have an object reference assigned to it

12. Pointers & Java • You may have heard that Java doesn’t use pointers; this is only true in the sense that Java doesn’t use pointers you have to deal with directly • all object variables contain references - they are, in fact, pointers • you can’t create invalid pointers • Java uses automatic garbage collection - you don’t have to worry about reclaiming memory

13. Parameter passing in Java • We can describe two types of parameters in a Java method: • implicit parameter: calling object • explicit parameter: argument passed to method; explicitly defined in method’s parameter list • When necessary, can refer to the implicit parameter using the keyword this

14. Parameter passing in Java • Primitive type arguments (int, double, char, etc.) are passed by value • Objects are passed by reference (since all object variables hold references), but methods can’t change parameter values - basically, it’s pass by const reference • Method can change the state of the calling object (implicit parameter) but not the received object (explicit parameter)

15. Basic Error Handling • Error messages can be sent to System.err (analogous to cerr) instead of System.out example: System.err.println (“Invalid input”); • Still prints to screen, in most cases - can be useful in situations where errors go somewhere else, like a printing terminal

16. Ending a program prematurely • If a program must be aborted because of an input error, can use System.exit(#) (where # represents an integer) • exit is analogous to C++ return statement • System.exit(0) means everything was OK, any other number represents error status

17. Exception Handling • Exception: a run-time event that disrupts program execution • Examples: • file that can’t be opened • input data inappropriate to variable type • Java forces programmer to deal with many such situations ahead of time

18. Exception Handling • Many standard methods, particularly those that perform I/O, are declared to “throw exceptions” • Compiler won’t recognize client methods that don’t handle such exceptions

19. Examples of Exceptions • NullPointerException: attempting to call a method on a null reference • IllegalArgumentException: indicates that data value passed to a method is outside the bounds of its domain; can be used to enforce preconditions • IOException: may occur when attempting to read or write data; for example, attempt to read data of wrong type into a variable

20. Unchecked exceptions • An unchecked exception is one that the compiler doesn’t force the programmer to handle; a NullPointerException is this type of exception • an unchecked exception can cause your program to halt with a runtime error • generally, unchecked exceptions are caused by conditions under the programmer’s control; in other words, errors you could have prevented

21. Checked exceptions • Checked exceptions are caused by external conditions beyond the programmer’s control; for example, I/O exceptions • The compiler insists that the programmer acknowledge such exceptions by providing exception-handling code

22. Exception Handling • Any method that might throw an exception must be invoked in one of two ways: • within a method that announces its propensity to throw the same type of exception: public static void main(String [] args) throws IOException public void read (String filename) throws IOException, ClassNotFoundException • within a method containing a try/catch block - described later

23. Exception handling • The method just described lets the exception pass through to a method higher on the chain of method calls • The second method traps the (potential) exception object in your method and treats the error appropriately • Catching exceptions means surrounding the error-prone code with a try block followed by one or more catch clauses

24. General form of try/catch block try { // code that might throw an exception } catch (ExceptionType e) { // code that handles specific exception - can have as many // catch blocks as needed to catch all pertinent exceptions } finally { // optional clause: executes regardless of whether or not // an exception was thrown in try block }

25. Notes on exception handling syntax • The exception mechanism deals with an object, which is an instance of class Throwable (defined in java.lang.*) or one of its subclasses • So catch block looks like a method declaration with a single parameter, the Throwable object

26. Throwable objects • Often contains useful information about exceptions - examples: • name of file that couldn’t be opened • value of illegal array index • Several methods are defined in Throwable class, including .getMessage(), which returns generic message associated with type of exception caught

27. Strings in Java • String is a built-in class (not a simple type) • Sequence of Unicode characters • String methods include: • length: returns number of character in String String name = “Cate Sheller”; int letters = name.length(); • charAt():returns character at specific index value char first = name.charAt(0);

28. Strings in Java • A String variable can hold reference to any String object – so can assign a different reference to same variable: name = “George W. Bush”; • But String object itself is read-only; can’t change first letter of George’s name to Q, for example – it’s NOT an array of char • String buffer class exists which does allow for this kind of manipulation

29. Strings & Assignment • Can assign reference to String to any String variable (as previously noted) • To copy String object use: String name = “Donald Duck”; String name2 = new String(name);

30. Strings & Logical Comparison • Operator == works as it does with pointers in C++: tests to see if 2 variables reference same object • Member method .equals can be used to test contents of 2 strings: if (name2.equals(name))

31. Strings & Logical Comparison • Member method .compareTo is more general comparison operator: • Returns positive value if calling object is greater than argument • Returns 0 if caller equals argument • Returns negative value if caller is less than argument • Example: if (name2.compareTo(name) > 0)

32. Substrings • The substring method of the String class returns the string described by two arguments: • first argument is position of the first character in the substring • second argument is position of the first character NOT to include in the substring • difference is the length of the substring

33. Substrings • The java.util package includes the StringTokenizer class, which can be used to extract substrings separated by delimiters • A StringTokenizer object is created using two arguments: the string to be broken down, and the delimiting character (space if not specified): String colors = “Red&White&Blue”; StringTokenizer breakup = new StringTokenizer(colors, “&”);

34. StringTokenizer • Once a StringTokenizer is created, can be used to access individual substrings in a sequential fashion • Example: while (breakup.hasMoreTokens()) { String theColor = breakup.nextToken(); … }

35. String Concatenation & Displaying Objects • The + operator concatenates strings with objects of other simple types • For implicit type conversion, can concatenate with an empty string • Since print() and println() work on Strings, the concatenation operation makes output of other types possible

36. String Concatenation & Displaying Objects • For newly-defined data type, can create a toString method which allows output using print or println • For example, the method on the following slide could be used for a Fraction class, with numerator and denominator represented by integer variables n and d

37. toString example public String toString() { return (“” + n + ‘/’ + d); }

38. Converting from String to numeric type • To convert from a String to a primitive numeric type, use the wrapper classes Integer and Double and their parsing methods, parseInt() and parseDouble() • For example: int n; String number = “52402”; n = Integer.parseInt(number); • The parsing methods will throw the unchecked NumberFormatException if the String argument doesn’t contain a number

39. I/O in Java • Java I/O stream library provides System.in, System.out and System.err • To do file I/O, need to declare • FileInputStream object for input • FileOutputStream object for output • No “open” command - use new instead: FileInputStream infile = new FileInputStream(“source.txt”); • No need for “close” - another example of automatic garbage collection

40. Character I/O • Like C++, Java uses streamed I/O • Standard input is represented by System.in (analogous to cin) • System.in.read( ) returns byte as an int: closest analog is cin.get(c) - ASCII input, in other words

41. System.out • Represents stdout • String data can be printed using System.out.print and System.out.println • can print most primitive types, as they can be converted to String • System.out.write prints byte (ASCII character) data

42. Code example import java.io.* class Uppercase { public static void main (String [] args) throws IOException { int x; System.out.println(“Enter text to be converted”); System.out.println (“to uppercase. Hit Ctrl-Z to end”); while ((x = System.in.read()) != -1) { x = Character.toUpperCase((char)x); System.out.write(x); } } }

43. Notes on example • The two lines inside the loop: x = Character.toUppercase((char)x); System.out.write(x); • Form the nucleus of the function: • Character is a class name, and toUppercase is a method defined in that class • the toUppercase method works on char (Unicode) data, so x, which is an int, is cast as char for function to work on it • the write method works on byte (ASCII) data

44. Console char input • As previously noted, System.in.read() reads byte data, not char • To read characters from the console, use System.in to create an InputStreamReader object: InputStreamReader reader = new InputStreamReader(System.in); • To read Strings, create a BufferedReader object from the InputStreamReader, then invoke the readLine() method: BufferedReader kbd = new BufferedReader(reader); String myString = kbd.readLine();

45. GUI input • A simpler way to read input is via an input dialog box; you can create one by invoking the showInputDialog method of JOptionPane class, which is found in the javax.swing package: String input = JOptionPane.showInputDialog(“Enter a number:”); if (input != null) num = Integer.parseInt(input); // reads a number by extracting it from returned String

46. GUI output • Can also create dialog box for output using showMessageDialog method: JOptionPane.showMessageDialog (null, “Hey!”); // first parameter indicates no parent window // second parameter is message displayed

47. Java intro Part 2