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.outexample: 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 blocktry{

// 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 exampleimport 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