chapter 10 polymorphismricci/cp/slides/chap10-v9.pdfpolymorphism via inheritance •let's look...

Copyright © 2017 Pearson Education, Inc.

Chapter 10Polymorphism

Java Software SolutionsFoundations of Program Design

9th Edition

John LewisWilliam Loftus

The measure of intelligence is the abilityto change.A. Einstein

Polymorphism• Polymorphism is an object-oriented concept that

allows us to create versatile software designs

• Chapter 10 focuses on:– defining polymorphism and its benefits– using inheritance to create polymorphic references– using interfaces to create polymorphic references– using polymorphism to implement sorting and searching

algorithms– property binding– additional GUI components


Outline

Late Binding

Polymorphism via Inheritance

Polymorphism via Interfaces

Sorting

Searching

Properties

Sliders

Spinners


Outline

Late Binding



Sorting

Searching

Event Processing Revisited

File Choosers and Color Choosers

Sliders


Binding• Consider the following method invocation:

obj.doIt();

• At some point, this invocation is bound to the definition of the method that it invokes

• If this binding occurred at compile time, then that line of code would call the same method every time

• However, Java defers method binding until run time -- this is called dynamic binding or late binding


Polymorphism• The term polymorphism literally means "having

many forms"

• A polymorphic reference is a variable that can refer to different types of objects at different points in time

• The method called through a polymorphic reference can change from one invocation to the next

• All object references in Java are potentially polymorphic (for instance?)


Polymorphism• Suppose we create the following reference variable:

Occupation job;

• This reference can point to an Occupation object, or to any object of any compatible type

• This compatibility can be established using inheritance or using interfaces

• Careful use of polymorphic references can lead to elegant, robust software designs


Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


References and Inheritance• An object reference (declared to be of a type X)

can refer to an object of any class related to X by inheritance

• For example, if Holiday is the superclass of Christmas, then a Holiday reference could be used to refer to a Christmas object

Holiday day;day = new Christmas();

Holiday

Christmas


References and Inheritance• These type compatibility rules are just an extension

of the is-a relationship established by inheritance

• Assigning a Christmas object to a Holiday reference is fine because Christmas is-a Holiday

• Assigning a child object to a parent reference can be performed by simple assignment


Holiday day;day = new Christmas();

References and Inheritance• Assigning a parent object to a child reference can

be done also, but must be done with a cast

• After all, Christmas is a holiday but not all holidays are Christmas

• You must know at compile time that the dayreference is actually referring to a Christmasobject.


Holiday day = new Christmas();Christmas mas = (Christmas) day;

Polymorphism via Inheritance• Now suppose the Holiday class has a method

called celebrate, and Christmas overrides it

• What method is invoked by the following?Holiday day = new Christmas();day.celebrate();

• The type of the object being referenced, not the reference type, determines which method is invoked

• If day refers to a Holiday object, it invokes the Holiday version of celebrate; if it refers to a Christmas object, it invokes that version

Polymorphism via Inheritance• Note that the compiler restricts invocations

based on the type of the reference• So if Christmas had a method called getTree

that Holiday didn't have, the following would cause a compiler error:

Holiday day = new Christmas();day.getTree(); // compiler error

• Remember, the compiler doesn't "know" which type of holiday is being (dynamically) referenced

• A cast can be used to allow the call (if this is a method of Christmas):

((Christmas)day).getTree();

Quick Check


If MusicPlayer is the parent of CDPlayer, are the following assignments valid?

MusicPlayer mplayer = new CDPlayer();

CDPlayer cdplayer = new MusicPlayer();

Quick Check


If MusicPlayer is the parent of CDPlayer, are the following assignments valid?

MusicPlayer mplayer = new CDPlayer();

CDPlayer cdplayer = new MusicPlayer();

Yes, because a CDPlayer is-a MusicPlayer

No, you'd have to use a cast ((CDPlayer) new MusicPlayer()) and you shouldn'tknowingly assign a super class object to asubclass reference.

Quizpublic class BaseClass {

public void methodToOverrid() {System.out.println ("I'm the BaseClass");

}}public class DerivedClass extends BaseClass {

public void methodToOverrid() {System.out.println ("I'm the derivedClass");

}}public class TestMethod {

public static void main (String args []) {BaseClass obj1 = new BaseClass(); BaseClass obj2 = new DerivedClass(); obj1.methodToOverrid(); obj2.methodToOverrid();

}}

What is this printing?

Quizpublic class BaseClass {

public void methodToOverride() {System.out.println ("I'm the BaseClass");

}}public class DerivedClass extends BaseClass {

public void methodToOverride() {System.out.println ("I'm the derivedClass");

}}public class TestMethod {

public static void main (String args []) {BaseClass obj1 = new BaseClass(); BaseClass obj2 = new DerivedClass(); obj1.methodToOverride(); obj2.methodToOverride();

}}

What is this printing?

I'm the BaseClassI'm the DerivedClass

QuizStudent, Employee and Retired are all extended classes of Person, and all four classes have different implementations of the method getMoney Person p = new Person(...);int m1 = p.getMoney( ); // assignment 1p = new Student(...);int m2 = p.getMoney( ); // assignment 2if (m2 < 100000)

p = new Employee(...);else if (m1 > 50000)

p = new Retired(...);int m3 = p.getMoney( ); // assignment 3

getMoney is a reference to XXX's getMoney method.What is the XXX class in assignments 1, 2 and 3?

