Programming2(CS272)

Lecture 5

1
lect4
 Object Casting
Syntax:
To cast the reference a1 to be of type B Casting checked twice
A a1=new B(); At compilation : class B is sub class of A
……. (otherwise compile error)
………. At runtime: a1 points to an object of class B
B b=(B)a1; //casting (otherwise runtime error:classCastExeption)

Instanceof Operator
Instanceof is a a boolean java operator that returns true or false
Usage: reference instanceof class
returns true if the reference points to an object of this class or any of its subclasses
Usage: reference instanceof interface
returns true if the reference points to an object of a class implementing the interface

class A class B extends A B b1=new B();

{ { System.out.println(b1 instanceof B);//true
} } System.out.println(b1 instanceof A);//true
05:26 2
 Object Casting
Syntax:
To cast the reference a1 to be of type B Casting checked twice
A a1=new B(); At compilation : class B is sub class of A
……. (otherwise compile error)
………. At runtime: a1 points to an object of class B
B b=(B)a1; //casting (otherwise runtime error:classCastExeption)

Instanceof Operator
Instanceof is a a boolean java operator that returns true or false
Usage: reference instanceof class
returns true if the reference points to an object of this class or any of its subclasses
Usage: reference instanceof interface
returns true if the reference points to an object of a class implementing the interface

class A class B extends A B b1=new B();

{ { System.out.println(b1 instanceof B);//true
} } System.out.println(b1 instanceof A);//true
05:26 3
Example public class Test {
public abstract class Shape{ public static void main(String[] args) {
public abstract double getArea(); Shape shape1 = new Circle(2);
} Shape shape2 = new Rectangle(3, 4);
displayObject(shape1);
public class Circle extends Shape{ displayObject(shape2);
private double radius; }
public Circle( double radius) public static void displayObject(Shape shape) {
{
System.out.println(“area=“+shape.getArea());
this.radius=radius;
}
public double getRadius(){return radius;} if (shape instanceof Circle) {
Public double getArea(){ Circle c=(Circle)shape;
return 3.14*radius*radius;} System.out.println("The circle radius is "
} +c.getRadius());
public class Rectangle extends Shape{ }
private double width; else if (shape instanceof Rectangle) {
private double height; Rectangle rect=(Rectangle)shape;
public Rectangle(double width,double height){ System.out.println("The rectangle Width is "
this .width=width; +(rect.getWidth()));
this .height=height;
}
System.out.println("The rectangle height is "
public double getWidth(){return width;} +(rect.getHeight()));
public double getHeight(){return height;} }
public double getArea() }
{return width*height;}
05:26 } 4
}
 object.equals()
Method equals in class Object offers only a trivial comparison, as it compares whether the
2 reference for the 2 objects are equal and not the contents of the 2 objects.

public class A{
i=3
private int i;
j=4
private int j;
public A(int i,int j)
{
a1
this.i=i; i=3
this.j=j; j=4
}
}
a2
class Test
{
public static void main (String[] arg){ false
A a1=new A(3,4);
A a2=new A(3,4);
System.out.println(a1.equals(a2));
}}
5
 Overriding object.equals()

class A
{
int i; class Test
int j; {
A(int i,int j)
public static void main (String[] arg)
{
{
A a1=new A(3,4);
this.i=i;
A a2=new A(3,4);
this.j=j;
System.out.println(a1.equals(a2));
}
}
}
public boolean equals(Object obj)
{ true
A a2=(A)obj;
if ( (i==a2.i)&&(j==a2.j) )
return true;
else
return false;
}}
6
 Case Study: Simple Payroll System
Consider the class hierarchy shown in Figure. The classes in it
represent various types of employees that might be employed at a
particular company..

StaffMember

Volunteer Employee

Executive Hourly
05:26 7
//********************************************************************
// StaffMember.java Author: Lewis/Loftus
//
// Represents a generic staff member.
//********************************************************************

abstract public class StaffMember

