Programming Languages and Techniques (CIS120)

Transcription

1 Programming Languages and Techniques (CIS120) Lecture 25 November 1, 2017 Inheritance and Dynamic Dispatch (Chapter 24)

2 Announcements HW7: Chat Client Available Soon Due: Tuesday, November 14 th at 11:59pm Upcoming: Midterm 2 Friday, November 10 th in class Covers: Mutable state (in OCaml and Java) Objects (in OCaml and Java) ASM (in OCaml and Java) ReacSve programming (in OCaml) Arrays (in Java) Subtyping & Simple Extension (in Java) CIS120 2

3 OOooooo programming OO Subtypes

4 Interfaces Give a type for an object based on what it does, not on how it was constructed Describes a contract that objects must sassfy Example: Interface for objects that have a posison and can be moved keyword public interface Displaceable { public int getx(); public int gety(); public void move(int dx, int dy); No fields, no constructors, no method bodies!

5 ImplemenSng the interface A class that implements an interface provides appropriate definisons for the methods specified in the interface That class fulfills the contract implicit in the interface methods required to sassfy contract public class Point implements Displaceable { private int x, y; public Point(int x0, int y0) { x = x0; y = y0; public int getx() { return x; public int gety() { return y; public void move(int dx, int dy) { x = x + dx; y = y + dy; interfaces implemented

6 Another implementason public class Circle implements Displaceable { private Point center; private int radius; public Circle(Point initcenter, int initradius) { center = initcenter; radius = initradius; public int getx() { return center.getx(); public int gety() { return center.gety(); public void move(int dx, int dy) { center.move(dx, dy); Objects with different Delega)on: move the local state can sassfy circle by moving the the same interface center

7 The following snippet of code typechecks: public void moveitalot (Displaceable s) { //omitted // elsewhere Circle c = new Circle(10,10,10); moveitalot(c); 1. True 2. False Answer: True

8 Subtypes and Supertypes An interface represents a point of view about an object Classes can implement mul)ple interfaces interfaces classes implement interfaces classes Types can have many different supertypes / subtypes

9 Extension 1. Interface extension 2. Class extension (Simple inheritance)

10 Class Extension: Inheritance public class DisplaceableImpl implements Displaceable { private double x; private double y; public DisplaceableImpl(double x, double y) { this.x = x; this.y = y; public double getx() { return x; public double gety() { return y; public void move(double dx, double dy) { x = x + dx; y = y + dy; public class Circle extends DisplaceableImpl { private int radius; public Circle(int x, int y, int radius) { super(x,y); this.radius = radius; public int getradius() { return radius;

11 Interface Extension Build richer interface hierarchies by extending exissng interfaces. public interface Displaceable { double getx(); double gety(); void move(double dx, double dy); The Shape type includes all the methods of Displaceable and Area, plus the new getboundingbox method. public interface Area { double getarea(); public interface Shape extends Displaceable, Area { Rectangle getboundingbox(); Note the use of the extends keyword.

12 Interface Hierarchy Displaceable Area Shape Point Circle Rectangle class Point implements Displaceable { // omitted class Circle implements Shape { // omitted class Rectangle implements Shape { // omitted Shape is a subtype of both Displaceable and Area. Circle and Rectangle are both subtypes of Shape, and, by transi)vity, both are also subtypes of Displaceable and Area. Note that one interface may extend several others. Interfaces do not necessarily form a tree, but the hierarchy has no cycles.

13 Class Extension: Inheritance Classes, like interfaces, can also extend one another. Unlike interfaces, a class can extend only one other class. The extending class inherits all of the fields and methods of its superclass, may include addisonal fields or methods. This captures the is a relasonship between objects (e.g. a Car is a Vehicle). Class extension should never be used when is a does not relate the subtype to the supertype.

14 Simple Inheritance In simple inheritance, the subclass only adds new fields or methods. Use simple inheritance to share common code among related classes. Example: Circle, and Rectangle have iden)cal code for getx(), gety(), and move() methods when implemensng Displaceable.

15 Subtyping with Inheritance Displaceable Area DisplaceableImpl Shape Point Circle Rectangle Extends Implements - Type C is a subtype of D if D is reachable from C by following zero or more edges upwards in the hierarchy. - e.g. Circle is a subtype of Area, but Point is not

16 Example of Simple Inheritance See: Shapes.zip

17 Inheritance: Constructors Contructors cannot be inherited They have the wrong names! A subclass invokes the constructor of its super class using the keyword super. Super must be the first line of the subclass constructor if the parent class constructor takes no arguments, it is OK to omit the call to super. It is then called implicitly.

18 Class Extension: Inheritance public class DisplaceableImpl implements Displaceable { private double x; private double y; public DisplaceableImpl(double x, double y) { this.x = x; this.y = y; public double getx() { return x; public double gety() { return y; public void move(double dx, double dy) { x = x + dx; y = y + dy; public class Circle extends DisplaceableImpl { private int radius; public Circle(int x, int y, int radius) { super(x,y); this.radius = radius; public int getradius() { return radius;

19 Other forms of inheritance Java has other features related to inheritance (some of which we will discuss later in the course): A subclass might override (re-implement) a method already found in the superclass. A class might be abstract i.e. it does not provide implementasons for all of its methods (its subclasses must provide them instead) These features are hard to use properly, and the need for them arises only in somewhat special cases Making reusable libraries Special methods: equals and tostring We recommend avoiding all forms of inheritance (even simple inheritance ) when possible prefer interfaces and composison. Especially: avoid overriding.

20 Main idea: Subtype Polymorphism* Anywhere an object of type A is needed, an object that is a subtype of A can be provided. // in class C public static void leapit(displaceableimpl c) { c.move(1000,1000); // somewhere else C.leapIt(new Circle (10)); If B is a subtype of A, it provides all of A s (public) methods. Due to dynamic dispatch, the behavior of a method depends on B s implementason. Simple inheritance means B's method is inherited from A Otherwise, behavior of B should be compasble with A s behavior *polymorphism = many shapes

21 Object public class Object { boolean equals(object o) { // test for equality String tostring() { // return a string representation // other methods omitted Object is the root of the class tree. Classes that leave off the extends clause implicitly extend Object Arrays also implement the methods of Object This class provides methods useful for all objects to support Object is the highest type in the subtyping hierarchy.

22 Object Recap: Subtyping classes (form a tree) interfaces Displaceable Area DisplaceableImpl Shape Point Circle Rectangle Extends Implements Subtype by fiat - Interfaces extend (possibly many) interfaces - Classes implement (possibly many) interfaces - Classes (except Object) extend exactly one other class (Object by default) - Interface types (and arrays) are subtypes by fiat of Object

23 When do constructors execute? How are fields accessed? What code runs in a method call?

24 How do method calls work? What code gets run in a method invocason? o.move(3,4); When that code is running, how does it access the fields of the object that invoked it? x = x + dx; When does the code in a constructor get executed? What if the method was inherited from a superclass?

25 ASM refinement: The Class Table Class Table public class Counter { private int x; public Counter () { x = 0; public void incby(int d) { x = x + d; public int get() { return x; public class extends Counter { private int y; public (int inity) { y = inity; public void dec() { incby(-y); The class table contains: the code for each method, references to each class s parent, and the class s stasc members. Object String tostring(){ boolean equals Counter extends Counter() { x = 0; void incby(int d){ int get() {return x; extends (int inity) { void dec(){incby(-y);

26 this Inside a non-stasc method, the variable this is a reference to the object on which the method was invoked. References to local fields and methods have an implicit this. in front of them. class C { private int f; public void copyf(c other) { this.f = other.f; this Stack Heap C f 0

27 An Example public class Counter { private int x; public Counter () { x = 0; public void incby(int d) { x = x + d; public int get() { return x; public class extends Counter { private int y; public (int inity) { y = inity; public void dec() { incby(-y); // somewhere in main: d = new (2); d.dec(); int x = d.get();

28 with Explicit this and super public class Counter extends Object { private int x; public Counter () { super(); this.x = 0; public void incby(int d) { this.x = this.x + d; public int get() { return this.x; public class extends Counter { private int y; public (int inity) { super(); this.y = inity; public void dec() { this.incby(-this.y); // somewhere in main: d = new (2); d.dec(); int x = d.get();

29 ConstrucSng an Object Workspace Stack Heap d = new (2); d.dec(); int x = d.get(); Class Table Object String tostring(){ boolean equals Counter extends Counter() { x = 0; void incby(int d){ int get() {return x; extends (int inity) { void dec(){incby(-y);

30 AllocaSng Space on the Heap Workspace Stack Heap Class Table super(); this.y = inity; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 Invoking a constructor: allocates space for a new object in the heap includes slots for all fields of all ancestors in the class tree (here: x and y) creates a pointer to the class this is the object s dynamic type runs the constructor body aper pushing parameters and this onto the stack Note: fields start with a sensible default - 0 for numeric values - null for references Counter extends Object Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

31 Calling super Workspace Stack Heap Class Table super(); this.y = inity; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 Counter extends Object Call to super: The constructor (implicitly) calls the super constructor Invoking a method/constructor pushes the saved workspace, the method params (none here) and a new this pointer. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

32 Abstract Stack Machine Workspace Stack Heap Class Table super(); this.x = 0; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 _; this.y = inity; this Counter extends Object (Running Object s default constructor omiqed.) Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

33 Assigning to a Field Workspace Stack Heap Class Table this.x = 0; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 _; this.y = inity; this Counter extends Object Assignment into the this.x field goes in two steps: - look up the value of this in the stack - write to the x slot of that object. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

34 Assigning to a Field Workspace Stack Heap Class Table.x = 0; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 _; this.y = inity; this Counter extends Object Assignment into the this.x field goes in two steps: - look up the value of this in the stack - write to the x slot of that object. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

35 Done with the call Workspace Stack Heap Class Table ; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 _; this.y = inity; this Counter extends Object Done with the call to super, so pop the stack to the previous workspace. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

36 ConSnuing Workspace Stack Heap Class Table this.y = inity; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 Counter extends Object ConSnue in the class s constructor. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

37 Abstract Stack Machine Workspace Stack Heap Class Table this.y = 2; d = _; d.dec(); int x = d.get(); this x 0 y 0 Object String tostring(){ boolean equals inity 2 Counter extends Object Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

38 Assigning to a field Workspace Stack Heap Class Table this.y = 2; d = _; d.dec(); int x = d.get(); this x 0 y 2 Object String tostring(){ boolean equals inity 2 Counter extends Object Assignment into the this.y field. (This really takes two steps as we saw earlier, but we re skipping some for the sake of brevity ) Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

39 Done with the call Workspace Stack Heap Class Table ; d = _; d.dec(); int x = d.get(); this x 0 y 2 Object String tostring(){ boolean equals inity 2 Counter extends Object Done with the call to the constructor, so pop the stack and return to the saved workspace, returning the newly allocated object (now in the this pointer). Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

40 Returning the Newly Constructed Object Workspace Stack Heap Class Table d = ; d.dec(); int x = d.get(); x 0 y 2 Object String tostring(){ boolean equals ConSnue execusng the program. Counter extends Object Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

41 AllocaSng a local variable Workspace Stack Heap Class Table d.dec(); int x = d.get(); d x 0 Object String tostring(){ y 2 boolean equals Counter extends Object Allocate a stack slot for the local variable d. Note that it s mutable (bold box in the diagram). Aside: since, by default, fields and local variables are mutable, we open omit the bold boxes and just assume the contents can be modified. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

42 Dynamic Dispatch: Finding the Code Workspace Stack Heap Class Table.dec(); int x = d.get(); d x 0 Object String tostring(){ y 2 boolean equals Counter extends Object Invoke the dec method on the object. The code is found by pointer chasing through the class hierarchy. This process is called dynamic dispatch: Which code is run depends on the dynamic class of the object. (In this case,.) Search through the methods of the, class trying to find one called dec. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

43 Dynamic Dispatch: Finding the Code Workspace Stack Heap Class Table this.incby(-this.y); d Object _; int x = d.get(); this x 0 y 2 String tostring(){ boolean equals Counter extends Object Call the method, remembering the current workspace and pushing the this pointer and any arguments (none in this case). Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

44 Reading A Field s Contents Workspace Stack Heap Class Table this.incby(-.y); d Object _; int x = d.get(); this x 0 y 2 String tostring(){ boolean equals Counter extends Object Read from the y slot of the object. Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

45 Dynamic Dispatch, Again Workspace Stack Heap Class Table.incBy(-2); d Object _; int x = d.get(); this x 0 y 2 String tostring(){ boolean equals Invoke the incby method on the object via dynamic dispatch. In this case, the incby method is inherited from the parent, so dynamic dispatch must search up the class tree, looking for the implementason code. The search is guaranteed to succeed Java s stasc type system ensures this. Search through the methods of the, class trying to find one called incby. If the search fails, recursively search the parent classes. Counter extends Object Counter() { x = 0; void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

46 Running the body of incby Workspace Stack Heap Class Table this.x = this.x + d; d Object this.x = -2; _; int x = d.get(); this _; x -20 y 2 String tostring(){ boolean equals d -2 Counter extends Object this Counter() { x = 0; It takes a few steps Body of incby: - reads this.x - looks up d - computes result this.x + d - stores the answer (-2) in this.x void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

47 Aper a few more steps Workspace Stack Heap Class Table int x = d.get(); d Object x -2 String tostring(){ y 2 boolean equals Counter extends Object Counter() { x = 0; Now use dynamic dispatch to invoke the get method for d. This involves searching up the class hierarchy again void incby(int d){ int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

48 Aper yet a few more steps Workspace Stack Heap Class Table ; d Object x -2 x -2 String tostring(){ y 2 boolean equals Counter extends Object Counter() { x = 0; void incby(int d){ Done! (Phew!) int get() {return x; extends Counter (int inity) { void dec(){incby(-y);

49 Summary: this and dynamic dispatch When object s method is invoked, as in o.m(), the code that runs is determined by o s dynamic class. The dynamic class, represented as a pointer into the class table, is included in the object structure in the heap If the method is inherited from a superclass, determining the code for m might require searching up the class hierarchy via pointers in the class table This process of dynamic dispatch is the heart of OOP! Once the code for m has been determined, a binding for this is pushed onto the stack. The this pointer is used to resolve field accesses and method invocasons inside the code.

50 Refinements to the Stack Machine Code is stored in a class table, which is a special part of the heap: When a program starts, the JVM inisalizes the class table Each class has a pointer to its (unique) parent in the class tree A class stores the constructor and method code for its instances The class also stores sta)c members Constructors: Allocate space in the heap (Implicitly) invoke the superclass constructor, then run the constructor body Objects and their methods: Each object in the heap has a pointer to the class table of its dynamic type (the one it was created with via new). A method invocason o.m( ) uses o s class table to dispatch to the appropriate method code (might involve searching up the class hierarchy). Methods and constructors take an implicit this parameter, which is a pointer to the object whose method was invoked. Fields& methods are accessed with this.