QuizPerson p = new Person(...);int m1 = p.getMoney( ); // assignment 1p = new Student(...);int m2 = p.getMoney( ); // assignment 2if (m2 < 100000)

p = new Employee(...);else if (m1 > 50000)

p = new Retired(...);int m3 = p.getMoney( ); // assignment 3

getMoney is a reference to XXX's getMoney method.What is the XXX class in assignments 1, 2 and 3? 1) Person, 2) Student, and 3) Who knows? It may be Employee, Student or Retired depending on m1 and m2 values.

Polymorphism via Inheritance• Consider the following class hierarchy:

StaffMember

Executive Hourly

Volunteer Employee


Abstract Classpublic abstract double pay();

Polymorphism via Inheritance• Let's look at an example that pays a set of diverse

employees using a polymorphic method

• See Firm.java (containing the main)• See Staff.java (a container for staff members)• See StaffMember.java (a generic staff member)• See Volunteer.java• See Employee.java• See Executive.java• See Hourly.java



//********************************************************************// Firm.java Author: Lewis/Loftus//// Demonstrates polymorphism via inheritance.//********************************************************************

public class Firm{

//-----------------------------------------------------------------// Creates a staff of employees for a firm and pays them.//-----------------------------------------------------------------public static void main (String[] args){

Staff personnel = new Staff();

personnel.payday();}

}


//********************************************************************// Firm.java Author: Lewis/Loftus//// Demonstrates polymorphism via inheritance.//********************************************************************

public class Firm{

//-----------------------------------------------------------------// Creates a staff of employees for a firm and pays them.//-----------------------------------------------------------------public static void main (String[] args){

Staff personnel = new Staff();

personnel.payday();}

}

OutputName: SamAddress: 123 Main LinePhone: 555-0469Social Security Number: 123-45-6789Paid: 2923.07-----------------------------------Name: CarlaAddress: 456 Off LinePhone: 555-0101Social Security Number: 987-65-4321Paid: 1246.15-----------------------------------Name: WoodyAddress: 789 Off RockerPhone: 555-0000Social Security Number: 010-20-3040Paid: 1169.23-----------------------------------

Output (continued)Name: DianeAddress: 678 Fifth Ave.Phone: 555-0690Social Security Number: 958-47-3625Current hours: 40Paid: 422.0-----------------------------------Name: NormAddress: 987 Suds Blvd.Phone: 555-8374Thanks!-----------------------------------Name: CliffAddress: 321 Duds LanePhone: 555-7282Thanks!-----------------------------------


//********************************************************************// Staff.java Author: Lewis/Loftus//// Represents the personnel staff of a particular business.//********************************************************************

public class Staff{

private StaffMember[] staffList;

//-----------------------------------------------------------------// Constructor: Sets up the list of staff members.//-----------------------------------------------------------------public Staff (){

staffList = new StaffMember[6];

continue


continue

staffList[0] = new Executive ("Sam", "123 Main Line","555-0469", "123-45-6789", 2423.07);

staffList[1] = new Employee ("Carla", "456 Off Line","555-0101", "987-65-4321", 1246.15);

staffList[2] = new Employee ("Woody", "789 Off Rocker","555-0000", "010-20-3040", 1169.23);

staffList[3] = new Hourly ("Diane", "678 Fifth Ave.","555-0690", "958-47-3625", 10.55);

staffList[4] = new Volunteer ("Norm", "987 Suds Blvd.","555-8374");

staffList[5] = new Volunteer ("Cliff", "321 Duds Lane","555-7282");

((Executive)staffList[0]).awardBonus (500.00);

((Hourly)staffList[3]).addHours (40);}

continue


continue

//-----------------------------------------------------------------// Pays all staff members.//-----------------------------------------------------------------public void payday (){

double amount;

for (int count=0; count < staffList.length; count++){

System.out.println (staffList[count]);

amount = staffList[count].pay(); // polymorphic

if (amount == 0.0)System.out.println ("Thanks!"); // it is a volunteer

elseSystem.out.println ("Paid: " + amount);

System.out.println ("-----------------------------------");}

}}


//********************************************************************// 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,


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; // payRate + 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,


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;}

}

Quiz• If MusicPlayer is the parent of CDPlayer, is the

following sequence of statements legal?


MusicPlayer mplayer = new MusicPlayer();

CDPlayer cdplayer = new CDPlayer();

cdplayer = mplayer;



• NO because mplayer is declared to be of type MusicPlayer and cdplayer is declared to be CDPlayer and a MusicPlayer is not a CDPlayer.




cdplayer = mplayer;






cdplayer = (CDPlayer)mplayer;



• YES but you will get a run time error when you will execute that because the mplayer variable does not refer to a CDPlayer.




cdplayer = (CDPlayer)mplayer;

Quiz• How is overriding related to polymorphism?


Quiz• How is overriding related to polymorphism?

• When a child class overrides the definition of a parent's method, TWO definitions of that method exist. If a polymorphic reference is used to invoke the method, then the version that is invoked is determined by the type of the object that is referenced by the polymorphic reference variable.


Quizpublic class Inherit {class Figure {void display() {System.out.println("F");

}}class Rectangle extends Figure {void display() {System.out.println("R");

}}class Box extends Figure {

void display() {System.out.println("B");}

}...

...Inherit() {Figure f = new Figure();Rectangle r = new Rectangle();Box b = new Box();f.display();f = r;f.display();f = b;f.display();

}

public static voidmain(String[] args) {

new Inherit();}

}

