Chair of Software Engineering. Languages in Depth Series: Java Programming. Prof. Dr. Bertrand Meyer. Exercise Session 3

Transcription

1 Chair of Software Engineering Languages in Depth Series: Java Programming Prof. Dr. Bertrand Meyer Exercise Session 3

2 Today s Exercise Session Assignment 2 Walkthrough the master solution (your solutions) Questions Pattern of the Day The Strategy Pattern Assignment II Hand-out Quizzes 2

3 Assignment 2 Review of the master solution (Your solutions) Questions 3

4 The Strategy Pattern A behavioral pattern: It is used to adapt/change behavior of an existing algorithm/object. Intent: Define a family of algorithms, encapsulate each one and make them interchangeable. The Strategy pattern lets the algorithm, embedded in a context object, vary independently from clients that use the context object. Useful if: The behavior of an context object should be dynamically swapped But the object s interface (and identity) remains the same All algorithms share a common interface 4

5 Motivation Often, different algorithms exist for the same task. Hardwiring all such algorithms into classes isn t desirable because: Clients get more complex if they would have to include the algorithms themselves The context classes become inflexible if they have to contain the algorithm Different algorithms will be appropriate at different times and should be exchangable Solution: Separate the algorithm implementation ( Strategy ) from the context object that uses it. 5

6 Example: Flexible Sorting Framework // Context public class SortedList { private ArrayList<String> list = new ArrayList<String>(); private SortStrategy sortstrategy; // "Strategy" public interface SortStrategy { void sort(arraylist<string> list); void setsortstrategy(sortstrategy s) { this.sortstrategy = s; public void add(string name) { list.add(name); public void sort() { sortstrategy.sort(list); 6

7 Example: Some Concrete Strategies public class QuickSort implements SortStrategy { public void sort(arraylist<string> list) { //Quick-sorting list... public class ShellSort implements SortStrategy { public void sort(arraylist<string> list) { //Shell-sorting list... public class MergeSort implements SortStrategy { public void sort(arraylist<string> list) { //Shell-sorting list... 7

8 Example: Usage public class SortApp { public static void main(string[] args) { // Two contexts following different strategies SortedList studentrecords = new SortedList(); studentrecords.add("samual"); studentrecords.add("jimmy"); studentrecords.add("sandra"); studentrecords.setsortstrategy(new QuickSort()); studentrecords.sort(); studentrecords.setsortstrategy(new ShellSort()); studentrecords.sort(); studentrecords.setsortstrategy(new MergeSort()); studentrecords.sort(); 8

9 Consequences (1) The Strategy pattern has the following benefits: Hierarchies of strategies define a whole family of algorithms; inheritance can help to factor out common functionality of the algorithms. Can be a more dynamic and more reusable alternative to subclassing, as long as the algorithm interface doesn t change. Strategies can provide a variety of implementations to a client which can choose the most appropriate one, depending on individual time and space trade-offs. 9

10 Consequences (2) The Strategy pattern has the following drawbacks: Clients might have to be aware of the different strategies in order to select the appropriate one; clients might be exposed to implementation issues. Additional communication overhead between strategy and context: additional method calls and a one-size-fitsall shared algorithm interface. Strategies increase the number of objects. You might use shared stateless (!) strategy objects to reduce the overhead. 10

11 Comparison to the Template Method Pattern The strategy pattern and the template method pattern are in some sense very similar; both allow to change the behavior of an algorithm. However: The Template Method pattern uses inheritance, but the Strategy pattern uses delegation. The basic steps of the algorithm in the Template Method pattern are fixed; callbacks and hook methods are used to adapt the behavior. With the Strategy pattern, the whole algorithm is replaced. 11

12 Assignment 3: A GUI for the Calculator 12

13 Quiz: Syntax File my/products/products.java: import java.util.date; package my.products; private class Product { int multiply(int a, int b) { return(a * b) Try to find all 6 mistakes in this example class. abstract Date lastsell(); public static void main(string args[ ]) { int x = 10, y = 20; System.out.println(multiply(x, y)); 13

14 Quiz: Syntax (Solution) File my/products/products.java: 1. The filename must be equal to the class name import java.util.date; package my.products; 2. The package declaration must come first private class Product { 3. Top-level classes can not be private int multiply(int a, int b) { return(a * b) 4. Semi-colon is missing abstract Date lastsell(); 5. No abstract methods in non-abstract classes public static void main(string args[ ]) { int x = 10, y = 20; System.out.println(multiply(x, y)); 6. A non-static method can not be invoked in a static context 14

15 Quiz: Generics and Overloading import java.util.*; class Foo { public Integer foo(list list) { public String foo(list list) { Do these two classes compile? Explain why or why not. class Bar { public Integer bar(list<integer> integers) { public String bar(list<string> strings) { 15

16 Quiz: Generics and Overloading import java.util.*; class Foo { public Integer foo(list list) { public String foo(list list) { class Bar { public Integer bar(list<integer> integers) { public String bar(list<string> strings) { Foo does not compile. Both foomethods have the same signature and are therefore ambiguous. Bar does compile. Overload resolution happens at compile time. At that time, the compiler has access to the generic type information to select a most specific method. 16

17 Quiz: Generics and Overloading import java.util.*; class Bar { public Integer bar(list<integer> integers) { public Integer bar(list<string> strings) { Why does this class not compile? (Note the changed return types) 17

18 Quiz: Generics and Overloading import java.util.*; class Bar { public Integer bar(list<integer> integers) { public Integer bar(list<string> strings) { During compilation, generic type erasure is performed: generic type parameters are replaced by their leftmost bound or Object if no bound was specified. Two methods with the same erasure would have identical signatures in the byte code (the return type is included) and the virtual machine could not distinguish between them. This is prohibited and the compiler issues an error method if two method have the same erasure. 18

19 Questions 19