Object-Oriented Programing in Java

1
Object-Oriented Programing in Java

• Cheng-Chia Chen

2
Contents

• Object and Class
• The contents of an object/class
• Creating and initializing Objects
• Accessing object data and methods
• Destroying and finalizing objects
• Subclass and inheritance
• Interfaces
• Java modifiers summary

3
What is an Object ?

• Real-world objects
• Concrete objects Apple1, Car1, TV2, Teacher2,
  Student3,
• Conceptual Objects 1, 2.3, Date1, Meeting2,
  point2,
• Objects have
• Properties (attributes) color, weight, height,
  sex, name, speed, position,
• Capabilities (behaviors) can receive commands(,
  request, query) and respond (do actions) based on
  its internal states to change its internal state
  and/or external environment.
• The properties of an object constitutes its
  current state.

4
What is a Software object ?

• a software bundle of data and functions used to
  model real-world objects you find in everyday
  life.
• In OOP, Software objects are building block of
  software systems
• program is a collection of interacting objects
• objects cooperate to complete a task
• to do this, they communicate by sending
  messages to each other
• Software objects can model
• tangible things School, Car, Bicycle,
• conceptual things meeting, date
• Processes finding paths, sorting cards
• Note Software objects are only abstraction of
  real-world objects properties and behavior of
  irrelevance will not be modeled in software
  objects.

5
What is a Java Object?

• In Java, an object consists of 0 or more fields
  and 0 or more methods.
• Fields are used to model properties.
• Methods are used to model capabilities.
• Fields are variables.
• like the fields of a C struct.
• An object without methods is equivalent to a C
  struct.
• A method is similar to a C function.
• Normally, it will operate on the fields of the
  object.
• These fields are accessible by name in the
  method.
• Java variables can not hold objects, only
  references to them.
• Object do not have a names.
• Object are created only at runtime.
• Given a reference r to an object, the syntax for
  accessing a field is r.field_name, the syntax
  for accessing a method is r.method()

6
Classes and Objects

• Current conception
• a java/software object ? a real-life object,
• e.g., a Java car ? a real car
• Disadvantage impractical to work with objects
  this way
• may be indefinitely many (i.e., modeling all
  atoms in the universe)
• do not want to describe each individual
  separately, because they may have much in common
• Classifying objects into classes of similar
  properties/behaviors
• factors out commonality among sets of similar
  objects
• lets us describe what is common once
• then stamp out any number of copies later
• Ex Student S1, S2, S3 CourseC1,C2,C3
  Teacher T1,T2
• but not s1, t1, s2, t2, c1,c2,c3,s3
• Analog
• stamp ?? (class)
• Imprints ?? (objects)

7
What is a Java Class?

• In Java, a class is a template (textual
  description) of a set of similar objects.
• All objects in the class have the same types of
  properties and the same set of capabilities.
• It defines the fields and methods that all
  objects in that class will have.
• Classes have names.
• Class appear in the text of your program.
• A java program consists of a set of classes.
• A defined class is a Java Type, so you can have
  objects or variables of that type.

8
Class diagrams
9
An Example the class of Circles

• Properties a circle can be described
• by the x, y position of its center and
• by its radius.
• Methods Some useful operations on Circles
• compute circumference,
• compute area,
• check whether points are inside the circle,
• etc.

10
The Circle class

• By defining the Circle class (as below), we
  create a new data type.
• // The class of circles (partially defined)
• class Circle
• // Fields
• double x, y
• double r
• // Methods
• double circumference() return
  2 3.14159 r
• double area()
  return 3.14159 r r
• void scale(double multiplier) r
  multiplier