What is printed by the following code?

Quizpublic class Inherit {class Figure {void display() {System.out.println("F");

}}class Rectangle extends Figure {void display() {System.out.println("R");

}}class Box extends Figure {

void display() {System.out.println("B");}

}...

...Inherit() {Figure f = new Figure();Rectangle r = new Rectangle();Box b = new Box();f.display();f = r;f.display();f = b;f.display();

}

public static voidmain(String[] args) {

new Inherit();}

}

What is printed by the following code? FRB

Quizpublic class Inherit {

abstract class Stone {protected float weight = 13;protected int value = 4;abstract public String

toString( );} class Aggregate {

protected int numKind;}class Granite extends Aggregate{

Granite( ) {weight = 25; numKind = 7;

}public String toString( ) {

return "Granite: weight= " + weight + " value="+ value + " numKind="+ numKind;

}}

Inherit( ) {Granite g = new Granite( );System.out.println(g);

}

public static void main(String[ ] args) {

new Inherit( );}

}

There is a mistake in Aggregate class. This program must printGranite: weight=25.0 value=4 numKind=7What is the solution?

A) abstract class Aggregate { B) abstract class Aggregate extends Granite { C) abstract class Aggregate extends Stone { D) class Aggregate extends Stone { E) none of the above

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Polymorphism via Interfaces• Interfaces can be used to set up polymorphic

references as well• Suppose we declare an interface called Speaker

as follows:


public interface Speaker{

public void speak();public void announce (String str);

}

Polymorphism via Interfaces• An interface name can be used as the type of an

object reference variable:Speaker current;

• The current reference can be used to point to anyobject of any class that implements the Speakerinterface

• The version of speak invoked by the following line depends on the type of object that current is referencing:

current.speak();


Polymorphism via Interfaces• Now suppose two classes, Philosopher and Dog, both implement the Speaker interface, providing distinct versions of the speak method

• In the following code, the first call to speak invokes one version and the second invokes another:

Speaker guest = new Philospher();guest.speak();guest = new Dog();guest.speak();


Polymorphism via Interfaces• As with class reference types, the compiler will

restrict invocations to methods in the interface

• For example, even if Philosopher also had a method called pontificate, the following would still cause a compiler error:

Speaker special = new Philosopher();special.pontificate(); // compiler error

• Remember, the compiler bases its rulings on the type of the reference


Quick Check


Would the following statements be valid?

Speaker first = new Dog();Philosopher second = new Philosopher();second.pontificate();first = second;

Quick Check



Speaker first = new Dog();Philosopher second = new Philosopher();second.pontificate();first = second;

Yes, all assignments and method calls arevalid as written

Quick Check



Speaker first = new Dog();Philosopher second = new Philosopher();first = second;second.pontificate();first.pontificate();

Quick Check



Speaker first = new Dog();Philosopher second = new Philosopher();first = second;second.pontificate();first.pontificate();

No, first is is declared to be a Speaker, so we cannot invoke the Philosopher method pontificate() though first.

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Sorting• Sorting is the process of arranging a list of items in

a particular order

• The sorting process is based on specific criteria:– sort test scores in ascending numeric order– sort a list of people alphabetically by last name

• There are many algorithms, which vary in efficiency, for sorting a list of items

• We will examine two specific algorithms: – Selection Sort– Insertion Sort


Selection Sort• The strategy of Selection Sort:

– select the min value and put it in its final place in the list

– repeat for all other values

• In more detail:

– find the smallest value in the list– switch it with the value in the first position– find the next smallest value in the list– switch it with the value in the second position– repeat until all values are in their proper places


Selection Sort


Swapping• The processing of the selection sort algorithm

includes the swapping of two values

• Swapping requires three assignment statements and a temporary storage location

• To swap the values of first and second:

temp = first;first = second;second = temp;


Quiz• Swap the first and third entries of the array

int numbers[] = {4, 3, 2, 1};


Quiz• Swap the first and third entries of the array

int numbers[] = {4, 3, 2, 1};

int temp;temp = numbers[0];numbers[0] = numbers[2];numbers[2] = temp;


Polymorphism in Sorting

• Recall that a class that implements the Comparable<T> interface defines a compareTo(T o) method to determine the relative order of its objects

• We can use polymorphism to develop a generic sort for any set of Comparable<T> objects

• The sorting method accepts as a parameter an array of Comparable<T> objects

• That way, one method can be used to sort an array of People, or Books, or whatever


Selection Sort• This technique allows each class to decide for itself

what it means for one object to be less than another

• Let's look at an example that sorts an array of Contact objects

• The selectionSort method is a method in the Sorting<T> class

• See PhoneList.java (containing the main)• See Sorting.java• See Contact.java



public class PhoneList{

//-----------------------------------------------------------------// Creates an array of Contact objects, sorts them, then prints// them.//-----------------------------------------------------------------public static void main (String[] args){

Contact[] friends = new Contact[8];

friends[0] = new Contact ("John", "Smith", "610-555-7384");friends[1] = new Contact ("Sarah", "Barnes", "215-555-3827");friends[2] = new Contact ("Mark", "Riley", "733-555-2969");friends[3] = new Contact ("Laura", "Getz", "663-555-3984");friends[4] = new Contact ("Larry", "Smith", "464-555-3489");friends[5] = new Contact ("Frank", "Phelps", "322-555-2284");friends[6] = new Contact ("Mario", "Guzman", "804-555-9066");friends[7] = new Contact ("Marsha", "Grant", "243-555-2837");

Sorting<Contact> sorts = new Sorting<Contact>();sorts.selectionSort(friends);

for (Contact friend : friends)System.out.println (friend);

}}


