Extending Classes (contd.) (Chapter 15) Questions:

Transcription

1 Extending Classes (contd.) (Chapter 15) Questions: 1

2 1. The following C++ program compiles without any problems. When run, it even prints out the hello called for in line (B) of main. But subsequently the program aborts with a memory segmentation fault. Why? 2

3 class X { int* p; int size; public: X() { p = 0; size = 0; X( int* ptr, int sz ) : size( sz ) { p = new int[ size ]; for ( int i=0; i<size; i++ ) p[i] = ptr[i]; ~X() { delete[] p; ; class Y : public X { int n; public: Y() {; Y( int* ptr, int sz, int nn ) : X( ptr, sz ), n( nn ) { Y( const Y& other ) : X( other ), n( other.n ) { Y& operator=( const Y& other ) { if ( this == &other ) return *this; X::operator=( other ); n = other.n; return *this; ; int main() { int data[ 3 ] = {3, 2, 1; Y y1( data, 3, 10 ); Y y2; y2 = y1; cout << "hello" << endl; return 0; //(A) //(B) 3

4 2. In terms of what happens at compile time and what happens at run time, what s the difference between function overloading and function overriding? 4

5 3. What program declaration makes it possible for a function to behave polymorphically? 5

6 4. What is meant by static binding and what is meant by dynamic binding? 6

7 5. Does overload resolution result in static binding or dynamic binding? 7

8 6. What is RTTI and what s it used for? 8

9 7. What is meant by a polymorphic type? 9

10 8. While polymorphic behavior of a function is obviously important, why is the concept of a polymorphic type important also? 10

11 Virtual Destructors in C++ Even when a base class does not directly appropriate system resources, you may still need to declare its destructor virtual if you want polymorphic destruction of derived-class objects. 11

12 Consider the case of a vector of pointers to the base-class type, where some of the pointers are actually pointing to objects of a derived-class type. Let s say that you now set up a loop in which you invoke the delete operator on each of the pointers, with the hope that the destructor invoked for each object would be the one defined specifically for it. In other words, you d want the destructor invocation to behave polymorphically. This will only happen if you declare the destructor to be virtual in the base class. 12

13 A simple demonstration of a virtual destructor in action, consider... #include <iostream> using namespace std; class X { public: virtual ~X(); ; // BASE //(A) X::~X(){ cout << "X s destructor" << endl; //(B) class Y : public X { // DERIVED public: ~Y() { cout << "Y s destructor" << endl; ; class Z : public Y { // DERIVED public: ~Z() { cout << "Z s destructor" << endl; ; int main() { X* p = new Z(); //(C) delete p; //(D) return 0; 13

14 Inmain of the above program, we construct an object of typezand assign it to a base-class pointer of type X* in line (C). When we invoke delete on this pointer in line (D), we get the following output from the program: Z s destructor Y s destructor X s destructor 14

15 What would be the output of the program for the following in main: Y* q = new Z(); delete q; What would be the output of the program if the keyword virtual was dropped in line (A) of the program? 15

16 Constructor Order Dependencies in C++ Order dependency in a derived-class constructor refers to the order in which the base-class sub-objects are constructed inside a derived-class object; the order in which the specified initializations carried for the data members of the derived class; etc. 16

17 class X { public: X() { cout << "X object under construction" << endl; ; class Y { public: Y() { cout << "Y object under construction" << endl; ; class Base { X xobj; // (A) Y yobj; // (B) public: Base() : xobj( X() ), yobj( Y() ) { // (C) ; int main() { Base b; 17

18 The official rules for the order in which the code for a derived-class constructor is executed are: 1. When a derived-class constructor is invoked, first the memory needed for constructing the derived-class object is appropriated. 2. Next, the constructor of the base-class is invoked to construct the baseclass slice of the derived-class object. (If the derived class has multiple bases, the base-class constructor for each base is invoked in the order in which the bases are declared in the header of the derived class, and regardless of the order used by the programmer in his/her coding of the derived-class constructor.) 3. If the derived-class constructor uses the member initialization syntax for the data member of the derived class, invoke the initializers in the order in which the data members are declared in the class definition, and regardless of the order they are shown in the member initialization syntax by the programmer. 4. Execute the code in the body of the derived-class constructor. 18

19 class X { public: virtual void foo(){ cout << "X s foo invoked" << endl; X() { foo(); ; class Y : public X { public: void foo(){ cout << "Y s foo invoked" << endl; Y() { ; int main() { Y yobj; 19

20 Abstract Classes in C++ Shape /\ /\ /\ / \ / \ / \ / \ / \ / \ / \ / \ Circle Rectangle... double area( ); double circumference(); class Shape { public: virtual double area( ); virtual double circumference(); //... ; 20

21 class Shape { public: virtual double area( ) = 0; virtual double circumference() = 0; //... ; Shape* shapes[ 3 ]; shapes[0] = new Circle(... ); shapes[1] = new Rectangle(... ); shapes[2] = new Rectangle(... ); double total_area = 0; for (int i=0; i < 3; i++ ) total_area += shapes[i]->area(); // (A) 21

22 #include <iostream> class Shape { public: virtual double area() = 0; virtual double circumference() = 0; ; class Circle : public Shape { protected: double r; static double PI; public: Circle() { r = 1.0; Circle( double r ) { this->r = r; ; double area() { return PI*r*r; double circumference() { return 2 * PI * r; double getradius() {return r; double Circle::PI = ; class Rectangle : public Shape { double w, h; public: Rectangle() { w=0.0; h = 0.0; Rectangle( double w, double h ) { this->w = w; this->h = h; ; double area() { return w * h; double circumference() { return 2 * (w + h); double getwidth() { return w; double getheight() { return h; 22

23 int main() { Shape* shapes[ 3 ]; shapes[0] = new Circle( 2.0 ); shapes[1] = new Rectangle( 1.0, 3.0 ); shapes[2] = new Rectangle( 4.0, 2.0 ); double total_area = 0; for (int i=0; i < 3; i++ ) total_area += shapes[i]->area(); cout << "Total area = " << total_area << endl; 23

24 A C++ class is abstract if it has at least one virtual function that is pure. As one would expect, it is not possible to make objects of a class that is abstract. Therefore, the sole purpose of an abstract class is to serve as an interface to the derived classes. You could also say that an abstract class serves as an organizational principle in a class hierarchy. A pure virtual function that is not defined in a derived class remains a pure virtual function. So, in such a case, the derived class is also an abstract class. This allows us to build an implementation in stages. 24

25 Shape /\ /\ /\ / \ / \ / \ / \ / \ / \ / \ / \ Polygon... CurvedShape /\ /\ /\ /\ /\ /\ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ Square Rectangle... Circle Ellipse... 25

26 #include <iostream> class Shape { public: virtual double area() = 0; virtual double circumference() = 0; ; class Polygon : public Shape { protected: int numvertices; bool starshaped; ; class CurvedShape : public Shape { public: virtual void polygonalapprox() = 0; ; class Circle : public CurvedShape { protected: double r; static double PI; public: Circle() { r = 1.0; Circle( double r ) { this->r = r; double area() { return PI*r*r; double circumference() { return 2 * PI * r; double getradius() {return r; void polygonalapprox() { 26

27 ; cout << "polygonal approximation code goes here" << endl; double Circle::PI = ; class Rectangle : public Polygon { double w, h; public: Rectangle() { w=0.0; h = 0.0; numvertices = 0; starshaped = true; Rectangle( double w, double h ) { this->w = w; this->h = h; numvertices = 4; starshaped = true; double area() { return w * h; double circumference() { return 2 * (w + h); double getwidth() { return w; double getheight() { return h; ; int main() { Shape* shapes[ 3 ]; shapes[0] = new Circle( 2.0 ); shapes[1] = new Rectangle( 1.0, 3.0 ); shapes[2] = new Rectangle( 4.0, 2.0 ); double total_area = 0; for (int i=0; i < 3; i++ ) 27

28 total_area += shapes[i]->area(); cout << "Total area = " << total_area << endl; 28

29 Protected and Private Derived Classes in C++ class Derived_class : public Base_class { //... ; class Derived_class : private Base_class { //... ; results in what s referred to as implementation inheritance. This name reflects the fact this kind of derivation is good primarily for using locally the non-private interface of the base class, but not for making this inherited interface available to other classes, or even to further derived classes. 29

30 A special case of this implementation inheritance is the protected inheritance obtained by a protected derivation, as in class Derived_class : protected Base_class { //... ; Now the non-private interface inherited from the base class is made available for inheritance to only the subclasses of the Derived class. 30

31 When you do not carry out a public derivation, you can no longer assign a Derived* to a Base* without explicit conversion. For example, in our Employee Manager example, if we had derived Manager using the following syntax class Manager : protected Employee { // same as before ; we would no longer be allowed to say Employee* e3 = new Manager( "ms", "importante" ); because a Manager is no longer automatically an Employee. Now if wish to make a single list, in the form of a vector, ofemployee* types, we must first use explicit conversion as in Employee* e3 = (Employee*) new Manager( "ms", "importante" ); 31

32 Employee ^ > ExecutiveRole / Manager ^ Director class ExecutiveRole { public: void sayexecutivehello(){ cout << "Hello from Executive ranks" << endl; ; 32

33 #include <iostream.h> #include <mstring.h> #include <vector.h> class Employee { string firstname, lastname; int age, yearsinservice; //... public: Employee( string fnam, string lnam ) { firstname = fnam; lastname = lnam; virtual void print() const { cout << firstname << " " << lastname << endl; void sayemployeehello() { cout << "hello from Employee class" << endl; ; 33

34 class ExecutiveRole { public: void sayexecutivehello(){ cout << "Hello from Executive ranks" << endl; ; //class Manager : public Employee, private ExecutiveRole { class Manager : public Employee, protected ExecutiveRole { short level; //.. public: Manager( string fnam, string lnam, short lvl ) : Employee( fnam, lnam ), level( lvl ) { cout<< "In Manager constructor: "; sayemployeehello(); sayexecutivehello(); // WILL NOT CO // WORKS FINE void print() const { Employee::print(); cout << "level: " << level << endl; ; 34

35 class Director : public Manager { short grade; //... public: Director( string fnam, string lnam, short lvl, short gd ) : Manager( fnam, lnam, lvl ), grade( gd ) { cout << "In Director constructor: "; sayemployeehello(); sayexecutivehello(); void print() const { Manager::print(); cout << "grade: " << grade << endl << endl; ; int main() { vector<employee*> emplist; Employee* e1 = new Employee( "john", "doe" ); Employee* e2 = (Employee*) new Manager( "jane", "joe", 2 ); Employee* e3 = (Employee*) new Director( "mister", "bigshot", 3, 4 ); emplist.push_back( e1 ); emplist.push_back( e2 ); emplist.push_back( e3 ); vector<employee*>::iterator p = emplist.begin(); while ( p < emplist.end() ) (*p++)->print(); 35

36 // e3->sayhi(); Manager* m = new Manager( "jane", "doe", 2 ); m->sayemployeehello(); Director* d = new Director( "john", "doe", 3, 4 ); d->sayemployeehello(); 36

37 Extending Classes in Java What is accomplished by making a public derivation from a class in C++ is achieved by using the extends clause in Java. 37

38 class Employee { private String firstname, lastname; //... public Employee( String fnam, String lnam ) { firstname = fnam; lastname = lnam; public void print() { System.out.print( firstname + " " + lastname ); class Manager extends Employee { private short level; //... public Manager( String fnam, String lnam, short lvl ) { super( fnam, lnam ); level = lvl; public void print() { super.print(); System.out.println( "level: " + level ); 38

39 Object construction in Java has one feature that is not shared by object construction in C++: If a derived-class constructor in Java does not invoke the base class s constructors (or if the base class does not have a no-arg constructor), the derived-class constructor is allowed to invoke another one of the constructors for the derived class by using the this() construct. 39

40 class Manager extends Employee { private short level; //... public Manager( String fnam, String lnam, short lvl ) { super( fnam, lnam ); level = lvl; public Manager( String fnam, String lnam ) { this( fnam, lnam, 10 ); public void print() { super.print(); System.out.println( "level: " + level ); 40

41 With regard to the base-class functions that are available in a derived class, another very important difference between C++ and Java is as follows: In C++ a derived-class function of a given name hides all base-class functions of the same name, regardless of their signatures; the hidden names can only be accessed through the scope operator in the derived class. That is not the case in Java. 41

42 //NameLookup.java class Base { public void foo() { System.out.println( "Base s foo() invoked" ); public void foo( int i ) { System.out.println( "Base s foo( int ) invoked" ); public void foo( int i, int j ) { System.out.println( "Base s foo( int, int ) invoked" ); class Derived extends Base { public void foo() { System.out.println( "Derived s foo() invoked" ); //(A) //(B) //(C) //(D) public class Test { public static void main( String[] args ) { Derived d = new Derived(); d.foo(); // Derived s foo() invoked //(E) d.foo( 3 ); // Base s foo( int ) invoked //(F) d.foo( 3, 4 ); // Base s foo( int, int ) invoked //(G) 42

43 //NameLookup.cc // WILL NOT COMPILE #include <iostream> using namespace std; class Base { public: void foo() { cout << "Base s foo() invoked" << endl; void foo( int i ) { cout << "Base s foo( int ) invoked" << endl; void foo( int i, int j ) { cout << "Base s foo( int, int ) invoked" << endl; ; class Derived : public Base { public: void foo() { cout << "Derived s foo() invoked" << endl; ; int main() { Derived d; d.foo(); d.foo( 3 ); d.foo( 3, 4 ); //(A) //(B) //(C) //(D) //(E) //(F) //(G) 43

44 Restrictions on Overriding Functions in Java The definition of an overriding method in a derived class must not violate the following restrictions: 1. The return type of an overriding method in a derived class must be the same as the return type of the overridden method in the base class. class X { public float foo( double m ) { return m; class Y extends public X { public double foo( double n ) { return n; // Er 44

45 2. The access restriction for an overriding method can be no tighter than the restriction on the base-class overridden method. So if the access restriction on the base-class method is, say, protected, the overriding method in the derived class can either be protected or public, but not private. 45

46 3. The exception specification for an overriding function in a derived class must be a subset of the exception specification on the overridden baseclass method. class Exception_1 extends Exception { class Exception_2 extends Exception { class X { private int m; public X( int mm ) { m = mm; public void foo() throws Exception_1 { System.out.println( "X s foo invoked" ); throw new Exception_1(); class Y extends X { private int n; public Y( int mm, int nn ) { super( mm ); n = nn; public void foo() throws Exception_2 { // WRON System.out.println( "Y s foo invoked" ); throw new Exception_2(); 46

47 class Exception_1 extends Exception { class Exception_2 extends Exception { class X { private int m; public X( int mm ) { m = mm; public void foo() throws Exception_1 { System.out.println( "X s foo invoked" ); throw new Exception_1(); class Y extends X { private int n; public Y( int mm, int nn ) { super( mm ); n = nn; public void foo() { System.out.println( "Y s foo invoked" ); 47

48 Constructor Order Dependencies in Java 1. Invoke the constructor of the derived class by appropriating the required amount of memory and set all the data members in this memory to their default values (zero for all numeric types, false for boolean, \u0000 for char, and null for object reference). 2. Invoke the base-class constructor. 3. If there is any initialization code attached to any of the data members in the base class, it is executed and the data members initialized. 4. Execute the code in the body of the base class constructor. This base class constructor could be a no-arg constructor. 5. If there is any initialization code attached to any of the data members in the derived class, it is now executed and the data members initialized. 6. Execute the code in the body of the derived class constructor. 48

49 class X { void foo(){ System.out.println( "X s foo invoked" ); public X() { foo(); class Y extends X { void foo(){ System.out.println( "Y s foo invoked" ); public Y() { class Test { public static void main( String[] args ) { Y yobj = new Y(); The output of this program is Y s foo invoked 49

50 Abstract Classes in Java abstract class Shape { abstract public double area( ); abstract public double draw(); //... 50

51 abstract class Shape { abstract protected double area(); abstract protected double circumference(); abstract class Polygon extends Shape { protected int numvertices; protected boolean starshaped; abstract class curvedshape extends Shape { abstract public void polygonalapprox(); class Circle extends curvedshape { protected double r; protected static double PI = ; public Circle() { r = 1.0; public Circle( double r ) { this.r = r; public double area() { return PI*r*r; public double circumference() { return 2 * PI * r; public double getradius() {return r; public void polygonalapprox() { System.out.println("polygonal approximation code goes here"); 51

52 class Rectangle extends Polygon { double w, h; public Rectangle() { w=0.0; h = 0.0; numvertices = 0; starshaped = true; public Rectangle( double w, double h ) { this.w = w; this.h = h; numvertices = 4; starshaped = true; public double area() { return w * h; public double circumference() { return 2 * (w + h); public double getwidth() { return w; public double getheight() { return h; class test { public static void main( String[] args ) { Shape[] shapes = new Shape[ 3 ]; shapes[0] = new Circle( 2.0 ); shapes[1] = new Rectangle( 1.0, 3.0 ); shapes[2] = new Rectangle( 4.0, 2.0 ); double total_area = 0; for (int i=0; i < shapes.length; i++ ) total_area += shapes[i].area(); System.out.println("Total area = " + total_area); 52

53 public abstract class WindowAdapter implements WindowListener public void windowactivated( WindowEvent e ) {; public void windowclosed( WindowEvent e ) {; public void windowclosing( WindowEvent e ) {; public void windowdeactivated( WindowEvent e ) {; public void windowdeiconified( WindowEvent e ) {; public void windowiconified( WindowEvent e ) {; public void windowopened( WindowEvent e ) {; 53

54 With regard to abstract methods, Java has one feature not possessed by C++: In a class hierarchy, any method inherited from any of the superclasses can be declared to be abstract, making that particular class in the hierarchy an abstract class. This can be useful when it is necessary to block the inherited definition of a method to one or more derived classes in a class hierarchy. 54

55 Interfaces in Java interface Drawable { public void setcolor( Color c ); public void setposition( double x, double y ); public void draw( DrawWindow dw ); class DrawableRectangle extends Rectangle implements Drawable { private Color c; private double x, y; public DrawableRectangle( double w, double h ) { super( w, h ); public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; this.y = y; public void draw( DrawWindow dw ) { dw.drawrect( x, y, w, h, c ); 55

56 Shape (abstract) /\ /\ / \ / \ Drawable /\ /\ Rectangle Circle / \ / \ /\ /\ / \ / \ \ \ / \ \ / \ \ / \ \ / \ \/ \ / \ \ / \ DrawableRectangle DrawableCircle

57 Shape[] shapes = new Shape[3]; Drawable[] drawables = new Drawable[3]; DrawableCircle dc = new DrawableCircle( 1.1 ); DrawableSquare ds = new DrawableSquare( 2.5 ); DrawableRectangle dr = new DrawableRectangle( 2.3, 4.5 ); shapes[0] = dc; shapes[1] = ds; shapes[2] = dr; drawables[0] = dc; drawables[1] = ds; drawables[2] = dr; 57

58 double total_area = 0; for (int i = 0; i < shapes.length; i++ ) { total_area += shapes[i].area(); drawables[i].setposition( i*10.0, i*10.0 ); // drawables[i].draw( draw_window ); // 58

59 abstract class Shape { abstract protected double area(); abstract protected double circumference(); class Circle extends Shape { protected double r; protected static double PI = ; public Circle( double r ) { this.r = r; public double area() { return PI*r*r; public double circumference() { return 2 * PI * r; class Rectangle extends Shape { double w, h; public Rectangle( double w, double h ) { this.w = w; this.h = h; public double area() { return w * h; public double circumference() { return 2 * (w + h); interface Drawable { public void setcolor( Color c ); public void setposition( double x, double y ); public void draw( DrawWindow dw ); 59

60 class DrawableRectangle extends Rectangle implements Drawable { private Color c; private double x, y; public DrawableRectangle( double w, double h ) { super( w, h ); // Implementations of the methods inherited from the interface: public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; this.y = y; public void draw( DrawWindow dw ) { dw.drawrect( x, y, w, h, c ); class DrawableCircle extends Circle implements Drawable { private Color c; private double x, y; public DrawableCircle( double rad ) { super( rad ); public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; this.y = y; public void draw( DrawWindow dw ) { dw.drawcircle( x, y, r, c ); class Color { int R, G, B; 60

61 class DrawWindow { public DrawWindow() {; public void drawrect( double x, double y, double width, double height, Colo { System.out.println( "Code for drawing a rect needs to be invoked" ); public void drawcircle( double x, double y, double radius, Color col ) { System.out.println( "Code for drawing a circle needs to be invoked" ); class test { public static void main( String[] args ) { Shape[] shapes = new Shape[3]; Drawable[] drawables = new Drawable[3]; DrawableCircle dc = new DrawableCircle( 1.1 ); DrawableRectangle dr1 = new DrawableRectangle( 2.5, 3.5 ); DrawableRectangle dr2 = new DrawableRectangle( 2.3, 4.5 ); shapes[0] = dc; shapes[1] = dr1; shapes[2] = dr2; drawables[0] = dc; drawables[1] = dr1; drawables[2] = dr2; int total_area = 0; DrawWindow dw = new DrawWindow(); 61

62 for (int i = 0; i < shapes.length; i++ ) { total_area += shapes[i].area(); drawables[i].setposition( i*10.0, i*10.0 ); drawables[i].draw( dw ); System.out.println("Total area = " + total_area); // (A) // (B) 62

63 Code for drawing a circle needs to be invoked Code for drawing a rect needs to be invoked Code for drawing a rect needs to be invoked Total area = 21 63

64 Implementing Multiple Interfaces in Java interface Scalable { public Shape scaletransform(); class DrawableScalableRectangle extends Rectangle implements Drawable, Scalable { // the methods of the Drawable and Scalable interfaces // must be implemented here 64

65 Extending Interfaces in Java interface Drawable { public void setcolor( Color c ); public void setposition( double x, double y ); public void draw( DrawWindow dw ); interface DrawScalable extends Drawable { public void drawscaledshape( int scalefactor, DrawWindow dw ); 65

66 class DrawScalableRectangle extends Rectangle implements DrawScala private Color c; private double x, y; public DrawScalableRectangle( double w, double h ) { super( w, // Implementations of the methods inherited from the interface public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; th public void draw( DrawWindow dw ) { dw.drawrect( x, y, w, h, c public void drawscaledshape( int scalefactor, DrawWindow dw ) { dw.drawscaledrect( x, y, w, h, c, scalefactor ); 66

67 abstract class Shape { abstract protected double area(); abstract protected double circumference(); class Circle extends Shape { protected double r; protected static double PI = ; public Circle( double r ) { this.r = r; public double area() { return PI*r*r; public double circumference() { return 2 * PI * r; class Rectangle extends Shape { double w, h; public Rectangle( double w, double h ) { this.w = w; this.h = h; public double area() { return w * h; public double circumference() { return 2 * (w + h); interface Drawable { public void setcolor( Color c ); public void setposition( double x, double y ); public void draw( DrawWindow dw ); 67

68 interface DrawScalable extends Drawable { public void drawscaledshape( int scalefactor, DrawWindow dw ); class DrawScalableRectangle extends Rectangle implements DrawScalable { private Color c; private double x, y; public DrawScalableRectangle( double w, double h ) { super( w, h ); // Implementations of the methods inherited from the interface: public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; this.y = y; public void draw( DrawWindow dw ) { dw.drawrect( x, y, w, h, c ); public void drawscaledshape( int scalefactor, DrawWindow dw ) { dw.drawscaledrect( x, y, w, h, c, scalefactor ); class DrawScalableCircle extends Circle implements DrawScalable { private Color c; private double x, y; public DrawScalableCircle( double rad ) { super( rad ); public void setcolor( Color c ) { this.c = c; public void setposition( double x, double y ) { this.x = x; this.y = y; public void draw( DrawWindow dw ) { dw.drawcircle( x, y, r, c ); public void drawscaledshape( int scalefactor, DrawWindow dw ) { dw.drawscaledcircle( x, y, r, c, scalefactor ); 68

69 class Color { int R, G, B; class DrawWindow { public DrawWindow() {; public void drawrect( double x, double y, double width, double height, Colo { System.out.println( "Code for drawing a rect needs to be invoked" ); public void drawscaledrect( double x, double y, double width, double height, Color col, int scale ) { System.out.println( "Code for drawing a scaled rect needs to be invoked public void drawcircle( double x, double y, double radius, Color col ) { System.out.println( "Code for drawing a circle needs to be invoked" ); public void drawscaledcircle( double x, double y, double radius, Color col, int scale ) { System.out.println( "Code for drawing a scaled circle needs to be invok 69

70 class test { public static void main( String[] args ) { Shape[] shapes = new Shape[3]; DrawScalable[] drawscalables = new DrawScalable[3]; DrawScalableCircle dc = new DrawScalableCircle( 1.1 ); DrawScalableRectangle dr1 = new DrawScalableRectangle( 2.5, 3.5 ); DrawScalableRectangle dr2 = new DrawScalableRectangle( 2.3, 4.5 ); shapes[0] = dc; shapes[1] = dr1; shapes[2] = dr2; drawscalables[0] = dc; drawscalables[1] = dr1; drawscalables[2] = dr2; int total_area = 0; DrawWindow dw = new DrawWindow(); for (int i = 0; i < shapes.length; i++ ) { total_area += shapes[i].area(); drawscalables[i].setposition( i*10.0, i*10.0 ); // (A) drawscalables[i].drawscaledshape( 2, dw ); // System.out.println("Total area = " + total_area); 70

71 Code for drawing a scaled circle needs to be invoked Code for drawing a scaled rect needs to be invoked Code for drawing a scaled rect needs to be invoked Total area = 21 71

72 Constants in Interfaces class A { public static final double PI = ; class test { //... void foo() { double x = A.PI; //... 72

73 interface A { public static final double PI = ; class test implements A { //... void foo() { double x = PI; //... 73