• void print()
• System.out.println("circle of radius " r
  
• " with center at (" x ","
  y ") )

11
Creating Objects

• In Java, objects are created by the new operator.
  
• For example
• //define a variable to refer to Circle objectsno
  objects yet.
• Circle c // c is null now
• // create a circle object and make the variable
  refer to it
• c new Circle()
• // define variable and create Circle object all
  at once
• Circle d new Circle()
• Note the fields in these objects are given
  default values at creation (0 for numbers null
  for object references)

12
Accessing Object Data

• We can access data fields of an object (subject
  to visibility restrictions -- see later).
• For example
• // create a new Circle
• Circle c new Circle()
• //initialize our circle to have center (2, 5) and
  radius 1.0.
• c.x 2.0
• c.y 5.0
• c.r 1.0
• // create another circle
• Circle d new Circle()
• //initialize this circle to have center (10,7)and
  double the radius of circle c.
• d.x 10.0
• d.y 7.0
• d.r c.r 2.0

13
Using Object Methods

• To access the methods of an object, use same
  syntax as accessing the data of an object
• Circle c
• double a
• ...
• a c.area() // Not a area(c)
• Notes
• Each method has a signature, which is defined by
  
• The method name and
• The sequence of all types of arguments
• Each class can define several methods with same
  name and different types of arguments
  (overloading).

14
Constructors

• Every class in Java has at least one constructor
  method, which has the same name as the class.
• The purpose of a constructor is to perform any
  necessary initialization for new objects.
• Java provides a default constructor that takes no
  arguments and performs no special initialization
  (i.e. gives objects default values).
• Note Java compiler provide the default
  constructor className() only if you do not
  provide any constructor at your class definition.
• For example
• Circle c new Circle()

15
Defining a Constructor

• Can define additional constructors for
  initialization.
• // The circle class, with a constructor
• public class Circle
• public double x, y, r
• // Constructor method
• public Circle(double x, double y, double r)
• this.x x
• this.y y
• this.r r
• // Other methods ... as above
• ...

16
Defining a Constructor (cont.)

• With the new constructor, we can create and
  initialize a Circle object as
• Circle c new Circle(2.0, 5.0, 1.0)
• A constructor is like a (static) method whose
  name is the same as the class name.
• The return value is an instance of the class.
• No return type is specified in constructor
  declarations, nor is the void keyword used.

17
Multiple Constructors

• A class can have any number of constructor
  methods.
• public class Circle
• public double x, y, r
• // Constructors
• public Circle(double x, double y, double r)
• this.x x this.y y this.r r
• public Circle(double r)
• x 0.0 y 0.0 this.r r
• public Circle(Circle c)
• this.x c.x this.y c.y this.r c.r
  
• public Circle()
• x 0.0 y 0.0 r 1.0
• // Other methods ... as above
• ...

18
Multiple Constructors (cont.)

• With the new constructors, we can initialize
  circle objects as follows
• Circle c1 new Circle(2.0, 5.0, 1.0)
• // c1 contains (2.0, 5.0, 1.0)
• Circle c2 new Circle(3.5)
• // c2 contains (0.0, 0.0, 3.5)
• Circle c3 new Circle(c2)
• // c3 contains (0.0, 0.0, 3.5)
• Circle c4 new Circle()
• // c4 contains (0.0, 0.0, 1.0)
• All uninitialized data receives default values.

19
Invoking one constructor from another

• We can use this() in a constructor to invoke
  other constructor.
• public class Circle
• public double x, y, r
• // Constructors
• public Circle(double x, double y, double r)
• this.x x this.y y this.r r
• public Circle(double r)
• //x 0.0 y 0.0 this.r r replaceable
  by
• this(0.0,0.0,r)
• public Circle()
• //x 0.0 y 0.0 r 1.0 replaceable by
• this(1.0)
• ...
• Note do not result in recursion.

20
Object and Object References

• A java object is a memory structure containing
  both data and methods
• An object reference holds the memory address of
  an object
• Rather than dealing with arbitrary addresses, we
  often depict a reference graphically as a
  pointer to an object
• ChessPiece bishop1 new ChessPiece()

21
Assignment Revisited

• The act of assignment takes a copy of a value and
  stores it in a variable
• For primitive types
• int num1 5, unm2 12
• num2 num1

22
Reference Assignment

• For object references, assignment copies the
  memory location
• bishop2 bishop1

23
Aliases

• Two or more references that refer to the same
  object are called aliases of each other
• One object (and its data) can be accessed using
  different variables
• Aliases can be useful, but should be managed
  carefully
• Changing the objects state (its variables)
  through one reference changes it for all of its
  aliases
• Ex
• Circle c new Circle(1.0, 2.0, 3.0)
• Circle d c // c and d are aliases.
• c.r 4.0 // d.r 4.0 now.

24
Destroying Objects

• When an object no longer has any valid references
  to it, it can no longer be accessed by the
  program
• It is useless, and therefore called garbage
• Java performs automatic garbage collection
  periodically, returning an garbage object's
  memory to the system for future use
• Hence it is needless to explicitly destroy
  objects.
• How can references to objects '' go away' ?
• Re-assigning object variables (a b a null)
  or
• object variables (locals or parameters) going out
  of scope.
• no more malloc/free bugs

25
Object Finalization

• A constructor method performs initialization for
  an object a Java finalizer method performs
  finalization for an object.
• Garbage collection only help freeing up memory.
• But there are other resources needed to be
  released.
• file descriptors, sockets, lock, database
  connection.

26
Example A Finalizer Method from the Java
FileOutputStream class.

• /
• Closes the stream when garbage is collected.
• Checks the file descriptor first to make sure
  it is not already closed.
• /
• protected void finalize() throws IOException
• if (fd ! null) close()

27
Notes about finalize()

• invoked before the system garbage collects the
  object.
• no guarantees about when a finalizer will be
  invoked, or in what order finalizers will be
  invoked, or what thread will execute finalizers.
  
• After a finalizer is invoked, objects are not
  freed right away.
• because a finalizer method may "resurrect" an
  object by storing the this pointer somewhere.
• may throw an exception If an uncaught exception
  actually occurs in a finalizer method, the
  exception is ignored by the system.
• No class Finalization method defined.

28
Classes v.s. Objects

• two of the most frequently occurring terms in the
  OO programmer's vocabulary.
• A class An object...
• exist at compile time exists at runtime
  only
• a template/pattern created/instantiated from
• for objects a class' specification
• "only exists once" can be created many
  times
• from one class
• a .java file returned by the new
• operator
• dress pattern dress
• architectural plans house
• stamp imprints

29
Types of variables and methods in a Java class

• There are two main types of variables/fields
• instance variables
• class (or static) variables
• Instance variables store information pertaining
  to one particular object's state
• Class variables store information pertaining to
  all objects of one class
• Likewise, there are two types of methods
• Instance methods
• Class (static) methods
• Instance methods belong to individual objects
  whereas class methods belongs to the whole class.
• Note In class method, you cannot use this and
  instance variables.(why?)

30
Class diagram of an Account class.
Class Name
Instance Methods
ShowNumberOfAccount
Class Methods
31
Declare class field/method with the static
Modifier

• makes methods and variables belong to the class
  rather than instances of the class.
• Example counting how many circles
• public class Circle
• public double x, y, r // instance variables
• // ncircles is class variable
• public static int ncircles 0
• // Constructors
• public Circle(double x, double y, double r)
• this.x x this.y y this.r r
• ncircles
• public Circle(double r)
• x 0.0 y 0.0 this.r r
• ncircles
• ...

32
The static Modifier (cont.)

• In the above example, there's only one instance
  of the ncircles variable per Circle class but one
  instance of x, y and r per Circle object.
• Diff. ways to reference ncircles
• Circle.ncircles // ClassName.classVarName
• ncircles this.ncircles, // used inside the
  Circle class definition only
• c.ncircles // where c is a Circle variable
• Similar approach for static methods.
• Examples of static methods (or called class
  method)
• Math.cos(x) Math.pow(x,y) Math.sqrt(x)

33
Notes on class methods

• Must be declared with the static keyword
• Also called static method
• Can only operate on class variables (e.g.,
  static)
• Cannot use this
• Cannot use instance variables
• To access a class method same as to access class
  vars
• Circle.countCircles() // ClassName.classVarName
• countCircles() this.countCircles(),
• // legal only when inside the Circle
  class definition
• c.countCircles() // where c is a Circle variable
• Lots of examples of class methods in the JDK
  (e.g., String)

34
Example instance member v.s. class member

• Class B int x static int y
• static int b1()
• int b2 ()
• static int b3() // class method
• int c
• c x c this.y //error
• c y c B.y //ok!
• A a new A()
• B b new B()
• c a.a1() //ok!
• c a.a2() // ok!
• c A.a2() // error!
• c A.a1() // ok!
• c b.b1() //ok!
• c b.b2() // ok!
• c B.b2() // error!
• c B.b1() // ok!
• c b1() // ok
• c b2() // error

• Int b4() // instance method
• c x c this.x //ok!
• c y c B.y c this.y //ok!
• c b1() c this.b1() // ok
• c b2() cthis.b2() // ok
• Class A
• public static int a1()
• public int a2()

35
Class and Instance initializers

• Both class and instance variables can have
  initializers attached to their declarations.
• static int num_circles 0
• float r 1.0
• Class variables are initialized when the class is
  first loaded.
• Instance variables are initialized when an object
  is created.
• Sometimes more complex initialization is needed.
• For instance variables, there are constructor
  methods ,and instance initializer.
• For class variables static initializers are
  provided

36
An example static/instance initializer

• public class TrigCircle // Trigonometric
  circle
• // Here are our static lookup tables, and
  their own simple initializers.
• static private double sin new
  double1000
• static private double cos new
  double1000
• // Here's a static initializer "method" that
  fills them in.
• // Notice the lack of any method declaration!
• static
• double x, delta_x
• int i
• delta_x (Circle.PI/2)/(1000-1)
• for(i 0, x 0.0 i lt 1000 i, x
  delta_x)
• sini Math.sin(x)
• cosi Math.cos(x)
• // The rest of the class omitted.

37
An example static/instance initializer (continued)

• // instance field and methods
• Private int data new int100 // datai
  i for i 0..99
• // instance initializer as an unnamed void method
• for(int I 0 I lt100 I) dataI I

38
Notes on initializers

• can have any number of static/instance
  initializers
• can appear anywhere a field or method can appear.
• Static initializer behaves like class method and
  cannot use this keyword and any instance fields
  of the class
• The body of each instance initializers (alone
  with field initialization expressions) is
  executed in the order they appear in the class
  and is executed at the beginning of every
  constructor.
• The body of each static initializers (alone with
  static field initialization expressions) is
  executed in the order they appear in the class
  and is executed while the class is loaded.

39
Inheritance in OOP

• Inheritance is a form of software reusability in
  which new classes are created from the existing
  classes by absorbing their attributes and
  behaviors.
• Instead of defining completely (separate) new
  class, the programmer can designate that the new
  class is to inherit attributes and behaviours of
  the existing class (called superclass). The new
  class is referred to as subclass.
• Programmer can add more attributes and behaviors
  to the subclass, hence, normally subclasses have
  more features than their superclasses.
• Inheritance relationships form tree-like
  hierarchical structures.

40
Subclasses and Inheritance

• An important aspect of OO programming
• the ability to create new data types based on
  existing data types
• Example ... a class of drawable Circles
• we'd like to be able to draw the circles we
  create, as well as setting and examining their
  properties.
• for drawing, we need to know the color of the
  circle's outline and its body
• In Java, we implement this by defining a new
  class that extends the behavior of the Circle
  class.
• This new class is a subclass of Circle.

41
Subclass Example

• The class GraphicCircle
• public class GraphicCircle extends Circle
• // Extra fields
• Color outline, fill
• // Extra constructors
• public GraphicCircle(Color edge, Color fill)
• x 0.0 y 0.0 r 1.0
• outline edge this.fill fill
• public GraphicCircle(double r, Color edge,
  Color fill)
• super(r) outline edge this.fill
  fill
• // Extra methods
• public void draw(Graphics g)
• g.setColor(outline) g.drawOval(x-r, y-r,
  2r, 2r)
• g.setColor(fill) g.fillOval(x-r, y-r,
  2r, 2r)

42
Subclass Inheritance

• A subclass inherits fields and methods from its
  parent class.
• A subclass method overrides a superclass method
  if they have the same signature.
• A subclass field shadows a superclass field if
  they have the same name.
• Refer to the superclass field via super.field
• Note you can also use super.method() to refer
  to overridden superclass method.

43
Using Subclasses

• Subclasses are just like ordinary classes
• GraphicCircle gc new GraphicCircle()
• ...
• double area gc.area()
• We can assign an instance of GraphicCircle to a
  Circle variable.
• Example
• GraphicCircle gc
• ...
• ...
• Circle c gc //widening conversion is
• // always safe explicit cast is not needed.

44
Superclasses, Objects, and the Class Hierarchy

• Every class has a superclass.
• If a class has no extends clause, it extends the
  Object class.
• Object Class
• the only class that does not have a superclass
• methods defined by Object can be called by any
  Java object

45
Abstract Classes

• Abstract class allows us to declare methods
  without implementation.
• the unimplemented method is called an abstract
  method.
• Subclasses can extend abstract class and provide
  implementation of all or portion of abstract
  methods.
• The benefit of an abstract class is that
• methods may be declared such that the programmer
  knows the interface definition of an object,
• however, methods can be implemented differently
  in different subclasses of the abstract class.

46
Abstract Classes (cont.)

• Any class containing an abstract method is
  automatically abstract itself
• But an abstract class need not have abstract
  methods in it!
• an abstract class can not be instantiated
• a subclass of an abstract class can be
  instantiated if it overrides each of the abstract
  methods of its superclass and provides an
  implementation for all of them
• if a subclass of an abstract class does not
  implement all of the abstract methods it
  inherits, that subclass is itself abstract

47
Abstract Classes (cont.) an example

• public abstract class Shape
• public abstract double area() // abstract
  methods
• // to be implemented by
  subclasses
• public abstract double circumference()
• public class Circle extends Shape
• protected double r
• protected static final double PI3.141592653
• public double Circle() r 1.0
• public double Circle(double r) this.r r
  
• // implementation of two abstract methods of
  shape class
• public double area() return PIrr
• public double circumference() return
  2PIr
• public double getRadius() return r

48
Abstract Classes an example (cont.)

• public class Rectangle extends Shape
• protected double w,h
• // two constructors
• public Rectangle() w1.0 h1.0
• public Rectangle(double w, double h)
• this.w w this.h h
• // implementation of two parent methods
• public double area() return wh
• public double circumference()
• return 2(w h)
• // methods for this class
• public double getWidth() return w
• public double getHeight() return h

49
Inheritance revisited

• the concept of inheritance
• the protected modifier
• adding and modifying methods through inheritance
• creating class hierarchies

1
50
Inheritance

• Inheritance allows a software developer to derive
  a new class from an existing one
• The existing class is called the parent class, or
  superclass, or base class
• The derived class is called the child class or
  subclass.
• The child class inherits characteristics (data
  methods) of the parent class
• That is, the child class inherits the methods and
  fields defined for the parent class

2
51
Inheritance

• Inheritance relationships are often shown
  graphically in a class diagram, with the arrow
  pointing to the parent class
• Inheritance relationships
• base class Vehicle
• derived class Car
• Car inherits data methods
• from Vehicle

Inheritance should create an is-a relationship,
meaning the child is a more specific version of
the parent
52
Deriving Subclasses

• The reserved word extends is used to establish an
  inheritance relationship
• class Car extends Vehicle
• // class contents
• Example next slide

4
53
(No Transcript)
54
class Book protected int pages 1500
public void pageMessage ()
System.out.println ("Number of pages "
pages) // method pageMessage // class
Book class Dictionary extends Book private
int definitions 52500 public void
definitionMessage () System.out.println
("Number of definitions "definitions)
System.out.println ("Definitions per page "
definitions/pages) // inherited var //
method definitionMessage // class Dictionary
55
Inheritance Example

• class Main // Test Driver
• public static void main (String args)
• Dictionary webster new Dictionary ()
• webster.pageMessage() // inherited
  method
• webster.definitionMessage() //
  class Words

56
Controlling Inheritance by the protected Modifier

• The protected (and public) visibility modifier
  allows a member of a parent class to be inherited
  into the child
• But protected visibility provides more
  encapsulation than public does
• However, protected visibility is not as tightly
  encapsulated as private visibility
• Note Unlike C, Inheritance does not change the
  visibility of the parent class members when used
  through instances of child classes.

5
57
Visibility modifiers and their usage

• The visibility modifiers determine which class
  members can be referenced from where and which
  cannot.
• public members
• all classes
• protected members
• all classes in the same package
• all subclasses (and subsubclasses )
• Note Java has no notions of public, private or
  protected inheritance as in C all inheritances
  are public.
• package members default visibility
• all classes in the same package
• private members
• can only be used in the same class where the
  member is defined.

58
Visible regions for members of class A
visible region for pubic members of class A
visible region for protected members
visible region for package members
package a.b.c public class A public int
p1 protected int p2 int p4 //package
scope private int p3
package a.b.c
package a.b.c extend A
visible region for private members of class A
extend A
extend A
extend A
59
Protected members are accessible to subclass (and
package) code

• class C extend B
• int p
• B b new B()
• p b.p1 // ok since p1 is public
• p b.p2 // ok
• p p2 // ok ! protected p2 is inherited
• A a new A()
• p a.p2 // error!!
• // protected field (p2) can be accessed from
  subclasses only through subclass instances
• class D B b new B()
• int i b.p2
• //error p2 is not visible within D class

60
The super Reference

• Constructors are not inherited, even though they
  are declared to have public visibility
• Yet we often want to use the parent's constructor
  to set up the "parent's part" of the object
• The super reference can be used to refer to the
  parent class, and is often used to invoke the
  parent's constructor

6
61
class Book protected int pages public
Book (int pages) this.pages pages
public void pageMessage ()
System.out.println ("Number of pages " pages)
// class Book class Dictionary extends
Book private int definitions public
Dictionary (int pages, int definitions)
super (pages) // construct Book part of a
Dictionary this.definitions definitions
// constructor Dictionary public void
definitionMessage () System.out.println
("Number of definitions " definitions)
System.out.println ("Definitions per page "
definitions/pages) // method
definitionMessage // class Dictionary
62
class Main2 public static void main
(String args) Dictionary webster new
Dictionary (1500, 52500)
webster.pageMessage() webster.definitionMes
sage() System.out.println(webster) // try
println object // method main //
class Words2
63
Single vs. Multiple Inheritance

• Java supports single inheritance, meaning that a
  child class can have only one parent class
• Multiple inheritance allows a class to be derived
  from two or more classes, inheriting the members
  of all parents
• Collisions, such as the same variable name in two
  parents, have to be resolved
• In most cases, the use of interfaces gives us the
  best aspects of multiple inheritance without the
  overhead

64
Types of Objects and Variables

• The type of an object is the class that is
  referred to when it is created via new construct.
• Student s1 new Student(name, age, sex)
• Two types associated with variables ( including
  method parameters/fields)
• The declared type of a variable is the type
  referred to in its declaration (also declared
  class compile-time type)
• Person p1, p2 new Person()
• The actual type of a variable is the type of the
  object bound to the variable at a specific moment
  during program execution (also run-time type)
• p1 s1
• Note the declared type of a variable is
  static(i.e., unchangable ) once it is declared,
  while the actual type of a variable is dynamic
  (i.e., can be changed by assignment of new object
  of different type.
• p2 s1

65
Example Declared type and actual type
66
Example Actual type
67
Overriding Methods

• What happens if both parent and child class
  contains members of the same signature ?
• fields gt variable shadowing constructor
  impossible!
• methods gt methods overriding
• A child class can override the definition of an
  inherited method in favor of its own
• A child can redefine a method it inherits from
  its parent
• Overriding method
• has the same signature as the parent's method
• has different code in the body
• The actual type (not casted type) of an object
  determines which method is invoked
• See Messages.java

8
68
class Messages public static void main
(String args) Message m new
Message() Advice a new Advice()
m.message() a.message()
(Message a).message() // same as a.message()
// class Messages class Message
public void message() System.out.println
(Message") // class Thought class
Advice extends Message public void message()
// overriding method System.out.println
(Advice") // class Advice
69
Overloading vs. Overriding

• Dont confuse the concepts of overloading (??)
  and overriding(??)
• Overloading deals with multiple methods in the
  same class with the same name but different
  signatures
• Overriding deals with two methods, one in a
  parent class and one in a child class, that have
  the same signature
• Overloading lets you define a similar operation
  in different ways for different data
• Overriding lets you define a similar operation in
  different ways for different object types

9
70
The super Reference Revisited

• Inherited parent methods/fields can be explicitly
  invoked using the super reference
• If a method/field is declared with the final
  modifier, it cannot be overridden
• The concept of overriding can be applied to data
  (called shadowing variables), but shadowing
  behaves quite differently from overriding.
• The syntax of super is
• super.method (parameters)
• super.var
• See Firm.java

10
71
Shadowing superclass fields vs overriding
superclass methods

• class A int x int m()
• class B extends A int x int m()
• class C extends B
• int x // x in B and A are shadowed
• // by this.x
• int m() // m() overrides m() in A B
• C c new C()
• x, this.x // field x in C
• super.x, ((B) this).x // field x in B
• ((A) this).x // filed x in A
• super.super.x // syntax error!!
• c.x // field in C
• ((B)c).x // fields in B
• ((A)c).x // fields in A

((A) c).m() // m() in A ? no
!! super.m() // m() in B ((B) this).m()
// m() in C ((A) this).m() // m() in C ((A)
c).m() ((B) c).m() m() // m()
in C
72
class Firm public static void main (String
args) Manager sam new Manager ("Sam",
"123 Main Line", "555-0469",
"123-45-6789", 1923.07) Employee carla
new Employee ("Carla", "456 Off Line",
"555-0101", "987-65-4321", 846.15)
Employee woody new Employee ("Woody",
"789 Off Rocker", "555-0000", "010-20-3040",
769.23) woody.print()
System.out.println ("Paid " woody.pay())
System.out.println() carla.print()
System.out.println ("Paid " carla.pay())
System.out.println() sam.print()
sam.awardBonus (2000) System.out.println
("Paid " sam.pay()) System.out.println()

73
class Employee protected String name,
address, phone, ID protected double salary
public Employee (String name, String address,
String phone, String ID, double salary)
this.name name this.address address
this.phone phone this.payRate payRate
this.ID ID // constructor Employee
public double pay () return salary //
method pay public void print ()
System.out.println (name " " ID)
System.out.println (address)
System.out.println (phone) // class
Employee
74
class Manager extends Employee private double
bonus public Manager (String name, String
address, String phone, String ID,
double pay) super (name, nddress, phone, ID,
pay) // call parents constructor bonus
0 // bonus yet to be awarded public
void awardBonus (double bonus) this.bonus
bonus public double pay () // managers
need special way to count pay! double pay
super.pay() bonus // call parents method
bonus 0 return pay
75
Class Hierarchies

• A child class of one parent can be the parent of
  another child, forming class hierarchies

76
Class Hierarchies

• Two children of the same parent are called
  siblings
• Good class design puts all common features as
  high in the hierarchy as is reasonable
• Class hierarchies often have to be extended and
  modified to keep up with changing needs
• There is no single class hierarchy that is
  appropriate for all situations
• See Accounts2.java

12
77
class Accounts2 public static void main
(String args) SavingsAccount savings
new SavingsAccount (4321, 5028.45,
0.02) BonusSaverAccount bigSavings
new BonusSaverAccount (6543, 1475.85, 0.02)
CheckingAccount checking new
CheckingAccount (9876, 269.93, savings)
savings.deposit (148.04)
bigSavings.deposit (41.52)
savings.withdrawal (725.55)
bigSavings.withdrawal (120.38)
checking.withdrawal (320.18) // method
main // class Accounts2
78
class BankAccount protected int account
protected double balance public BankAccount
(int accountNum, double initialBalance)
account accountNum balance
initialBalance public void deposit
(double amount) balance amount
// method deposit public boolean withdrawal
(double amount) boolean result false
if (amount gt balance) System.out.println
("Insufficient funds.") else balance -
amount System.out.println ("New
balance " balance) result
true return result //
class BankAccount
79
class SavingsAccount extends BankAccount
protected double rate public SavingsAccount
(int accountNum, double initialBalance,
double interestRate) super (accountNum,
initialBalance) rate interestRate
// constructor SavingsAccount public void
addInterest () balance balance rate
// method addInterest // class SavingsAccount
80
class BonusSaverAccount extends SavingsAccount
private final int PENALTY 25 private
final double BONUSRATE 0.03 public
BonusSaverAccount (int accountNum,
double initialBalance, double interestRate)
super (accountNum, initialBalance,
interestRate) // constructor
SuperSaverAccount public boolean withdrawal
(double amount) return super.withdrawal
(amountPENALTY) // method withdrawal
public void addInterest () balance
balance (rate BONUSRATE) // method
addInterest
81
class CheckingAccount extends BankAccount
private SavingsAccount overdraft public
CheckingAccount (int accountNum, double
initialBalance, SavingsAccount protection)
super (accountNum, initialBalance)
overdraft protection // constructor
CheckingAccount public boolean withdrawal
(double amount) boolean result false
if ( ! super.withdrawal (amount) )
System.out.println ("Using overdraft...")
if ( ! overdraft.withdrawal (amount - balance)
) System.out.println ("Overdraft
source insufficient.") else
balance 0 System.out.println ("New
balance on account "
account " " balance) result
true return result
// class CheckingAccount
82
The Object Class

• A class called Object is defined in the java.lang
  package of the Java standard class library
• All objects are derived from the Object class
• If a class is not explicitly defined to be the
  child of an existing class, it is assumed to be
  the child of the Object class
• The Object class is therefore the ultimate root
  of all class hierarchies
• The Object class contains a few useful methods,
  such as toString(),equals(), hashCode() which are
  inherited by all classes
• You may choose to override equals and/or toString
  to define equality/toString in your way.

13
83
import java.awt.Point class TestToString
public static void main (String args)
Integer n new Integer (25) Point p
new Point (0, 0) A a new
A() System.out.println ( n.toString() )
System.out.println ( p.toString() )
System.out.println ( a.toString() ) //
method main // class TestToString class A
public String toString() return "I am
AnyClass" // method toString // class
AnyClass
84
Abstract Classes revisted

• An abstract class is a placeholder in a class
  hierarchy that represents a generic concept
• An abstract class cannot be instantiated
• We use the modifier abstract on the class header
  to declare a class as abstract
• An abstract class often contains abstract methods
  (like an interface does), though it doesnt have
  to

85
Abstract Classes

• The child of an abstract class must override the
  abstract methods of the parent, or it too will be
  considered abstract
• An abstract method cannot be defined as final
  (because it must be overridden) or static
  (because it has no definition yet)
• The use of abstract classes is a design decision
  it helps us establish common elements in a class
  that is too general to instantiate

86
References and Inheritance

• An object reference can refer to an object of its
  class, or to an object of any class related to it
  by inheritance
• For example, if the Holiday class is used to
  derive a child class called Christmas, then a
  Holiday reference could actually be used to point
  to a Christmas object

Holiday day day new Christmas()
87
References and Inheritance

• Assigning a descendant class instance to an
  ancestor reference is considered to be a widening
  conversion, and can be performed by simple
  assignment
• Assigning an ancestor object to a subclass
  reference can also be done, but it is considered
  to be a narrowing conversion and must be done
  with a cast
• The widening conversion is the most useful

88
Polymorphism

• A polymorphic reference is one which can refer to
  one of several possible methods.
• Same invocation expression(say o.m()), different
  methods actually called.
• Suppose the Holiday class has a method called
  celebrate, and the Christmas class overrode it
• Now consider the following invocation
• day.celebrate()
• If day refers to a Holiday object, it invokes
  Holiday's version of celebrate if it refers to
  a Christmas object, it invokes that version

16
89
Polymorphism

• In general, it is the type of the object being
  referenced, not the reference type, that
  determines which method is invoked
• Note that, if an invocation is in a loop, the
  exact same line of code could execute different
  methods at different times
• Polymorphic references are therefore resolved at
  run-time, not during compilation

17
90
Polymorphism

• Note that, because all classes inherit from the
  Object class, an Object reference can refer to
  any type of object
• A Vector is designed to store Object references
• The instanceOf operator can be used to determine
  the class from which an object was created
• See Variety.java

18
91
import java.awt.Point import
java.util.Vector class MyVariety public
static void main (String args) Vector
collector new Vector() Integer num1
new Integer (10) collector.addElement (num1)
Point origin new Point (0, 0)
collector.addElement (origin) Integer num2
new Integer (37)collector.addElement (num2)
Point cornernew Point (12,
45)collector.addElement (corner) int
temp Object something for (int
count0 count lt collector.size() count)
something collector.elementAt (count)
if (something instanceof Integer)
temp ((Integer)something).intValue() 20
System.out.println (something " 20
" temp) else
System.out.println ("Point " something)

92
Polymorphism via Inheritance

• Consider the following class hierarchy

93
class Firm2 public static void main
(String args) Staff personnel new
Staff() personnel.payday()
94
class Staff StaffMember staffList new
StaffMember6 public Staff()
staffList0 new Executive ("Sam", "123 Main
Line", "555-0469",
"123-45-6789",
1923.07) staffList1 new Employee
("Carla", "456 Off Line",
"555-0101", "987-65-4321", 846.15)
staffList2 new Employee ("Woody", "789 Off
Rocker", "555-0000", "010-20-3040",
769.23) staffList3 new Hourly ("Diane",
"678 Fifth Ave.", "555-0690",
"958-47-3625", 8.55) staffList4 new
Volunteer ("Norm", "987 Suds Blvd.",
"555-8374") staffList5 new Volunteer
("Cliff", "321 Duds Lane", "555-7282")
((Executive)staffList0).awardBonus (5000)
((Hourly)staffList3).addHours (40) //
constructor Staff
95
public void payday() double amount
for (int count0 count lt staffList.length
count) staffListcount.print()
amount staffListcount.pay() if
(amount 0.0) System.out.println
("Thanks!") else System.out.println
("Paid " amount)
System.out.println ("")
// method payday // class Staff
96
class StaffMember protected String name,
address, phone public StaffMember (String
empName, String empAddress, String
empPhone) name empName address
empAddress phone empPhone //
constructor StaffMember public double pay()
return 0.0 // default pay method
public void print() System.out.println
("Name " name) System.out.println
("Address " address) System.out.println
("Phone " phone) // class StaffMember
97
class Volunteer extends StaffMember public
Volunteer (String empName, String empAddress,
String empPhone) super (empName,
empAddress, empPhone) // constructor
Volunteer public double pay() return
0.0 // method pay // class Volunteer
98
class Employee extends StaffMember protected
String ID protected double payRate public
Employee (String empName, String empAddress,
String empPhone, String empSsnumber, double
empRate) super (empName, empAddress,
empPhone) this.ID ID payRate
empRate // constructor Employee public
double pay () return payRate // method pay
public void print () super.print()
System.out.println (ID number " ID)
System.out.println ("Pay rate " payRate)
// method print // class Employee
99
class Executive extends Employee private
double bonus public Executive (String name,
String addr, String phone, String ID,
double pay) super (name, addr, phone, ID,
pay) bonus 0 // bonus yet to be
awarded // constructor Executive public
void awardBonus (double bonus) this.bonus
bonus // method awardBonus public
double pay () double pay super.pay()
bonus bonus 0 return pay
// method pay public void print ()
super.print() System.out.println ("Current
bonus " bonus) // method print
100
class Hourly extends Employee private int
hoursWorked public Hourly (String name,
String addr, String phone, String ID,
double hrRate) super (name, address,
phone, ID, hrRate) hoursWorked 0
public void addHours (int moreHours)
hoursWorked moreHours // method
addHours public double pay () return
payRate hoursWorked // method pay
public void print () super.print()
System.out.println ("Current hours "
hoursWorked) // method print // class
Hourly
101
Summary for inheritance

• Inheritance reuse the existing objects (is-a
  relation)
• Protect modifier better encapsulation
• Use super to invoke parents methods.
• Overriding methods and overloaded methods
• All Java classes inherit from object class
• Polymorphism which overriding method is invoked
  
• based on the objects type
• Widening narrowing

102
Interfaces

• A Java interface is a collection of abstract
  methods and constants
• An abstract method is a method header without a
  method body (i.e., no implementation)
• An abstract method in an interface can be
  declared using the modifier abstract, but because
  all methods in an interface are abstract, it is
  usually left off.
• cf abstract methods in an abstract class must be
  declared explicitly using the abstract modifier.
• An interface is used to formally define a set of
  methods that a class will implement

103
Interfaces
None of the methods in an interface are given a
definition (body)
public interface Doable public void
doThis() public int doThat() public void
doThis2 (float value, char ch) public boolean
doTheOther (int num)
104
Interfaces

• An interface cannot be instantiated
• Doable d new Doable() // error
• Like a class, a user-defined interface can be
  used as the type of variables.
• Doable a, b
• Methods in an interface have public visibility by
  default
• A class formally implements an interface by
• stating so in the class header
• providing implementations for each abstract
  method in the interface
• If a class asserts that it implements an
  interface, it must define all methods in the
  interface or the compiler will produce errors.

105
Interfaces
public class CanDo implements Doable public
void doThis () // whatever
public void doThat () // whatever
// etc.
106
Interfaces

• A class can implement more than one interfaces
• See Speaker.java (page 236)
• See Philosopher.java (page 237)
• See Dog.java (page 238)
• The interfaces are listed in the implements
  clause, separated by commas
• The class must implement all methods in all
  interfaces listed in the header

107
Interfaces

• An interface can be implemented by multiple
  classes
• Each implementing class can provide their own
  unique version of the method definitions
• An interface is not part of the class hierarchy
• A class can be derived from a base class and
  implement one or more interfaces

9
108
Interface constants

• Unlike interface methods, interface constants
  require nothing special of the implementing class
  
• Constants in an interface can be used in the
  implementing class as if they were declared
  locally
• This feature provides a convenient technique for
  distributing common constant values among
  multiple classes

10
109
Extending Interfaces

• An interface can be derived from another
  interface, using the extends reserved word
• The child interface inherits the constants and
  abstract methods of the parent
• Note that the interface hierarchy and the class
  hierarchy are distinct
• Unlike class hierarchy, an interface can extend
  more than one interfaces.
• public interface Transformable extends Scable,
  Translatable, Rotatable
• A class that implements an interface must define
  also all methods in all ancestors of the
  interface.

11
110
An interface Example
interface Printable public String name()
public String print() // public can be
omitted // interface Printable class
PrintLogger public void log (Printable file)
System.out.println (file.name() " "
file.print()) // method log // class
PrintLogger
111
class File protected String id
protected int size public File (String id,
int size) this.id id this.size
size // constructor File public String
name() return id // method name // class
File class TextFile extends File implements
Printable protected String text public
TextFile (String id, int size, String contents)
super(id, size) text contents
// constructor TextFile public String print()
return text // class TextFile
112
class BinaryFile extends File protected
byte data public BinaryFile (String id, int
size, byte data) super(id, size)
this.data data // constructor
BinaryFile // class BinaryFile class ImageFile
extends BinaryFile implements Printable
public ImageFile (String id, int size, byte
data) super(id, size, data) //
constructor ImageFile public String print()
return new String (data) // class Image_File
113
public class Printer public static void main
(String args) byte logoData 41,
42, 49, 44 TextFile report new
TextFile (Reprot 1",
1024, "One two three ") ImageFile logo
new ImageFile(Picture 1", 4, logoData)
PrintLogger daily new PrintLogger()
daily.log (report) daily.log (logo)

114
Marker interface

• An interface without including any method.
• useful for providing additional information
  about an object.
• EX
• java.lang.Serializable
• java.lang.Cloneable
• java.rmi.Remote
• Ex
• Object obj
• Object copy
• copy o.clone() // may raise CloneNotSupportedExc
  eptionexception
• if(obj instanceof Cloneable) copy o.clone()
• else copy null

115
Polymorphism via Interfaces

• An interface name can be used as the type of an
  object reference variable
• Doable obj
• The obj reference can be used to point to any
  object of any class that implements the Doable
  interface
• The version of doThis that the following line
  invokes depends on the type of object that obj is
  referring to
• obj.doThis()

116
Polymorphism via Interfaces

• That reference is polymorphic, which can be
  defined as "having many forms"
• That line of code might execute different methods
  at different times if the object that obj points
  to changes
• See PrinterLogger.java(slide 106)
• Note that polymorphic references must be resolved
  at run time this is called dynamic binding
• Careful use of polymorphic references can lead to
  elegant, robust software designs

117
Some interfaces used in core java classes

• The Java standard class library contains many
  interfaces that are helpful in certain situations
• The Comparable interface contains an abstract
  method called compareTo, which is used to compare
  two objects
• pubilc iterface Comparable
• public abstract int comparedTo(Object)
  
• Ex int rlt x.comparedTo(y)
• if(rlt lt 0) // x lt y
• else if (rltgt0) // x gt y
• else // rlt 0 means x is equal to y.
• The String class implements Comparable which
  gives us the ability to put strings in
  alphabetical order

118
The Iterator and Enumeration interface

• The java.util.Iterator/Enumeration interface
  contain methods that allow the user to move
  through a collection of objects easily
• public interface Iterator
• public abstract boolean hasNext()
• public abstract Object next()
• public abstract void remove()
• pubic interface Enumeration
• public boolean hasMoreElements()
• pubic Object nextElement()
• Ex Object obj // obj is an object
  implementing Iterator
• for(Iterator i (Iterator)obj
  i.hasNext() )
• processing(i.next())

119
Events skipped

• An event is an object that represents some
  activity to which we may want to respond
• For example, we may want our program to perform
  some action when the following occurs
• the mouse is moved
• a mouse button is clicked
• the mouse is dragged
• a graphical button is clicked
• a keyboard key is pressed
• a timer expires
• Of