public class PhoneList{


Contact[] friends = new Contact[8];



for (Contact friend : friends)System.out.println (friend);

}}

OutputBarnes, Sarah 215-555-3827Getz, Laura 663-555-3984Grant, Marsha 243-555-2837Guzman, Mario 804-555-9066Phelps, Frank 322-555-2284Riley, Mark 733-555-2969Smith, John 610-555-7384Smith, Larry 464-555-3489

The selectionSort method in the Sorting<T>class:


//-----------------------------------------------------------------// Sorts the specified array of objects using the selection// sort algorithm.//-----------------------------------------------------------------public void selectionSort(Comparable<T>[] list){

int min;Comparable<T> temp;

for (int index = 0; index < list.length - 1; index++){

min = index;for (int scan = index + 1; scan < list.length; scan++)

if (list[scan].compareTo((T)list[min]) < 0)min = scan;

// Swap the valuestemp = list[min];list[min] = list[index];list[index] = temp;

}}


//********************************************************************// Contact.java Author: Lewis/Loftus//// Represents a phone contact.//********************************************************************

public class Contact implements Comparable<Contact>{

private String firstName, lastName, phone;

//-----------------------------------------------------------------// Constructor: Sets up this contact with the specified data.//-----------------------------------------------------------------public Contact(String first, String last, String telephone){

firstName = first;lastName = last;phone = telephone;

}

continue


continue

//-----------------------------------------------------------------// Returns a description of this contact as a string.//-----------------------------------------------------------------public String toString(){

return lastName + ", " + firstName + "\t" + phone;}

//-----------------------------------------------------------------// Returns a description of this contact as a string.//-----------------------------------------------------------------public boolean equals(Object other){

return (lastName.equals(((Contact)other).getLastName()) &&firstName.equals(((Contact)other).getFirstName()));

}

continue


continue

//-----------------------------------------------------------------// Uses both last and first names to determine ordering.//-----------------------------------------------------------------public int compareTo(Contact other){

int result;

if (lastName.equals(other.getLastName()))result = firstName.compareTo(other.getFirstName());

elseresult = lastName.compareTo(other.getLastName());

return result;}

continue


continue

//-----------------------------------------------------------------// First name accessor.//-----------------------------------------------------------------public String getFirstName(){

return firstName;}

//-----------------------------------------------------------------// Last name accessor.//-----------------------------------------------------------------public String getLastName(){

return lastName;}

}

Insertion Sort• The strategy of Insertion Sort:

– pick any item and insert it into its proper place in a sorted sublist

– repeat until all items have been inserted

• In more detail:– consider the first item to be a sorted sublist (of one item)– insert the second item into the sorted sublist, shifting the

first item if needed to make room to insert the new one– insert the third item into the sorted sublist (of two items),

shifting items as necessary– repeat until all values are inserted into their proper

positions.


Insertion Sort


1

2

123

4

The insertionSort method in the Sorting<T>class:


//-----------------------------------------------------------------// Sorts the specified array of objects using the insertion// sort algorithm.//-----------------------------------------------------------------public void insertionSort(Comparable<T>[] list){

for (int index = 1; index < list.length; index++){

Comparable<T> key = list[index];int position = index;

// Shift larger values to the rightwhile (position > 0 && key.compareTo((T)list[position-1]) < 0){

list[position] = list[position - 1];position--;

}

list[position] = key;}

}

Comparing Sorts• The Selection and Insertion sort algorithms are

similar in efficiency

• They both have outer loops that scan all elements, and inner loops that compare the value of the outer loop with almost all values in the list

• Approximately n2 number of comparisons are made to sort a list of size n

• We therefore say that these sorts are of order n2

• Exercise: Compare the two sorts when the list is already sorted.


Quiz• Show the sequence of changes the selection and

insertion sort algorithm makes to the following array of numbers– {5 7 1 8 2 4 3}

Write the array content at every iteration of the outer loop.


Quiz• Show the sequence of changes the selection and

insertion sort algorithm makes to the following array of numbers– {5 7 1 8 2 4 3}

5 7 1 8 2 4 31 7 5 8 2 4 31 2 5 8 7 4 31 2 3 8 7 4 51 2 3 4 7 8 51 2 3 4 5 8 71 2 3 4 5 7 8

5 7 1 8 2 4 35 7 1 8 2 4 31 5 7 8 2 4 31 5 7 8 2 4 31 2 5 7 8 4 31 2 4 5 7 8 31 2 3 4 5 7 8

Selection Insertion

yellow means that the value was compared to a target (orange)

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Searching• Searching is the process of finding a target element

within a group of items called the search pool

• The target may or may not be in the search pool

• We want to perform the search efficiently, minimizing the number of comparisons

• Let's look at two classic searching approaches: linear search and binary search

• As we did with sorting, we'll implement the searches with polymorphic Comparable parameters


Linear Search• A linear search begins at one end of a list and

examines each element in turn

• Eventually, either the item is found or the end of the list is encountered


