lecture 14 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Lecture 14 PowerPoint Presentation
Download Presentation
Lecture 14

Loading in 2 Seconds...

play fullscreen
1 / 30
galvin-middleton

Lecture 14 - PowerPoint PPT Presentation

82 Views
Download Presentation
Lecture 14
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Lecture 14 Inheritance vs Composition

  2. Inheritance vs Interface • Use inheritance when two objects share a structure or code relation • Embodies the is_a relation • Should reflect the roles of the objects throughout the program • Use an interface when they share a common behavior spec

  3. Abstract Classes vs Interfaces • Abstract for the inheritance situation above, i.e. sharing code or structure • Interfaces for sharing behavior spec, not code • Example: Consider a Framework • It provides code in the form of methods that are inherited without being overridden->code is inherited • The implementation of an action listener cannot be predicted, so no code is inherited here

  4. Inheritance and Composition • Which to use and when? • Alternative 1: Implement a Stack with inheritance from a Vector class Stack extends Vector{ public Object push(Object item){ addElementAt(size()-1;} public Object pop(){return elementAt (size()- 1);} • Stacks can use protected members of Vector • Stacks can be used where Vectors are used as arguments • Reuse Vector methods, e.g. size, isEmpty • What to do with unwanted Vector methods, e.g. removeAt()?

  5. Inheritance and Composition • Now do this with Composition: class Stack{ private Vector theData; public Stack(){theData=new Vector();} public Object push(Object item){theData.addElement( item); return item;} • Advantages • Can change the implementation without any impact to users of stacks • Interface is narrower: we don’t need to know anything about Vectors

  6. Inheritance and Composition • Advantages to Composition (cont.) • There are no substitutability issues • Stacks and Vectors are different types • One cannot be substituted for the other • Meaningless behavior is not exposed • Inheritance couples base and derived class • Changes do not ripple upwards • Promotes encapsulation • Not dependent on private variables • Can change implementation of composed objects at run-time, not so with inheritance

  7. Composition • Prefer it to inheritance • Used in Java AWT • Uses Components and Containers • An item is a Component • A Container can contain Components and Containers • Obtain a tree-like structure by nesting • Embodied in the Composite Pattern

  8. Composite Pattern • Facilitate the same treatment of composite and primitive objects • Composite object: an object that contains other objects • E.g. lines and polygons are primitive objects, a drawing is composite. • Composite methods are implemented by iterating over the composite object, invoking the appropriate method for each subcomponent

  9. Composite Pattern • Use it when • You want to represent part-whole hierarchies of objects • You want your clients to be able to ignore differences between compisitions of objects and objects themselves • Benefits • Easy to add new kinds of components • Makes clients simpler

  10. Composite Pattern • Liabilities • Hard to restrict the types of components • Clients can do meaningless things to primitive objects at run-time

  11. Example • Consider a simple GUI system: public class window{ Button[] buttons; TextArea[] ta; Menu[] menus; WidgetContainer[] containers; public void updateWindow(){ if (buttons != null){ for(k=0;k<buttons.length();k++) buttons[k].draw(); if (ta != null) ... }

  12. Problem • If you want to add on a new kind of resource the update() method needs to be modified • Way around this is to use a uniform interface • Just do Widgets and WidgetContainers • Now you are programming to an interface • All Widgets support the Widget interface

  13. Another Attempt public class window{ Widget[] widgets; WidgetContainer[] containers; public void updateWindow(){ if (widgets != null) for (k=0; k<widgets.length(); k++){ widgets[k].updateWindow(); if (containers != null) ....

  14. Now Use Composite Pattern Component Button Menu widgetContainer

  15. To Obtain public class window{ Component[] components; public void updateWindow(){ if (components != null) for(k=0;k<components.length();k++) components[k].updateWindow(); } } • Bottom Line: Do not distinguish Widgets and WidgetContainers

  16. Delegation in Composition • It is often convenient to allow a receiving object, e.g. a Window, to further delegate certain operations to another object--its delegate--e.g. a Rectangle • This is better than making Window a subclass of Rectangle, the Window class may reuse the behavior of Rectangle and delegate rectangle-specific behavior to it

  17. Window Rectangle Rectangle area() area() width height return Rectangle->area() return width*height

  18. Comments • Here Window has_a Rectangle • It is easy to compare behavior at run-time • You can reuse Rectangle as a black box (not white-box as in inheritance) • You can use polymorphism to achieve dynamic behavior--employ an interface. This is the Strategy Design Pattern • Trade-off: harder to understand, much more flexible than inheritance • Visitor uses delegation

  19. Combining Inheritance and Composition • Main use: simplify an inheritance hierarchy • Not achievable everywhere, but it is very powerful where you can • Main example: Java Stream Wrappers • Add capabilities to a stream by “wrapping” it in another object that provides the desired capabilities • Makes a bigger, better version of a base class

  20. InputStream Hierarchy • InputStream • ByteArrayInputStream • FileInputStream • PipedInputStream • SequenceInputStream • ObjectInputStream • FilterInputStream • BufferedInputStream • DataInputStream  differ in the source of data values

  21. The Way It Works • Start with an InputStream, i.e. try to read a stream of bytes in sequence • Use it polymorphically • Add functionality, depending on your data • This new functionality is called a “wrapper” • Just add a new and better interface to the old one, getting/sending the result from/to the same place, i.e. InputStream, resp. OutputStream • Subclassing provides the new interface

  22. Example class FilterInputStream extends InputStream ... protected InputStream in; FilterInputStream(InputStream in){ this.in = in;} ...} • Filter is a wrapper • Builds on InputStream • First obtain the sequence of bytes from the InputStream and then do the filtering • Use composition on the InputStream

  23. Comments • You really have one object, many interfaces • Thus you avoid an explosion of the inheritance hierarchy • FilterInputStream is really just an InputStream with added functionality • If you wanted a DataInputStream, just wrap the InputStream in a DataInputStream object • Construct a new DataInputStream object, using the InputStream as input to the constructor

  24. Important Note • The primitive data-type operations of DataInputStream cannot be included in InputStream, because that object does not know about integer, float, etc • But you can make it understand these types by wrapping. • The neat thing: You can use a DataInputStream anywhere an InputStream is expected--thi is the advantage of inheritance

  25. Example • If dataSource is of type InputStream: InputStream dataSource; • Then the DataInputStream: DataInputStream typedDataSource = new DataInputStream(dataSource); • Gets the data from exactly the same place as data retrieved from dataSource • We have merely provided a better interface to the same input stream

  26. Another Example: Buffered Readers • Use Readers and Writers for character data • Start with primitive readers that directly manipulate the input data: • CharArrayReader, StringReader, FileReader • Now add functionality to data generated by the above Readers: • BufferedReader, FilterReader, LineNumberReader • Reader has the subclasses • BufferedReader • FileReader • PipedReader

  27. One Way to Buffer the Char Input • Do it from FileReader: BufferedReader in =new BufferedReader( new FileReader(“stuff.in”); • Buffers the char file “stuff.in”

  28. Another Way • Start with Reader (which is also primitive for 16 Bit Unicodes) • Buffer on top of it • Allow two types of buffer--a standard one with 8192 bytes and another of user-specified size • Use Reader’s capabilities and then add the buffering in the constructor

  29. public class BufferedReader extends Reader{ private Reader in; //use composition private char cb[]; //the buffer private static int defaultCharBufferSize=8192; private static int defaultExpectedLineLength=80; public BufferedReader(Reader in, int sz){ super(in); //get Reader functionality if (sz <= 0) throw new IllegalArgumentException( “Illegal Buffer size”); this.in = in; cb = new char[sz]; nextChar = nChars = 0;} public BufferedReader(Reader in){ this(in, defaultCharBufferSize);}

  30. Remarks • BufferedReader has methods read() and readLine() to read a single character, resp. a line of text. • Both of these throw an IOException • Remember to import from java.io