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

Transcription

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

2 Today s Exercise Session Organisation Status of the projects (summary in wiki) Pattern of the Day The Command Related patterns Quizzes on Reflection 2

3 Status of the projects Walkthrough the project summaries IEEE project specification Discuss the submitted project specifications The project members report Project status Problems General questions 3

4 Command Encapsulates the request as an object. Lets you parameterize clients with different requests. Queue or log requests. Supports undoable operations. 4

5 Command - Structure Command Declares an interface for executing an operation. ConcreteCommand Binding between receiver object and an action, it implements Command. Client Creates ConcreteCommand and sets its receiver. Receiver Knows how to perform the operations encoded in the Command. Invoker Asks the command(s) to carry out the request. 5

6 Command Example public interface CommandInterface { public void execute(); public class AddCommand implements CommandInterface { Item item; Category cat; public AddCommand(Item i, Category c) { item = i; cat = c; public void execute() { item.add(cat); cat.add(item); public String tostring() { return "Command Add: " + item.tostring() + " " + cat.tostring(); public class DeleteCommand implements CommandInterface { public DeleteCommand(Item i, Category c) { public void execute() { 6

7 Command Example public class Category { private HashMap<String, Item> items; private String desc; public Category(String s) { public void add(item i) { public void delete(item i) { import java.util.hashmap; public class Item { public Item(String s) { public void add(category cat) { public void delete(category cat) { 7

8 Command Example public class ItemManager { ArrayList <CommandInterface> commands = public void setcommand(commandinterface c) { commands.add(c); public void process() { for (int i=0; i < commands.size(); i++) { commands.get(i).execute(); public class CommandTest { public static void main(string[] args) { ItemManager manager = new ItemManager(); CommandInterface command = new AddCommand(CD, catcd); manager.setcommand(command); command = new AddCommand(CD, catcd); manager.setcommand(command); command = new AddCommand(CD, catcd); manager.setcommand(command); command = new DeleteCommand(CD, catcd); manager.setcommand(command); manager.process(); 8

9 Command Consequences Command decouples the object that invokes the operation from the one that knows how to perform it. The commands can be manipulated and extended as any other objects. The commands can be assembled into a composite commands MacroCommads with Composite pattern. It is easy to add new Commands, because the existing classes don t have to be changed. 9

10 Related patterns Related patterns Chain of Responsibility, Memento and Composite Relations Chain of Responsibility can use Command to represent requests as objects. Command and Memento act as magic tokens to be passed around and invoked at a later time. In Command, the token represents a request; in Memento, it represents the internal state of an object at a particular time. Command can use Memento to maintain the state required for an undo operation. MacroCommands can be implemented with Composite. 10

11 Quizz: Reflection I public class ClassInfo { public static void main(string args[]) { try { Class c = Class.forName("java.lang.String"); System.out.println(c); // How to obtain the type of int? // How to obtain the type of inner class Inner as a literal? System.out.println(String[].class); // What will be printed? catch (Throwable e) { System.out.println(e); class Inner { public int test(string s){ return 0; 11

12 Quizz: Reflection I - Solution public class ClassInfo { public static void main(string args[]) { try { Class c = Class.forName("java.lang.String"); System.out.println(c); System.out.println(int.class); System.out.println(Inner.class); System.out.println(String[].class); catch (Throwable e) { System.out.println(e); class Inner { public int test(string s){ return 0; class java.lang.string int class ClassInfo$Inner class [Ljava.lang.String; 12

13 Quizz: Reflection II - What Does It Print? import java.util.arraylist; import java.util.list; public class ClassInfo1 { public static void main(string args[]) { try { List<String> l1 = new ArrayList<String>(); List<Integer> l2 = new ArrayList<Integer>(); System.out.println(l1.getClass() == l2.getclass()); Class<?> c = ClassInfo1.Inner.class; Class<?> c1 = Class.forName("ClassInfo1$Inner"); System.out.println(c==c1); Object o = c.newinstance(); Object o1 = c1.newinstance(); catch (Throwable e) { e.printstacktrace(); class Inner { public int test(string s){ return 0; 13

14 Quizz: Reflection II - Solution true true java.lang.instantiationexception: ClassInfo1$Inner at java.lang.class.newinstance0(unknown Source) at java.lang.class.newinstance(unknown Source) at ClassInfo1.main(ClassInfo1.java:16) It prints true, because all instances of a generic class have the same run-time class, regardless of their actual type parameters. Indeed, what makes a class generic is the fact that it has the same behavior for all of its possible type parameters; the same class can be viewed as having many different types. Second print is true, because both constructs represent the same class. They must share the same instance of Class. Exception is thrown because to obtain an instance of inner class we need first an instance of the outer one. 14

15 Reflection III - What Does It Print? import java.lang.reflect.method; public class ClassInfo2 { public static void main(string args[]) { try { Class<ClassInfo2> c = ClassInfo2.class; ClassInfo2 object = c.newinstance(); Class<?>[] innerclasses = object.getclass().getclasses(); ClassInfo2.Inner innerobject = null; for(int i=0;i<innerclasses.length;i++){ if(innerclasses[i].getname().equals("classinfo2$innere")){ innerobject = (ClassInfo2.Inner) innerclasses[i].getconstructor(new Class[]{object.getClass()).newInstance(new Object[]{object); Method[] methods = innerobject.getclass().getsuperclass().getdeclaredmethods(); Method ourmethod = null; for(int i=0;i<methods.length;i++){ if (methods[i].getname().equals("length")) { ourmethod = methods[i]; Integer length = (Integer) ourmethod.invoke(innerobject, "test"); System.out.println(length); catch (Throwable e) { e.printstacktrace(); public class Inner { public Integer length(string s){ return s.length(); public class InnerE extends ClassInfo2.Inner { public Integer length (String s) { return s.length() + 1; 15

16 Reflection III - What Does It Print? It prints 5 because 1. First loop searches all inner public classes of the outer class 2. and constructs an instance of inner class called InnerE. 3. To construct an instance of inner class an instance of outer class is needed. 4. We use reflection to obtain all methods of a superclass of InnerE (Inner). 5. The method length() is invoked, however because we provided an instance of InnerE to the method invocation, it will not invoke the length() method on Inner but on InnerE. 16

17 Questions? 17