TeachJava 2003

1
TeachJava! 2003

• Corky Cartwright
• Dung Nguyen
• Stephen Wong
• Charlie Reis, James Hsia, Neal Hororwitz, Peter
  Centgraf

2
From C To Java

• C and Java have similar syntax.Dont be
  misled!
• Profoundly different semantics high-level
  objects vs. bytes in memory
• Profoundly different programming modelsJava is
  object-oriented (OO)C is object-based (OB) in
  normal usage

3
Encouraging Note

• Writing OO programs in Java is remarkably
  easyprovided we recognize that it is
  fundamentally different than writing OB programs
  in C.
• There is little common conceptual ground, other
  than syntactic conventions, beween OO programing
  (OOP) in Java and OB programming in C

4
Guiding Vision

• Program design in Java is data-directed.Design
  the data abstractions first they will determine
  the structure of the code. In OOP circles, this
  data design process is often called
  object-modeling.
• Common data abstractions are codified as design
  patterns.

5
Secondary Theme

• DrJava, our lightweight, reactive environment for
  Java, facilitates active learning with DrJava
  learning Java is a form of exploration.
• DrJava is not a toy DrJava is developed using
  DrJava. It includes everything that we believe
  is important and nothing more.

6
What Is an Object?

• Collection of fields representing the properties
  of a conceptual or physical object.
• Collection of operations called methods for
  observing and changing the fields of the object.
• These fields and methods often called the
  members of the object.

7
Example Phone Directory

• Task maintain a directory containing the office
  address and phone number for each person in the
  Rice Computer Science Dept.
• Each entry in such a directory has a natural
  representation as an object with three fields
  containing a persons
• name
• address
• phone number
• represented as character strings.

8
Summary of Entry format

• Fields
• String name
• String address
• String phone
• Methods
• String getName()
• String getAddress()
• String getPhone()

9
Java Method Invocation

• A Java method m is executed by sending a method
  call o.m()
• to an object o, called the receiver. The method
  m must be a member of o.
• The code defining the method m can refer to the
  receiver using the keyword this.

10
Finger Exercise

• In the DrJava programming environment, open the
  program file Entry.java, compile it, and type the
  following statements in the Interactions pane