{
protected String name;
protected String address;
protected String phone;

//-----------------------------------------------------------------
// Constructor: Sets up this staff member using the specified
// information.
//-----------------------------------------------------------------
public StaffMember (String eName, String eAddress, String ePhone)
{
name = eName;
address = eAddress;
phone = ePhone;
}

continue
continue

//-----------------------------------------------------------------
// Returns a string including the basic employee information.
//-----------------------------------------------------------------
public String toString()
{
String result = "Name: " + name + "\n";

result += "Address: " + address + "\n";

result += "Phone: " + phone;

return result;
}

//-----------------------------------------------------------------
// Derived classes must define the pay method for each type of
// employee.
//-----------------------------------------------------------------
public abstract double pay();
}
//********************************************************************
// Volunteer.java Author: Lewis/Loftus
//
// Represents a staff member that works as a volunteer.
//********************************************************************

public class Volunteer extends StaffMember

{
//-----------------------------------------------------------------
// Constructor: Sets up this volunteer using the specified
// information.
//-----------------------------------------------------------------
public Volunteer (String eName, String eAddress, String ePhone)
{
super (eName, eAddress, ePhone);
}

//-----------------------------------------------------------------
// Returns a zero pay value for this volunteer.
//-----------------------------------------------------------------
public double pay()
{
return 0.0;
}
}
//********************************************************************
// Employee.java Author: Lewis/Loftus
//
// Represents a general paid employee.
//********************************************************************

public class Employee extends StaffMember

{
protected String socialSecurityNumber;
protected double payRate;

//-----------------------------------------------------------------
// Constructor: Sets up this employee with the specified
// information.
//-----------------------------------------------------------------
public Employee (String eName, String eAddress, String ePhone,
String socSecNumber, double rate)
{
super (eName, eAddress, ePhone);

socialSecurityNumber = socSecNumber;
payRate = rate;
}

continue
continue

//-----------------------------------------------------------------
// Returns information about an employee as a string.
//-----------------------------------------------------------------
public String toString()
{
String result = super.toString();

result += "\nSocial Security Number: " + socialSecurityNumber;

return result;
}

//-----------------------------------------------------------------
// Returns the pay rate for this employee.
//-----------------------------------------------------------------
public double pay()
{
return payRate;
}
}
//********************************************************************
// Executive.java Author: Lewis/Loftus
//
// Represents an executive staff member, who can earn a bonus.
//********************************************************************

public class Executive extends Employee

{
private double bonus;

//-----------------------------------------------------------------
// Constructor: Sets up this executive with the specified
// information.
//-----------------------------------------------------------------
public Executive (String eName, String eAddress, String ePhone,
String socSecNumber, double rate)
{
super (eName, eAddress, ePhone, socSecNumber, rate);

bonus = 0; // bonus has yet to be awarded

}

continue
continue

//-----------------------------------------------------------------
// Awards the specified bonus to this executive.
//-----------------------------------------------------------------
public void awardBonus (double execBonus)
{
bonus = execBonus;
}

//-----------------------------------------------------------------
// Computes and returns the pay for an executive, which is the
// regular employee payment plus a one-time bonus.
//-----------------------------------------------------------------
public double pay()
{
double payment = super.pay() + bonus;

bonus = 0;

return payment;
}
}
//********************************************************************
// Hourly.java Author: Lewis/Loftus
//
// Represents an employee that gets paid by the hour.
//********************************************************************

public class Hourly extends Employee

{
private int hoursWorked;

//-----------------------------------------------------------------
// Constructor: Sets up this hourly employee using the specified
// information.
//-----------------------------------------------------------------
public Hourly (String eName, String eAddress, String ePhone,
String socSecNumber, double rate)
{
super (eName, eAddress, ePhone, socSecNumber, rate);

hoursWorked = 0;
}

continue
continue

//-----------------------------------------------------------------
// Adds the specified number of hours to this employee's
// accumulated hours.
//-----------------------------------------------------------------
public void addHours (int moreHours)
{
hoursWorked += moreHours;
}

//-----------------------------------------------------------------
// Computes and returns the pay for this hourly employee.
//-----------------------------------------------------------------
public double pay()
{
double payment = payRate * hoursWorked;

hoursWorked = 0;

return payment;
}

continue
continue

//-----------------------------------------------------------------
// Returns information about this hourly employee as a string.
//-----------------------------------------------------------------
public String toString()
{
String result = super.toString();

result += "\nCurrent hours: " + hoursWorked;

return result;
}
}