Binary Search• A binary search assumes the list of items in the

search pool is sorted• It eliminates a large part of the search pool with a

single comparison

• A binary search first examines the middle element of the list -- if it matches the target, the search is over

• If it doesn't, only one half of the remaining elements need be searched

• Since they are sorted, the target can only be in one half of the other


Binary Search• The process continues by comparing the middle

element of the remaining viable candidates

• Each comparison eliminates approximately half of the remaining data

• Eventually, the target is found or the data is exhausted


Binary Searching: 7911 28 29 47 53 54 56 70 73 88

compare 79 with the entry in position (0+9)/2 = 4(79 == 53) ---- NO it is larger

11 28 29 47 53 54 56 70 73 88compare 79 with the entry in position (5+9)/2 = 7(79 == 70) ---- NO it is larger

11 28 29 47 53 54 56 70 73 88compare 79 with the entry in position (8+9)/2 = 8(79 == 73) ---- NO it is larger

11 28 29 47 53 54 56 70 73 88compare 79 with the entry in position (9+9)/2 = 9(79 == 88) ---- NO it is larger and there are no more entriesNOT FOUND

Searching• The search methods are implemented as methods

in the Searching<T> class

• See PhoneList2.java• See Searching.java



//********************************************************************// PhoneList2.java Author: Lewis/Loftus//// Driver for testing searching algorithms.//********************************************************************

public class PhoneList2{


Contact test, found;Contact[] friends = new Contact[8];


Searching<Contact> searches = new Searching<Contact>();continue


continue

test = new Contact("Frank", "Phelps", "");found = searches.linearSearch(friends, test);if (found != null)

System.out.println("Found: " + found);else

System.out.println("The contact was not found.");System.out.println();


test = new Contact("Mario", "Guzman", "");found = (Contact) searches.binarySearch(friends, test);if (found != null)


System.out.println("The contact was not found.");}

}


continue

test = new Contact("Frank", "Phelps", "");found = Searching.linearSearch(friends, test);if (found != null)


System.out.println("The contact was not found.");System.out.println();


test = new Contact("Mario", "Guzman", "");found = (Contact) searches.binarySearch(friends, test);if (found != null)


System.out.println("The contact was not found.");}

}

OutputFound: Phelps, Frank 322-555-2284

Found: Guzman, Mario 804-555-9066

The linearSearch method in the Searching<T>class:


//-----------------------------------------------------------------// Searches the specified array of objects for the target using// a linear search. Returns a reference to the target object from// the array if found, and null otherwise.//-----------------------------------------------------------------public T linearSearch(T[] list, T target){

int index = 0;boolean found = false;

while (!found && index < list.length){

if (list[index].equals(target))found = true;

elseindex++;

}

if (found)return list[index];

elsereturn null;

}

The binarySearch method in the Searching<T>class:


//-----------------------------------------------------------------// Searches the specified array of objects for the target using// a binary search. Assumes the array is already sorted in// ascending order when it is passed in. Returns a reference to// the target object from the array if found, and null otherwise.//-----------------------------------------------------------------public Comparable<T> binarySearch(Comparable<T>[] list,

Comparable<T> target){

int min = 0, max = list.length - 1, mid = 0;boolean found = false;

while (!found && min <= max){

mid = (min + max) / 2;if (list[mid].equals(target))

found = true;else

if (target.compareTo((T)list[mid]) < 0)max = mid - 1;

elsemin = mid + 1;

}

continue


continue

if (found)return list[mid];

elsereturn null;

}

Quiz• Given the following list of numbers, how many

elements would be examined (# of calls to equals()) by the linear search to determine if the indicated targets are on the list?– 15 21 4 17 8 27 1 22 43 57 25 7 53 12 16

• a) 17• b) 15• c) 16• d) 45



elements would be examined by the linear search to determine if the indicated targets are on the list?– 15 21 4 17 8 27 1 22 43 57 25 7 53 12 16

• a) 17 à 4• b) 15 à 1• c) 16 à 15• d) 45 à 15



elements would be examined (# of calls to equals()) by the binary search to determine if the indicated targets are on the list?

• a) 17• b) 15• c) 16• d) 45


1 4 7 8 12 15 16 17 21 22 25 27 43 53 570 1 2 3 4 5 6 7 8 9 10 11 12 13 14

numberindex


elements would be examined by the linear search to determine if the indicated targets are on the list?

• a) 17 à 1• b) 15 à 3• c) 16 à 4• d) 45 à 4


1 4 7 8 12 15 16 17 21 22 25 27 43 53 570 1 2 3 4 5 6 7 8 9 10 11 12 13 14

numberindex

searching for 45min = 0, max = 14, mid = 7 NO largermin = 8, max =14, mid = 11, NO largermin = 12, max = 14, mid = 13, NO smallermin = 12, max = 12, mid = 12, NO largermin = 13, max = 12 exit

QuizWhat kind of performance can you expect if you perform linear search on a sorted array?

A) The performance will be about the same as on an unsorted array B) The performance will be much better than on an unsorted array C) The performance will be much worse than on an unsorted array D) The performance will be worse than n2 in this case E) none of the above

QuizWhat kind of performance can you expect if you perform linear search on a sorted array? A) The performance will be about the same as on an unsorted array B) The performance will be much better than on an unsorted array C) The performance will be much worse than on an unsorted array D) The performance will be worse than n2 in this case E) none of the above Linear search doesn't make any assumptions about whether or not its data is sorted. So, if the data happens to be sorted or not, it won't make any difference. Linear sort will perform roughly as n.

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Properties• A JavaFX property is an object that holds a value