• Entry e new Entry("Corky","DH 3104","x
  6042") e.getName()
• e.getPhone()

11
Java Expressions

• Java supports essentially the same expressions
  over primitive types (int, float, double,
  boolean) as C.
• Notable differences
• boolean is a distinct type from int
• no unsigned version of integer types
• explicit long type

12
Finger Exercise

• Evaluate the following
• -5 3
• -(5 3)
• 5 3
• 5./3.
• 5 / 0
• 5./0.
• 5
• 5. 6.

13
Finger Exercise cont.

• 72. - 32. 1.8
• (72. - 32.) 1.8
• 72. - 30. - 12.
• 72. - (30. - 12.)

14
Java Statements

• Essentially the same form as in C assignment,
  if, while, for, return,
• But well-written Java programs consist primarily
  of assignment, if, and return statements (with
  smattering of for).
• Focus on assignment and if for most of the week.

15
Assignment

• Restricted form of assignment variable
  definition
• type var exp
• Example
• int x 5

16
Finger Exercise

• int x 5
• xx
• double d .000001
• double dd dd
• dd
• dddd
• 1. dd
• 1. dddd

17
Finger Exercise cont.

• Evaluate
• int x 7
• if (x 5) y 0 else y 10
• y
• Did you get the behavior that you expected?
  Repeat the exercise with corrected syntax.
• Evaluate
• boolean switch1 (x 7)
• switch1
• Repeat the exercise with corrected syntax.

18
Classes Object Templates

• A Java program is a collection of classes.
• A class is an object template consisting of a
  collection of membersfields and methods plus a
  constructor, which is a special method used to
  initialize objects when created.

19
Example Class Entry

• class Entry
• / fields /
• String name
• String address
• String phone
• / constructor /
• Entry(String n, String a, String p)
• this.name n
• this.address a
• this.phone p
• / getters /
• String getName() return this.name
• String getAddress() return this.address
• String getPhone() return this.phone

20
Finger Exercise

• In the Definitions pane of DrJava, enter the
  Java program defining the Entry class. In the
  Interactions pane, evaluate the following program
  text
• Entry e new Entry("Corky", "DH 3104", "x
  6042")
• e.getName()
• e.getAddress()
• e.getPhone()
• Save your program for future use in a file named
  Entry.java.

21
Terminology

• The methods that return the fields of a class are
  called getters.
• The special method with the same name as the
  class is called the constructor. The constructor
  is executed when a new instance (object) of the
  class is created using new.

22
Java Data Types

• Two fundamental categories
• Primitive types int, boolean, double, float,
  char, long, short, byte (first three are most
  common)
• Object types all class instances (objects)
  belong to object types, which are disjoint from
  the primitive types
• Values of primitive type (e.g., true, 0) are not
  objects

23
Object Types

• Organized in a strict hierarchy with the
  universal type Object at the top.
• Every class C except Object has an immediate
  superclass, which is the parent of C in the
  hierarchy. In a class definition (like our Entry
  example), the default superclass is Object.
• A descendant in the class hierarchy is called a
  subclass. B is a subclass of A iff A is a
  superclass of B. Entry is a subclass of Object
  Object is a superclass of Entry.

24
null

• There is a special value null of object type on
  which method invocation utterly fails.
• null is a reference to nothing the method
  invocation
• null.m()
• always generates a NullPointerException aborting
  execution.

25
Example the String class

• The String class is built-in to Java, just like
  Object.
• Finger Exercise evaluate
• String s "Corky"
• Object o s
• o
• o s
• String t "Cork" "y
• t s
• s.length()
• o null
• o.length()
• Morals
• multiple copies of the same String may exist do
  not use to test String equality.
• Do not use null to represent legitimate data
  values.

26
Object Types cont.

• Each subclass C inherits (includes) all of the
  members of its superclass.
• The declared members of C augment the inherited
  members with one exception if C declares a
  method m with exactly the same name and types as
  an inherited method, then the new definition of m
  overrides (replaces) the inherited definition.

27
Inheritance from Object

• The Object class has several members that its
  children inherit. They include the methods
• public String toString() which gives a String
  representation for the object.
• public boolean equals(Object o) which compares
  this to o

28
Example of Overriding

• class Entry
• / fields /
• String name
• String address
• String phone
• / constructor /
• Entry(String n, String a, String p)
• this.name n
• this.address a
• this.phone p
• / accessors /
• String getName() return this.name
• String getAddress() return this.address
• String getPhone() return this.phone

29
Finger Exercise

• Open your Entry class into the DrJava
  Interactions pane.
• Compile your program and evaluate
• Entry e new Entry("Corky", "DH 3104", "x
  6042") e
• Add the definition of toString() from the
  previous slide to your Entry class.
• Compile your program and evaluate
• Entry e new Entry("Corky", "DH 3104", "x
  6042") e

30
Adding a Method Definition

• class Entry
• / return this if its name matches keyName
  otherwise return null indicating failure /
• Entry match(String keyName)
• if (keyName.equals(this.name)) return this
  else return null
• Finger Exercise Add this method definition to
  your Entry class, compile it, and evaluate
• Entry e new Entry("Corky", "DH 3104", "x
  6042") e.match("Corky")
• e.match("Matthias")

31
The Wrapper Classes

• How do we treat primitive values as objects?
  Java includes a built-in wrapper class for each
  primitive type.
• Examples
• Integer is the wrapper class for int
• Boolean is the wrapper class for boolean
• Double is the wrapper class for double

32
Finger Exercise

• In the DrJava Interactions evaluate the
  following
• Integer i new Integer(5)
• i
• Integer j i
• i j
• Integer k new Integer(5)
• i k

33
Constructors

• Given a class definition, Java provides a
  mechanism called new for creating new instances
  of the class.
• To exploit the new, the class must provide a
  special method called a constructor that
  specifies how the fields of the created object
  are initialized.
• A constructor method has the same name as the
  class and does not contain the return type in the
  heading.
• Example
• Entry(String n, String a, String p)
• this.name n
• this.address a
• this.phone p
• If a class does not include a constructor, Java
  provides a default constructor (of no arguments)
  that does nothing.

34
Finger Exercise
Add a second constructor Entry(String n)
to the Entry class where n specifies the name
of the entry. Use any reasonable default value,
e.g., "unknown" for the address and phone
fields. Recompile your program and evaluate
the expression new Entry("Matthias")
35
Union Pattern

• The union pattern is used to represent different
  forms of related data with some common behavior.
  
• The pattern consists of an abstract class A
  together with a collection of variant subclasses
  B1, ..., BN extending A. An abstract class
  cannot be instantiated using new.
• The collection of classes A, B1, ..., BN is
  called a union hierarchy and A classes is called
  the root class of the hierarchy.
• The common behavior is codified by a set of
  methods in A, which may be abstract Each such
  method m has an associated contract that that the
  implementation in each variant class must obey.

36
Class Diagram of Union Pattern

37
Defining a Method on a Union
abstract m()

m()
m()
38
City Directory Example

• Assume that we want to design the data for an
  online city phone book. In contrast to our
  DeptDirectory example, such a directory will
  contain several different kinds of listings
  businesses, residences, and government agencies.
• The entry data for such a directory is
  represented by using the union pattern to
  identify the common behavior among the various
  kinds of listings.
• In this case, the common behavior is the
  existence of a String name for the listing and
  the String text of the listing (given by
  toString()).

39
Definition of CityEntry

• A CityEntry is either
• a ResidentialEntry(name,address,phone)
• a BusinessEntry(name,address,phone,city,state)
• a GovernmentEntry(name,address,phone,city,
  state, government)
• Examples
• ResidentialEntry("Corky Cartwright","3310
  Underwood", "713-660-6967")
• BusinessEntry("ToysRUs","2101 Old Spanish
  Trail","713-664-1234","Houston", "TX")
• GovernmentEntry("Federal Drug Administration",
  "800-666-9000", "Washington", "DC", "Federal")

40
Class Diagram of CityEntry Union
41
Defining Methods on Unions

• Assume that we want to define a method on a
  union. The method will typically require a
  separate implementation for each variant
  (subclass) of the union. But each
  implementation will satisfy the same "contract"
  (description of behavior).
• In Java, the method must not only be defined in
  each variant of the union, it must be declared as
  abstract in the root class of the union
  hierarchy. Otherwise, Java will not allow the
  method to be invoked on objects of the union type.

42
Methods for CityEntry

• To process entries in a city directory, we need
  two methods
• / Returns the name of this CityEntry /
• String getName()
• / Returns all information in this CityEntry
  /
• String toString()
• The toString() method is already declared in
  Object (the superclass of CityEntry) but the
  provided default behavior does not satisfy the
  contract given above, so it must be overridden in
  each variant.
• The getName must be declared as abstract in
  CityEntry.

43
CityEntry

• abstract class CityEntry
• / Returns the name for the entry /
• abstract String getName()
• / Returns all of the information in the
  listing in String form/
• / String toString() /
• class BusinessEntry extends CityEntry
• String name, address, phone, city, state
• BusinessEntry(String n, String a, String p,
  String c, String s)
• this.name n
• this.address a
• this.phone p
• this.city c
• this.state s
• String getName() return this.name
• public String toString()
• return "Business" this.name ","
  this.address ","

44
CityEntry cont.

• class GovernmentEntry extends CityEntry
• String name, address, phone, city, state,
  government
• GovernmentEntry(String n, String a, String p,
  String c, String s, String g)
• this.name n
• this.address a
• this.phone p
• this.city c
• this.state s
• this.government g
• String getName() return this.name
• public String toString()
• return "Government" this.name ","
  this.address "," this.phone
• "," this.city "," this.state ","
  this.government ""
• class Residential Entry extends CityEntry
• String name, address, phone, city
• ResidentialEntry(String n, String a, String p)
  

45
Member Hoisting

• In a union hierarchy, the same code may be
  repeated in every variant.
• A cardinal rule of software engineering is never
  duplicate code. We can eliminate code
  duplication in a union hierarchy by hoisting
  duplicated code (code that is invariant within
  the union) into the abstract class at the route
  of the hierarchy.

46
CityEntry Example

• We can hoist the fields name, address, and phone
  and the getters getAddress and getPhone. To
  perform this transformation we must introduce a
  constructor in the abstract class CityEntry to
  initialize the fields declared in the class.
  This constructor can be called from subclass
  constructors by using the special method name
  super.
• This hoisting process does not affect the form of
  the class diagram.

47
CityEntry II

• abstract class CityEntry
• String name, address, phone
• CityEntry(String n, String a, String p)
• name n
• address a
• phone p
• String getName() return name
• String getAddress() return address
• String getPhone() return phone
• / Returns all of the information in the
  listing /
• / String toString() /
• class BusinessEntry extends CityEntry
• String city, state
• BusinessEntry(String n, String a, String p,
  String c, String s)
• super(n,a,p)
• this.city c
• this.state s

48
CityEntry II cont.

• class GovernmentEntry extends CityEntry
• String city, state, government
• GovernmentEntry(String n, String a, String p,
  String c, String s, String g)
• super(n,a,p)
• this.city c
• this.state s
• this.government g
• String getCity() return this.city
• String getState() return this.state
• String getGovernment() return
  this.government
• public String toString()
• return "Government" this.getName() ","
  this.getAddress() ","
• this.getPhone() "," this.city ","
  this.state ","
• this.government ""
• class ResidentialEntry extends CityEntry

49
Partial Hoisting

• In a union hierarchy, the same code may be
  repeated in some proper subset of the variants.
• We can eliminate this code duplication by
  introducing a new abstract class that is a
  superclass only of the variants that repeat the
  same code.
• Partial hoisting modifies the form of the class
  diagram because it introduces a new abstract
  class below the root abstract class of the union.

50
Revised Class Hierarchy
New abstract class
51
CityEntry III

• abstract class CityEntry
• String name, address, phone
• CityEntry(String n, String a, String p)
• name n
• address a
• phone p
• String getName() return name
• String getAddress() return address
• String getPhone() return phone
• / Returns all of the information in the
  listing /
• / String toString() /
• abstract class NonResidentialEntry
• String city, state
• NonResidentialEntry(String n, String a, String
  p, String c, String s)
• super(n, a, p)
• city c

52
CityEntry III cont.

• class BusinessEntry extends NonResidentialEntry
• BusinessEntry(String n, String a, String p,
  String c, String s) super(n,a,p,c,s)
• public String toString()
• return "Business" this.getName() ","
  this.getAddress() ","
• this.getPhone() "," this.getCity()
  "," this.getState() ""
• class GovernmentEntry extends CityEntry
• String government
• GovernmentEntry(String n, String a, String p,
  String c, String s, String g)
• super(n,a,p,c,s)
• this.government g
• String getGovernment() return
  this.government
• public String toString()
• return "Government" this.getName() ","
  this.getAddress() "," this.getPhone()
• "," this.getCity() ","
  this.getState() "," this.getGovernment()
  ""

53
Defining DeptDirectory Data

• A DeptDirectory is either
• Empty(), the empty DeptDirectory , or
• NonEmpty(first,rest), a non-empty DeptDirectory,
  where first is an Entry and rest is a
  DeptDirectory
• Examples
• Empty()NonEmpty(Entry("Stephen","DH 3103","x
  3846"), Empty())

54
Class Diagram for DeptDirectory
55
DeptDirectory
abstract class DeptDirectory class Empty
extends DeptDirectory class Cons extends
DeptDirectory Entry first DeptDirectory
rest Cons(Entry f, DeptDirectory r)
this.first f this.rest r Entry
getFirst() return this.first DeptDirectory
getRest() return this.rest
56
The Composite Pattern

• The DeptDirectory class hierarchy is a special
  form of union called a composite. A union is
  composite when one or more variants contain
  fields of the root class type. In other words,
  variants in the union contain references to
  objects of union type. In the DeptDirectory
  example, the NonEmpty variant contains a field
  rest of type DeptDirectory.

57
Searching a DeptDirectory

• Given the name of a person, we want to find that
  person's phone number in our DeptDirectory. In
  other words, we want to define a method on the
  DeptDirectory class
• findAddress(String keyName)
• that searches "this" DeptDirectory for an Entry
  that matches the argument keyName.

58
The Interpreter Pattern

• To define a method m on a composite class like
  DeptDirectory, we follow the same process as we
  would in defining a method on a union class, with
  one new wrinkle. In the variants that refer to
  the composite class (have fields of composite
  class type), computing m for this will usually
  involve delegating the task of computing m for
  the embedded references to the composite class.
• In our DeptDirectory example, the only embedded
  reference to DeptDirectory in variant subclasses
  is the rest field in NonEmpty.

59
Template for coding findPhone

• abstract class DeptDirectory
• abstract String findPhone(String key)
• F
• class Empty extends DeptDirectory
• String findPhone(String key)
• public String toString() return "Empty()"
• class Cons extends DeptDirectory
• Entry first
• DeptDirectory rest
• Cons(Entry f, DeptDirectory r)
• this.first f
• this.rest r
• Entry getFirst() return this.first

Fill in this method body
Fill in this method body
60
findPhone

• abstract class DeptDirectory
• abstract String findPhone(String key)
• class Empty extends DeptDirectory
• String findPhone(String key)
• return null
• public String toString() return "Empty()"
• class NonEmpty extends DeptDirectory
• Entry first
• DeptDirectory rest
• NonEmpty(Entry f, DeptDirectory r)
• this.first f
• this.rest r
• Entry getFirst() return this.first