COP 3503 FALL 2012 Shayan Javed Lecture 7

1 / 162

COP 3503 FALL 2012SHAYAN JAVED

LECTURE 7

Programming Fundamentals using Java

2 / 162

More With Interfaces

3 / 162

Interfaces

Language construct for specifying functionality without implementation

Method specifications but no implementations.

4 / 162

Interfaces in Software Engineering

In large projects you have a lot of classes interacting with each other

5 / 162

Need formal descriptions of what a class does, and how it interacts with other classes.

6 / 162

Interfaces are a way to define expected behavior.

7 / 162

Interfaces are a way to define expected behavior.

Useful when multiple teams working in tandem.

8 / 162

Interfaces

Some interfaces already defined in Java Widely used

Comparable

Comparator

Cloneable

9 / 162

The Comparable interface

Defined in the java.lang Package

10 / 162

Defined in the java.lang Package

public interface Comparable {public int compareTo(Object o);

11 / 162

12 / 162

Comparisons between objects of the same type

13 / 162

Comparisons between objects of the same type Object1.compareTo(Object2)

14 / 162

Comparisons between objects of the same type Object1.compareTo(Object2) Return values:

< 0 = Object 1 < Object 2 (usually -1)

15 / 162

< 0 = Object 1 < Object 2 (usually -1) == 0 = Object 1 == Object 2

16 / 162

< 0 = Object 1 < Object 2 (usually -1) == 0 = Object 1 == Object 2 > 0 = Object 1 > Object 2 (usually 1)

17 / 162

Used commonly.

18 / 162

Used commonly.

For ex. the String and Date classes.

19 / 162

public String implements Comparable,… {public int compareTo(Object o) {

// compares the two Strings lexicographically

20 / 162

Ex.: "computer".compareTo ("comparison")

21 / 162

Ex.: "computer".compareTo ("comparison")

Returns 20

22 / 162

"computer".compareTo ("comparison")

Returns 20

Provides the first non-zero difference in ASCII values.

23 / 162

Returns 20

Provides the first non-zero difference in ASCII values. “c”, “o”, “m”, “p” are all equal

24 / 162

Returns 20

Returns: (int)‘u’ - (int)‘a’

25 / 162

Returns 20

Returns: (int)‘u’ - (int)‘a’

So “computer” > “comparison”

26 / 162

Implement it for the Rectangle class

27 / 162

Implement it for the Rectangle class Comparisons based on area

28 / 162

Implement it for the Rectangle class Comparisons based on area

public class Rectangle extends GeometricObject implements Comparable {public int compareTo(Object ob) {

Rectangle r = (Rectangle)ob;if (this.getArea() > r.getArea())

return 1;else if (r.getArea() > this.getArea())

return -1;else

return 0;}

29 / 162

What if a non-Rectangle object is passed in?

30 / 162

A ClassCastException is thrown

31 / 162

A ClassCastException is thrown

Will look at it later

32 / 162

Can also use Comparable as a data type

33 / 162

String s = “aString”;(s instanceof Comparable) // returns true!

34 / 162

String s = “aString”;(s instanceof Comparable) // returns true!

Comparable[] compObjects = new Comparable[5];

35 / 162

So now we can compare objects

36 / 162

So now we can compare objects

Would be nice if we could sort them using this info

37 / 162

Sorting

Always need data sorted by certain requirements

38 / 162

Sorting

How do you sort arrays?

39 / 162

Sorting

How do you sort arrays?

Will look at specific sorting algorithms later on.

40 / 162

Sorting

Sorting on Amazon’s website

41 / 162

Sorting

By different categories

42 / 162

Comparing Bookspublic Book implements Comparable{

String title;int popularity;double price, avgCustomerReview;Date publicationDate;

43 / 162

Comparing Bookspublic Book implements Comparable{

String title;int popularity;double price, avgCustomerReview;Date publicationDate;

// comparison based on pricepublic int compareTo(Object o) {

Book b = (Book)o;if (price > b.getPrice())

return 1;else if (price < b.getPrice())

return -1;else

return 0;}

44 / 162

Arrays.sort()

An easy way to sort an array

45 / 162

Arrays.sort()

An easy way to sort an array Works directly with most of the primitive types –

int, char, double, long, etc.

46 / 162

Arrays.sort()

int numbers[] = {4, 1, 19, 8};Arrays.sort(numbers);

47 / 162

Arrays.sort()

int numbers[] = {4, 1, 19, 8};Arrays.sort(numbers);

numbers = [1, 4, 8, 19]

48 / 162

Arrays.sort()

Can also sort arrays of Objects

49 / 162

Arrays.sort()

Arrays.sort(Object[] o)

50 / 162

Arrays.sort()

Make sure that the objects in the array: Implement Comparable

51 / 162

Arrays.sort()

Make sure that the objects in the array: Implement Comparable Are of the same type (no ClassCastException thrown)

52 / 162

Arrays.sort()

Let’s sort the Books by price

53 / 162

Arrays.sort()

Book book1 = new Book(“Game Of Thrones”, 9.99);Book book2 = new Book(“The Help”, 12.99);Book book3 = new Book(“The Road”, 8.99);Book[] books = {book1, book2, book3};

54 / 162

Arrays.sort()

Book book1 = new Book(“Game Of Thrones”, 9.99);Book book2 = new Book(“The Help”, 12.99);Book book3 = new Book(“The Road”, 8.99);Book[] books = {book1, book2, book3};

Arrays.sort(books);books = [book3, book1, book2];

55 / 162

Arrays.sort()

Let’s sort Rectangles

56 / 162

Arrays.sort()

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};

57 / 162

Arrays.sort()

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};Arrays.sort(objs);

58 / 162

Arrays.sort()

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};Arrays.sort(objs);

objs = [r2, r3, r1]

59 / 162

Arrays.sort()

Now we have sorted by area (for Rectangles) and by price (for Books)

60 / 162

Arrays.sort()

Now we have sorted by area (for Rectangles) and by price (for Books)

What if we want to sort by another criteria?

61 / 162

The Comparator interface

Provides an alternative way of comparison

62 / 162

Provides an alternative way of comparison

public interface Comparator {public int compare(Object o1, Object

// To use the interface:

import java.util.Comparator;

63 / 162

public interface Comparator {public int compare(Object o1, Object o2);

Comparisons between objects of the same type

64 / 162

Comparisons between objects of the same type Object1.compare(Object1, Object2)

65 / 162

Comparisons between objects of the same type Object1.compare(Object1, Object2) Object3.compare(Object1, Object2)

66 / 162

Comparisons between objects of the same type Object1.compare(Object1, Object2) Object3.compare(Object1, Object2) Return values:

< 0 = Object 1 < Object 2 (usually -1) == 0 = Object 1 == Object 2 > 0 = Object 1 > Object 2 (usually 1)

67 / 162

Now let’s sort books by popularity.

public Book implements Comparable{String title;int popularity;double price, avgCustomerReview;Date publicationDate;

68 / 162

The Comparator interfacepublic Book implements Comparable, Comparator{

// Properties..// compareTo…

// comparison based on popularitypublic int compare (Object o1, Object o2) {

69 / 162

Book b1 = (Book)o1;

70 / 162

Book b1 = (Book)o1;Book b2 = (Book)o2;

71 / 162

Book b1 = (Book)o1;Book b2 = (Book)o2;if (b1.getPopularity() > b2.getPopularity())

return 1;if (b1.getPopularity() < b2.getPopularity())

return -1;else

return 0;}

72 / 162

Sort using Comparator

73 / 162

Sort using Comparator

Arrays.sort(Object[] array, Comparator object)

object = object of a class which implements Comparator

74 / 162

Sorting Books based on popularity

75 / 162

Book book1 = new Book(“Game Of Thrones”, 9.99, 2);Book book2 = new Book(“The Help”, 12.99, 1);Book book3 = new Book(“The Road”, 8.99, 20);Book[] books = {book1, book2, book3};

76 / 162

Arrays.sort(books, book1);

77 / 162

Arrays.sort(books, book1);books = [book2, book1, book3];

78 / 162

Arrays.sort(books, book1); // Replace book1 with book2?

79 / 162

80 / 162

books = [book2, book1, book3]; // same output

81 / 162

books = [book2, book1, book3]; // same outputObject passed in doesn’t matter

82 / 162

Implement it for the Rectangle class Comparisons based on width

83 / 162

public class Rectangle extends GeometricObject implements Comparator {

public int compare(Object ob1, Object ob2) {Rectangle r1 = (Rectangle)ob1;Rectangle r2 = (Rectangle)ob2;if (r1.getWidth() > r2.getWidth() )

return 1;else if (r1.getWidth() < r2.getWidth()

return -1;else

return 0;}

84 / 162

Rectangle(width, height)

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};

85 / 162

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};Arrays.sort(objs, r1); // can also pass in r2 or r3

86 / 162

Rectangle r1 = new Rectangle(5.0, 2.0); // area = 10Rectangle r2 = new Rectangle(1.0, 4.0); // area = 4Rectangle r3 = new Rectangle(3.0, 2.0); // area = 6Rectangle[] objs = {r1, r2, r3};Arrays.sort(objs, r1); // can also pass in r2 or r3

objs = [r2, r3, r1]

87 / 162

Now we have sorted by area and width (for Rectangles) and by price and popularity (for Books)

88 / 162

Now we have sorted by area and width (for Rectangles) and by price and popularity (for Books)

What if we still want to sort by another criteria?

89 / 162

Already implemented Comparator in the Rectangle/Book classes though…

90 / 162

Solution: Create a new, empty class which implements Comparable

91 / 162

Solution: Create a new, empty class which implements Comparable

Comparisons based on other criteria

92 / 162

Book comparisons based on “Avg. Customer Review” (avgCustomerReview)

93 / 162

public class ReviewComparison implements Comparator {

94 / 162

public class ReviewComparison implements Comparator {public int compare (Object o1, Object o2) {

Book b1 = (Book)o1;Book b2 = (Book)o2;if (b1.getACR() > b2.getACR())

return 1;if (b1.getACR() < b2.getACR())

return -1;else

return 0;}

ACR = Average Customer Review

95 / 162

To sort based on average customer review:

96 / 162

To sort based on average customer review:

Arrays.sort(books, new ReviewComparison() )

97 / 162

So we can use Comparator for comparing objects based on different criteria.

And use Arrays.sort() based on that.

98 / 162

Comparable vs. Comparator

Use Comparable ( the compareTo() method):

99 / 162

Use Comparable ( the compareTo() method): want to compare based on default natural ordering

100 / 162

Use Comparable ( the compareTo() method): want to compare based on default natural ordering have control of the object (source code)

101 / 162

Use Comparator ( the compare() method):

102 / 162

Use Comparator ( the compare() method): want to compare based on different behavior from

the default

103 / 162

Use Comparator ( the compare() method): want to compare based on different behavior from

the default do NOT have control of the object (source code)

104 / 162

Object duplication

In large systems, often deal with objects of the same type.

105 / 162

Object duplication

In large systems, often deal with objects of the same type.

Need a way to easily create clones of objects.

106 / 162

Object duplication

Example: (Halo videogame)

107 / 162

Object duplication

Would be tedious to instantiate each one individually

108 / 162

Object duplication

Easier to clone (and then maybe modify)

109 / 162

Object duplication

Products of multiple sizes/colors

110 / 162

Object duplication

Products of multiple sizes/colors

111 / 162

Object duplication

Easier to clone (and then modify color)

112 / 162

Object duplication

Two types of copies:

113 / 162

Object duplication

1. Shallow copy

114 / 162

Object duplication

1. Shallow copy

2. Deep Copy

115 / 162

Shallow copy

Bit-wise copy of an object

116 / 162

Shallow copy

New object created with exact copy of the values.

117 / 162

Shallow copy

Will create new primitives with same values (int, char, double, etc.)

118 / 162

Shallow copy

Will create new primitives with same values (int, char, double, etc.)

But: Will just copy over references to objects.

119 / 162

Shallow copy

References to objects copied.

120 / 162

Shallow copy

References to objects copied.

Problem: Modifying objects in clone will also modify objects in the original!

121 / 162

Shallow copy

public Book {String title;int popularity;double price, avgCustomerReview;Date publicationDate;

122 / 162

Shallow copy

public Book {String title;int popularity;double price, avgCustomerReview;Date publicationDate;

What happens if you create a shallow copy?

123 / 162

Shallow copy

Book1double price

double avg

Date publicationDate

String title

Memory

124 / 162

Shallow copy

Book1double price

double avg

Date publicationDateShallow

String title

Memory

125 / 162

Shallow copy

Book1double price

double avg

String title

double price

double avg

Shallow copy

String title

Memory

126 / 162

Shallow copy

Book1double price

double avg

String title

double price

double avg

Shallow copy

String title

Memory

127 / 162

Shallow copy

Both Books point to the same Date!

128 / 162

Shallow copy

Modifying Date object in clone will also modify Date in original.

129 / 162

Shallow copy

Modifying Date object in clone will also modify Date in original.

Solution?

130 / 162

Deep Copy

Complete copy of an object

131 / 162

Deep Copy

References are not copied – new objects are created. (all the way down the hierarchy)

132 / 162

Deep Copy

References are not copied – new objects are created. (all the way down the hierarchy)

Of course primitives are copied too (int, char, double, etc.)

133 / 162

Deep Copy

Book1double price

double avg

String title

Memory

134 / 162

Deep Copy

Book1double price

double avg

Date publicationDateDeep

String title

Memory

135 / 162

Deep Copy

Book1double price

double avg

Date publicationDateDeep

String title

Memory

Book2double price

double avg

String title

136 / 162

The Cloneable interface

A Marker interface

137 / 162

A Marker interface Does not contain constants or methods Used to indicate that it’s legal to clone this object

138 / 162

A Marker interface Does not contain constants or methods Used to indicate that it’s legal to clone this object

Defined in the java.lang.package:

package java.lang;public interface Cloneable {

139 / 162

Use the .clone() method

140 / 162

Use the .clone() method

Defined in the Object class:

protected Object clone() throws CloneNotSupportedException

141 / 162

Java classes (like Date and Calendar) implement Cloneable

142 / 162

Example:

Calendar calendar = new GregorianCalendar(2004, 2, 1);

Calendar copy = (Calendar)calendar.clone();

143 / 162

Example:

calendar == copy // ?

144 / 162

Example:

calendar == copy // ? false

145 / 162

Example:

calendar == copy // ? falsecalendar.equals(copy) // ?

146 / 162

Example:

calendar == copy // ? falsecalendar.equals(copy) // ? true

147 / 162

Did the clone() method create a shallow or deep copy?

148 / 162

Did the clone() method create a shallow or deep copy?

Deep – since they are distinct objects

149 / 162

A class that implements Cloneablemust override the clone() method

150 / 162

Let’s clone the Book class

151 / 162

Let’s clone the Book class

152 / 162

public Book implements Cloneable {String title;int popularity;double price, avgCustomerReview;Date publicationDate;

public Object clone() throws CloneNotSupportedException {return super.clone();

153 / 162

Will that create a shallow or deep copy?

154 / 162

Shallow – just calling super.clone() creates a shallow copy.

155 / 162

Shallow – just calling super.clone() creates a shallow copy.

Need to clone references properly to create a deep copy

156 / 162

Shallow copy

Book1double price

double avg

String title

double price

double avg

Shallow copy

String title

Memory

157 / 162

public Book implements Cloneable {Date publicationDate;

public Object clone() throws CloneNotSupportedException {

158 / 162

public Object clone() throws CloneNotSupportedException { Book book = (Book)super.clone(); // shallow copy

159 / 162

first book.publicationDate =

(Date)publicationDate.clone(); // deep copy

160 / 162

first book.publicationDate =

(Date)publicationDate.clone(); // deep copy return book;

161 / 162

All mutable fields should be cloned for a deep copy

162 / 162

All mutable fields should be cloned for a deep copy

Strings are immutable, so no need to clone them separately.

COP 3503 FALL 2012 Shayan Javed Lecture 7

Documents

AKTIVITI 1- HBEF 3503

COP 3503 FALL 2012 Shayan Javed Lecture 17

COP 3503 FALL 2012 Shayan Javed Lecture 12

Shayan LoOser

HBEF 3503 (Aktiviti 1)

Freemium Summit Shayan Zadeh

COMP200 JAVA REVIEW - Discipline of Musichughm/oop/slides/Lecture2-Review.pdf · COMP200 JAVA REVIEW OOP using Java, from slides by Shayan Javed. 2 Introduction to Java 䡦High-level

COP 3503 FALL 2012 Shayan Javed Lecture 14

COP 3503 FALL 2012 Shayan Javed Lecture 13

“Curb Appeal” Virtual Environments Project 4 Spring 2009 Ethan Blackwelder, Siddarth Garg and Shayan Javed

COP 3503 FALL 2012 Shayan Javed Lecture 8

€¦ · 2 Draft amendment 3503 === BUDG/3503=== Budget reference line : 05 01 04 01

St.marketing Plan Shayan[1]

COP 3503 FALL 2012 Shayan Javed Lecture 9

3503 AlmashriqNews

Shayan Ghose_Portfolio

COP 3503 FALL 2012 Shayan Javed Lecture 2

Εμπρός 3503

What's all going around ?!? Hamed Shayan

COP 3503 FALL 2012 Shayan Javed Lecture 6