• A property is observable – it can be monitored and changed as needed

• So, instead of holding an int primitive or an Integer object, a JavaFX class might store an IntegerProperty object

• Most values of JavaFX classes, such as the width of a Rectangle, are stored as properties


Properties• A key benefit of properties is property binding

• A property can be bound to another property so that when the value of one changes, the other is automatically updated (they are kept equal)

• No explicit event handling is needed

• Let's look at an example that binds the center point of a circle, and the text of a Text object, to the size of the scene

• See PropertyBindingDemo.java



import javafx.application.Application;import javafx.beans.property.SimpleStringProperty;import javafx.beans.property.StringProperty;import javafx.scene.Group;import javafx.scene.Scene;import javafx.scene.paint.Color;import javafx.scene.shape.Circle;import javafx.scene.text.Text;import javafx.stage.Stage;

//************************************************************************// PropertyBindingDemo.java Author: Lewis/Loftus//// Demonstrates the ability to bind one property to another.//************************************************************************

public class PropertyBindingDemo extends Application{

//--------------------------------------------------------------------// Displays the width and height of the scene, as well as a circle// in the center of the scene. The scene is updated using property// bindings as the window is resized.//--------------------------------------------------------------------public void start(Stage primaryStage){

Group root = new Group();Scene scene = new Scene(root, 300, 200, Color.SKYBLUE);

continue


continue

Circle center = new Circle(6);center.centerXProperty().bind(scene.widthProperty().divide(2));center.centerYProperty().bind(scene.heightProperty().divide(2));

StringProperty width = new SimpleStringProperty("Width: ");StringProperty height = new SimpleStringProperty("Height: ");

Text widthText = new Text(20, 30, "");widthText.textProperty().bind(width.concat(scene.widthProperty()));

Text heightText = new Text(20, 60, "");heightText.textProperty().bind(height.concat(scene.heightProperty()));

root.getChildren().addAll(center, widthText, heightText);

primaryStage.setTitle("Property Binding Demo");primaryStage.setScene(scene);primaryStage.show();

}}

Change Listeners• A property can have a change listener, similar to

an event handler• Properties have an addListener method:

myProperty.addListener(this::processChange);

• A change listener method accepts three parameters:– the ObservableValue (the property)– the old value– the new value


Change Listeners• The types of the old and new values depend on the

type of value the property holds

• See ChangeListenerDemo.javaCopyright © 2017 Pearson Education, Inc.

public void processChange(ObservableValue<? extends String> val,String oldValue, String newValue)

{// whatever

}

public void processChange(ObservableValue<? extends Integer> val,Integer oldValue, Integer newValue)

{// whatever

}


import javafx.application.Application;import javafx.beans.value.ObservableValue;import javafx.scene.Group;import javafx.scene.Scene;import javafx.scene.paint.Color;import javafx.scene.shape.Circle;import javafx.scene.text.Text;import javafx.stage.Stage;

//************************************************************************// ChangeListenerDemo.java Author: Lewis/Loftus//// Demonstrates the ability to respond to property changes using// change listeners. Functionally equivalent to PropertyBindingDemo.//************************************************************************

public class ChangeListenerDemo extends Application{

private Scene scene;private Circle center;private Text widthText, heightText;

continue


continue

//--------------------------------------------------------------------// Displays the width and height of the scene, as well as a circle// in the center of the scene. The scene is updated using a change// listener as the window is resized.//--------------------------------------------------------------------public void start(Stage primaryStage){

Group root = new Group();

scene = new Scene(root, 300, 200, Color.SKYBLUE);scene.widthProperty().addListener(this::processResize);scene.heightProperty().addListener(this::processResize);

center = new Circle(6);center.setCenterX(scene.getWidth() / 2);center.setCenterY(scene.getHeight() / 2);

widthText = new Text(20, 30, "Width: " + scene.getWidth());heightText = new Text(20, 60, "Height: " + scene.getHeight());

root.getChildren().addAll(center, widthText, heightText);

primaryStage.setTitle("Change Listener Demo");primaryStage.setScene(scene);primaryStage.show();

}

continue


continue

//--------------------------------------------------------------------// Updates the position of the circle and the displayed width and// height when the window is resized.//--------------------------------------------------------------------public void processResize(ObservableValue<? extends Number> property,

Object oldValue, Object newValue){

center.setCenterX(scene.getWidth() / 2);center.setCenterY(scene.getHeight() / 2);widthText.setText("Width: " + scene.getWidth());heightText.setText("Height: " + scene.getHeight());

}}

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Sliders• A slider is a GUI control that allows the user to

specify a value within a numeric range

• The minimum and maximum values for the slider are set using the Slider constructor

• A slider can be oriented horizontally (default) or vertically

• It can also have optional tick marks and labels


Sliders• You can use the getValue method of the slider to

obtain its current value

• Or you can use property bindings or a change listener to react dynamically to the movement of a slider knob

• Let's look at an example that uses two sliders to change the shape of an ellipse

• See EllipseSliders.java



import javafx.application.Application;import javafx.geometry.Insets;import javafx.geometry.Orientation;import javafx.scene.Scene;import javafx.scene.control.Slider;import javafx.scene.layout.BorderPane;import javafx.scene.paint.Color;import javafx.scene.shape.Ellipse;import javafx.stage.Stage;

