Abstract Classes An abstract class is a placeholder in a class hierarchy that represents a generic...

Abstract ClassesAbstract Classes

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:

public abstract class Whatever

{

// contents

}

Abstract ExampleAbstract Example

A good example is the MovingObject class. MovingObject is just an abstract or synthetic concept to help us capture commonalities.

To make sure nobody creates an instance of class MovingObject,we need to declare it abstract.

Question: Is there another way of preventing others from creating objects of type MovingObject?

Abstract ExampleAbstract Example

Let’s say you want the MovingObjects to be able to collide with each other, but cannot define a collide method since the outcome of collision depends on specific object

MovingObject//collide ?

MovingRectanglecollide(MovingObject mo)

Ballcollide(..)

MovingImage?????????


An abstract class often contains abstract methods with no definitions

In addition to forcing sub-classes to override to become concrete classes, it enables one to write polymorphic methods

An abstract class typically contains non-abstract methods (with bodies), which can even call abstract methods

(a framework to build on)

A class declared as abstract does not need to contain abstract methods

Vehicle exampleVehicle example

public abstract class Vehicle {private Position position;public getPosition() { return position; }public abstract void start();public abstract void move();public abstract void turnLeft();public abstract void turnRight();public abstract void stop();public void goto(Position pos) {

start();if (position.getX() > pos.getX())

turnLeft(); . ……


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

AbstractMethodsAbstractMethods

to make sure every MovingObject has a collide() method,you can declare an abstract MovingObject.collide() method without an implementation, to be provided by more specific sub-classes

public class MovingObject {…..

public abstract void collide (MovingObject other);

………}

A framework for sequential A framework for sequential range search range search

Let’s say that we want to search a list of objects to find all objects having values between start and end objects.

Before starting an implementation, we have to ask the following questions:• what do we have to know about our objects? in other words,

what is the proper abstraction we should make of our objects?

• What do we have to know about the list that stores our objects?

the idea is to know as little about our objects as possible to write more general code, the more we know about our actors, the more restrictive our methods will get

lets create two classes, Searchable for our objects, List for our list, that can sub-classed later.

Searchable ClassSearchable Class

we don’t have to know the actual value of an object. for example a method like “public int getValue()” would be too restrictive, what if our objects are strings?

all we need is to know if an object is greater or less than another :

public abstract class Searchable {public boolean isLess(Searchable other);public boolean isGreater(Searchable other);

} Any class that extends Searchable can be

used by our method Now lets look at a List class that will contain

Searchable objects

List classList class

as a part of being as general as possible, we don’t want to just implement a list class. we want our search method to work on any structure that has the characteristics of a list. A specific implementation can inherit from our abstract List class.

Here are the things we need from a typical list• a method that tells us if we have more elements in the

list• a method to get the next element• a method to advance to the following element• a method to go to the first element

note that we don’t care how the elements got inserted into the list, that is irrelevant to our searching

List abstract classList abstract class

public abstract class List {public boolean hasNext();public Searchable getNext();public void advance();public void reset(); // to go to first element

}

note that a List doesn’t have to know what it contains, we could change the getNext() to return an Object reference.

the search methodthe search method

public static ArrayList rangeSearch(List list, Searchable start, Searchable end) {ArrayList result = new ArrayList();while (list.hasNext()) {

Searchable current = list.getNext();if (current.isGreater(start) &&

current.isLess(end))result.add(current);

list.advance();}return result;

} could have made it a method of List class

Example usage of searchExample usage of search

public class YearAndMonth extends Searchable {public int year, month;public boolean isLess(Searchable other) {

YearAndMonth ym = (YearAndMonth) other;if (ym.year > year)

return true;else if (ym.year < year)

return false;if ym.month > month

return true;return false;

}public boolean isGreater(Searchable other) { …. }

A List exampleA List example

public class VectorList extends List {private ArrayList v = new ArrayList();private int next = 0;public boolean hasNext() {

return (next < v.size());}public Searchable getNext() {

return v.get(next);}public void advance() {

next++;}public void reset() {

next = 0;}…..

Multiple RolesMultiple Roles

What if a class can satisfy several abstractions ? For example a car can be seen/viewed as a MovingObject(velocity), personal property (date of purchase, owner name ..), a rental item (cost per day,..),product (manufacture date, serial number..), a vehicle (number of seats) ….

In order to inherit implementation, can choose one parent

how can we fit our Car objects into different situations even though it has only one line of ancestors?

InterfacesInterfaces

A Java interface is a collection of abstract methods and constants

An abstract method can be declared using the modifier abstract, but because all methods in an interface are abstract, usually it is left off

An interface is used to establish, as a formal contract, a set of methods that a class will implement


public interface Product{ public static final int USA = 1; public static final int TURKEY = 90; …...

public int getCountry(); public String getSerialId(); public int getManufactureYear(); public void setQualityTester(Employee e); public String getModel(); }

interface is a reserved word

None of the methods inan interface are given

a definition (body)

A semicolon immediatelyfollows each method header


An interface cannot be instantiated

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


public class Car extends Vehicle implements Product{

public String getModel() { …. }

...

// etc.}

implements is areserved word

Each method listedin Product is

given a definition

Car-ProductCar-Product

Now an object of type Car can also be regarded as a product:

public void displayProductInfo(Product p) {…..}….Car c = new Car(…);Product p = c; // nothing happens to the actual object

heredisplayProductInfo(c);

Interfaces cannot be instantiated but can be used as parameter and reference types


A class can implement multiple interfaces

The interfaces are listed in the implements clause

The class must implement all methods in all interfaces listed in the header

class Car extends Vehicle implements Product, MovingObject, Property, RentalItem

{

// all methods of all interfaces

}

Polymorphism via InterfacesPolymorphism 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 any object of any class that implements the Speaker interface

The version of speak that the following line invokes depends on the type of object that current is referencing

current.speak();

Polymorphism via InterfacesPolymorphism via Interfaces

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();

Searchable and ListSearchable and List

the abstract classes Searchable and List defined earlier are good candidates for being interfaces.

the name List could be misleading, since our abstraction doesn’t care about the structure itself, it just cares about iterating through elements of any structure.

the Searchable name is not very good, too. What about a method that finds the maximum valued object? It can also use Searchable objects. What we really care is that the objects must be compared to each other.

often the logic of isLess() and isGreater() is closely related, why have two separate methods?


The Java standard class library contains many helpful interfaces

The Comparable interface contains an abstract method called compareTo, which is used to compare two objects (similar to Searchable)

The String class implements Comparable, giving us the ability to put strings in lexicographic order

The Iterator interface contains methods that allow the user to move easily through a collection of objects (similar to our List interface)

The Comparable InterfaceThe Comparable Interface

The Comparable interface provides a common mechanism for comparing one object to another

if (obj1.compareTo(obj2) < 0)

System.out.println (“obj1 is less than obj2”);

The result is negative is obj1 is less that obj2, 0 if they are equal, and positive if obj1 is greater than obj2

When a programmer writes a class that implements the Comparable interface, it should follow this intent

It's up to the programmer to determine what makes one object less than another

The Iterator InterfaceThe Iterator Interface

The Iterator interface provides a means of moving through a collection of objects, one at a time

The hasNext method returns a boolean result (true if there are items left to process)

The next method returns the next object in the iteration

The remove method removes the object most recently returned by the next method

A class can change its data structures, but as long as it is accessed by Iterator interface, no problem

Iterator ExampleIterator Example

public String toString() {String report = "";for (int cd = 0; cd < collection.size (); cd++) {

CD currentcd = (CD) collection.get (cd);report += currentcd.toString() + "\n";

}// or ….Iterator it = collection.iterator ();while (it.hasNext ()) {

CD currentcd = (CD) it.next ();report += currentcd.toString() + "\n";

}return report;

}

Iterator ExampleIterator Example

public class Database { private ArrayList items;

public Database() { items = new ArrayList(); }

public void addItem(Item theItem) { items.add(theItem); }

public String toString() { String result = "";

for(Iterator iter = items.iterator(); iter.hasNext(); ) { Item item = (Item)iter.next(); result += item.toString(); }

return result; }}

Flexibility of InterfacesFlexibility of Interfaces

When your program expects an object of a concrete class, you can only use types of objects that are descendants of that concrete class.

If you use interfaces, then regardless of its location in inheritance hierarchy, any object can be used

Therefore it is more flexible, for a method for example, to accept an Interface type rather than a concrete type. This way, it is possible to change underlying object without changing your code.

Extending InterfacesExtending Interfaces

An Interface can extend other interfaces.

interface ABC extends A, B, C{….}

Call-back methodsCall-back methods

Lets say that your class needs to be notified when something happens by some other class (like an alarm clock, barometer, thermometer, a window …)

It is clear that we should have two classes, Let’s say a thermometer and some other class communicating with each other.

What should a thermometer class look like? What does a thermometer need to know

about the objectthat is going to be “called-back” ?

ThermometerThermometer

It makes sense if the thermometer called some method of that object when the temperature exceeds some given limit.

public class Temperature {….

if (currentTemp > limit)

object.handleTemperature(currentTemp);

How does a Temperature know which object(s) to notify?


we could get the object from the constructor or via a method :

public class Temperature {public Temperature(TemperatureListener tl, int limit)

public addListener(TemperatureListener tl, int limit)

…}

What about TemperatureListener ?


it makes sense to define TemperatureListener to be an interface, since any type of object should be allowed to be a listener to be most flexible :

interface TemperatureListener {void handleTemperature(int currentTemp);

}

SortingSorting

Sorting is the process of arranging a list of items in a particular order

The sorting process is based on specific value(s)

• sorting a list of test scores in ascending numeric order

• sorting 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 SortSelection Sort

The approach of Selection Sort:

• select a value and put it in its final place into 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


An example:

original: 3 9 6 1 2

smallest is 1: 1 9 6 3 2




Each time, the smallest remaining value is found and exchanged with the element in the "next" position to be filled

39


Given an array numbers of size length,1 For index = 0 to length - 1 do1.1 find min, index of smallest element from index to

length - 11.2 switch elements at locations index and min

expand 1.11.1.1 min = index1.1.2 for scan = index+1 to length do1.1.2.1 if (numbers[scan] < numbers[min])1.1.2.1.1 min = scan;

SwappingSwapping

The processing of the selection sort algorithm includes the swapping of two values

Swapping requires three assignment statements and a temporary storage location:

temp = first;

first = second;

second = temp;

Selection Sort on int arraysSelection Sort on int arrays

public class Sorts {public static void selectionSort (int[] numbers) {

int min, temp;

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

min = index; for (int scan = index+1; scan <

numbers.length; scan++) if (numbers[scan] < numbers[min]) min = scan; // Swap the values temp = numbers[min]; numbers[min] = numbers[index]; numbers[index] = temp; } }

Polymorphism in SortingPolymorphism in Sorting

Recall that an class that implements the Comparable interface defines a compareTo method to determine the relative order of its objects

We can use polymorphism to develop a generic sort for any set of Comparable objects

The sorting method accepts as a parameter an array of Comparable objects

That way, one method can be used to sort a group of People, or Books, or whatever


The sorting method doesn't "care" what it is sorting, it just needs to be able to call the compareTo method

That is guaranteed by using Comparable as the parameter type

Also, this way each class decides for itself what it means for one object to be less than another

See PhoneList.java (page 500) See Sorting.java (page 501), specifically the selectionSort method

See Contact.java (page 503)

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.selectionSort(friends);

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

public class Contact implements Comparable { private String firstName, lastName, phone;

public Contact (String first, String last, String telephone) { …}public String toString () {…}public boolean equals (Object other) {…}

public int compareTo (Object other) { int result;

String otherFirst = ((Contact)other).getFirstName(); String otherLast = ((Contact)other).getLastName();

if (lastName.equals(otherLast)) result = firstName.compareTo(otherFirst); else result = lastName.compareTo(otherLast);

return result; }

public static void selectionSort (Comparable[] list) { int min; Comparable 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(list[min]) < 0) min = scan;

// Swap the values temp = list[min]; list[min] = list[index]; list[index] = temp; } }

Insertion SortInsertion Sort The approach 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 as needed to make room to insert the new addition

• 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 SortInsertion Sort

An example:

original: 3 9 6 1 2

insert 9: 3 9 6 1 2

insert 6: 3 6 9 1 2

insert 1: 1 3 6 9 2

insert 2: 1 2 3 6 9

See Sorting.java (page 501), specifically the insertionSort method

public static void insertionSort (Comparable[] list) { for (int index = 1; index < list.length; index++) { Comparable key = list[index]; int position = index;

// Shift larger values to the right while (position > 0 &&

key.compareTo(list[position-1]) < 0) { list[position] = list[position-1]; position--; } list[position] = key; } }

Comparing SortsComparing 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

Other sorts are more efficient: order n log2 n

OutlineOutline

Polymorphic References

Polymorphism via Inheritance

Polymorphism via Interfaces

Sorting

Searching

Event Processing Revisited

File Choosers and Color Choosers

Sliders

SearchingSearching

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 SearchLinear 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

See PhoneList2.java (page 508) See Searching.java (page 509), specifically

the linearSearch method

Contact test, found; Contact[] friends = new Contact[8]; friends[0] = new Contact ("John", "Smith", "610-555-7384"); … friends[7] = new Contact ("Marsha", "Grant", "243-555-2837");

test = new Contact ("Frank", "Phelps", ""); found = (Contact) Searching.linearSearch(friends, test); if (found != null) System.out.println ("Found: " + found); else System.out.println ("The contact was not found."); System.out.println (); Sorting.selectionSort(friends); test = new Contact ("Mario", "Guzman", ""); found = (Contact) Searching.binarySearch(friends, test); if (found != null) System.out.println ("Found: " + found); else System.out.println ("The contact was not found.");

public static Comparable linearSearch (Comparable[] list, Comparable target) {

int index = 0; boolean found = false;

while (!found && index < list.length) { if (list[index].equals(target)) found = true; else index++; }

if (found) return list[index]; else return null; }

Binary SearchBinary 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 SearchBinary 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

See PhoneList2.java (page 508) See Searching.java (page 509), specifically

the binarySearch method

public static Comparable binarySearch (Comparable[] list, Comparable target) {

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

while (!found && min <= max) { mid = (min+max) / 2; if (list[mid].equals(target)) found = true; else if (target.compareTo(list[mid]) < 0) max = mid-1; else min = mid+1; } if (found) return list[mid]; else return null; }

Abstract Classes An abstract class is a placeholder in a class hierarchy that represents a generic...

Documents

Transcript of Abstract Classes An abstract class is a placeholder in a class hierarchy that represents a generic...