//************************************************************************// EllipseSliders.java Author: Lewis/Loftus//// Demonstrates the use of slider controls and property binding.//************************************************************************

public class EllipseSliders extends Application{

private Ellipse ellipse;private Slider xSlider, ySlider;

//--------------------------------------------------------------------// Displays an ellipse with sliders that control the width and// height of the ellipse.//--------------------------------------------------------------------public void start(Stage primaryStage){

continue


continue

ellipse = new Ellipse(250, 150, 150, 75);ellipse.setFill(Color.SALMON);

xSlider = new Slider(0, 200, 150);xSlider.setShowTickMarks(true);xSlider.setPadding(new Insets(0, 20, 20, 80));

ellipse.radiusXProperty().bind(xSlider.valueProperty());

ySlider = new Slider(0, 100, 75);ySlider.setOrientation(Orientation.VERTICAL);ySlider.setShowTickMarks(true);ySlider.setPadding(new Insets(20, 0, 0, 30));

ellipse.radiusYProperty().bind(ySlider.valueProperty());

BorderPane pane = new BorderPane();pane.setLeft(ySlider);pane.setBottom(xSlider);pane.setCenter(ellipse); pane.setStyle("-fx-background-color: grey");

continue


continue

Scene scene = new Scene(pane, 500, 300);

primaryStage.setTitle("Ellipse Sliders");primaryStage.setScene(scene);primaryStage.show();

}}

Outline

Late Binding



Sorting

Searching

Properties

Sliders

Spinners


Spinner• A spinner is a GUI control that allows the user to

select a value from a list of predefined values

• The current value is shown in a text field with arrow buttons for changing the selection

• Only the current value is ever shown, so other GUI elements are never obscured by a drop-down list

• Spinner is a generic class – you specify the type of values the spinner presents


Spinner• A SpinnerValueFactory is used to define the

spinner options

• An integer spinner can be created using an IntegerSpinnerValueFactory

• A string spinner is created using an ObservableList

• See SpinnerDemo.java



import javafx.application.Application;import javafx.beans.property.SimpleStringProperty;import javafx.beans.property.StringProperty;import javafx.collections.FXCollections;import javafx.collections.ObservableList;import javafx.geometry.Pos;import javafx.scene.Scene;import javafx.scene.control.Spinner;import javafx.scene.control.SpinnerValueFactory.IntegerSpinnerValueFactory;import javafx.scene.layout.VBox;import javafx.scene.text.Font;import javafx.scene.text.Text;import javafx.stage.Stage;

//************************************************************************// SpinnerDemo.java Author: Lewis/Loftus//// Demonstrates the use of spinner controls and property binding.//************************************************************************

public class SpinnerDemo extends Application{

private Spinner<Integer> intSpinner;private Spinner<String> stringSpinner;private Text text;

continue


continue

//--------------------------------------------------------------------// Presents an integer spinner and a string spinner, updating some// text when either value changes.//--------------------------------------------------------------------public void start(Stage primaryStage){

IntegerSpinnerValueFactory svf =new IntegerSpinnerValueFactory(1, 10, 5);

intSpinner = new Spinner<Integer>(svf);

ObservableList<String> list = FXCollections.observableArrayList();list.addAll("Grumpy", "Happy", "Sneezy", "Sleepy", "Dopey",

"Bashful", "Doc");stringSpinner = new Spinner<String>(list);stringSpinner.getStyleClass().add(

Spinner.STYLE_CLASS_SPLIT_ARROWS_VERTICAL);

StringProperty textString = new SimpleStringProperty("");

text = new Text();text.setFont(new Font("Helvetica", 24));text.textProperty().bind(textString.concat(

intSpinner.valueProperty()).concat(" and ").concat(stringSpinner.valueProperty()));

continue


continue

VBox pane = new VBox(intSpinner, stringSpinner, text);pane.setStyle("-fx-background-color: skyblue");pane.setAlignment(Pos.CENTER);pane.setSpacing(25);

Scene scene = new Scene(pane, 300, 250);

primaryStage.setTitle("Spinner Demo");primaryStage.setScene(scene);primaryStage.show();

}}

Summary• Chapter 10 has focused on:

– defining polymorphism and its benefits– using inheritance to create polymorphic references– using interfaces to create polymorphic references– using polymorphism to implement sorting and searching

algorithms– property binding– additional GUI components


QuizAn int array stores the following values. Use the array to answer these next questions.

Which of the following lists of numbers would accurately show the array after the first pass through the Selection Sort algorithm? A) 9, 4, 12, 2, 6, 8, 18 B) 4, 9, 12, 2, 6, 8, 18 C) 2, 4, 12, 9, 6, 8, 18 D) 2, 4, 6, 8, 9, 12, 18 E) 2, 4, 9, 12, 6, 8, 18


QuizAn int array stores the following values. Use the array to answer these next questions.

Which of the following lists of numbers would accurately show the array after the fourth pass through the Selection Sort algorithm? A) 9, 4, 12, 2, 6, 8, 18 B) 2, 4, 6, 9, 12, 8, 18 C) 2, 4, 6, 8, 9, 12, 18 D) 2, 4, 6, 9, 8, 12, 18 E) 2, 4, 6, 8, 12, 9, 18


Quizpublic class Inherit { abstract class Speaker {abstract public void speak( );

}class Cat extends Speaker {public void speak( ){System.out.println("Woof!");

}} class Dog extends Speaker {public void speak( ){ System.out.println("Meow!");

}} ...

...Inherit( ){

Speaker d = new Dog( );Speaker c = new Cat( );d.speak( );c.speak( );

}

public static void main(String[ ]args)

{new Inherit( );

}

}

What is printed by the following code?

Quizpublic class Inherit { abstract class Speaker {abstract public void speak( );

}class Cat extends Speaker {public void speak( ){System.out.println("Woof!");

}} class Dog extends Speaker {public void speak( ){ System.out.println("Meow!");

}} ...

...Inherit( ){

Speaker d = new Dog( );Speaker c = new Cat( );d.speak( );c.speak( );

}

public static void main(String[ ]args)

{new Inherit( );

}

}

Meow!Woof!

QuizWhich statement is completely true?

A) Java upcasts automatically, but you must explicitly downcast (upcasting = casting up in the hierarchy, e.g., to Object)B) Java downcasts automatically, but you must explicitly upcast C) Java expects the user to explicitly upcast and downcast D) Java will both upcast and downcast automatically E) The rules for upcasting and downcasting depend upon whether classes are declared public, protected, or private


QuizWhich statement is completely true?

A) Java upcasts automatically, but you must explicitly downcast (upcasting = casting up in the hierarchy., .e.g., to Object)B) Java downcasts automatically, but you must explicitly upcast C) Java expects the user to explicitly upcast and downcast D) Java will both upcast and downcast automatically E) The rules for upcasting and downcasting depend upon whether classes are declared public, protected, or private Upcasting is entirely safe, it's a product of the single inheritance structure that Java supports. Downcasting, by comparison, must be done explicitly by the programmer. Java only casts in one direction automatically it upcasts.

Quiz: what does it?void arrange(double[ ] ary){

for (int n=0; n<ary.length; n++)for (int k=n+1; k<ary.length; k++)

if (ary[n] > ary[k]){

double x = ary[n];ary[n] = ary[k];ary[k] = x;

}}

Quizvoid arrange(double[ ] ary){

for (int n=0; n<ary.length; n++)for (int k=n+1; k<ary.length; k++)

if (ary[n] > ary[k]){

double x = ary[n];ary[n] = ary[k];ary[k] = x;

}} It sorts the input array in ascending order

QuizCan a program exhibit polymorphism if it only implements early binding? A) Yes, because one form of polymorphism is overloading B) No, because without late binding polymorphism cannot be supported C) Yes, because so long as the programs uses inheritance and/or interfaces it supports polymorphism D) Yes, because early binding has nothing to do with polymorphism E) none of the above


QuizCan a program exhibit polymorphism if it only implements early binding? A) Yes, because one form of polymorphism is overloading B) No, because without late binding polymorphism cannot be supported C) Yes, because so long as the programs uses inheritance and/or interfaces it supports polymorphism D) Yes, because early binding has nothing to do with polymorphism E) none of the above

While inheritance and interfaces support polymorphism, they only do so if one has late binding. But, overloading is a form of polymorphism -- one (method) name, multiple bodies -- so as long as the program uses overloading, polymorphism is in use.

QuizThe type of the reference, not the type of the object, is used to determine which version of a method is invoked in a polymorphic reference. True or False?


QuizThe type of the reference, not the type of the object, is used to determine which version of a method is invoked in a polymorphic reference.

FalseBackwards! It is the type of the object, not the type of the reference, that determines which method is invoked .


QuizAn interface reference can refer to any object of any class that implements the interface.

True of False?


QuizAn interface reference can refer to any object of any class that implements the interface.

TrueThis is one of the polymorphic functions of using an interface name to declare a reference variable.


QuizA method's parameter can be polymorphic, giving the method flexible control of its arguments.

True or False?


QuizA method's parameter can be polymorphic, giving the method flexible control of its arguments.

TrueTo accomplish this, merely use an interface name or a base class name to declare the variable. Then the parameter is polymorphic -- referring to the correct instance of the class during execution, with the correct semantics being accessed during execution.


QuizIs it possible to use both overloading and overriding in the same method?

True or False?


QuizIs it possible to use both overloading and overriding in the same method?

TrueA method which is declared in a descendent class certainly can override a method in a parent class so long as the method in the parent class isn't declared final. Now, if the descendent class contains another method with the same name and different signature the new method will also overload it.


QuizFind the errorspublic abstract class AbstractClass {

public int one() {return 1;

}public abstract int two();private abstract int three ();final abstract int four ();static abstract int five ();public abstract class Subclass extends

AbstractClass {}public class Subclass2 extends AbstractClass {

public int two() {return 2;

}protected int four() {

return 4;}

}}

QuizFind the errorspublic abstract class AbstractClass {

public int one() {return 1;

}public abstract int two();private abstract int three ();final abstract int four ();static abstract int five ();public abstract class Subclass extends

AbstractClass {}public class Subclass2 extends AbstractClass {

public int two() {return 2;

}protected int four() {

return 4;}

}}

abstract methods cannot be privateabstract methods cannot be finalabstract methods cannot be static

Subclass2 must be abstract because it is not implementingall the abstract methods in AbstractClass

chapter 10 polymorphismricci/cp/slides/chap10-v9.pdfpolymorphism via inheritance •let's look...

Documents