Inheritance and Subclasses

1. Inheritance and Subclasses

2. Inheritance • Often we create very similar classes • Different types of triangles: equilateral, isosceles, etc. • Different types of quadrilaterals: squares, rectangles, parallelograms, etc. • Different types of animals: dogs, cows, etc. • It seems wasteful to write these classes from scratch • These have many features in common • Inheritance in Java allows you to extend a base class to another class with similar features

3. Inheritance • Usually a class hierarchy is implemented through inheritance • Example: a polygon hierarchy • The class that inherits from a base class becomes a subclass of the base class • The constructors are not inherited • Each subclass must offer its own constructor; however it is possible to access the constructors of the base class • All public members and methods are inherited in the subclass • The subclass may define additional members and methods; same methods override those in the base class

4. Polygon hierarchy class Point { // to be used later private double x; private double y; public Point (double x, double y) { this.x = x; this.y = y; } public Point (Point p) { // copy constructor this.x = p.GetX(); this.y = p.GetY(); } // next slide

5. Polygon hierarchy public double GetX () { return x; } public double GetY () { return y; } public void SetX (double x) { this.x = x; } public void SetY (double y) { this.y = y; } // next slide

6. Polygon hierarchy public double Distance (Point p) { return Math.sqrt ((x-p.GetX())*(x-p.GetX()) + (y-p.GetY())*(y-p.GetY())); } } // end class

7. Polygon hierarchy class Polygon { private int numVertices; public Point vertices[]; public Polygon (Point vertices[]) { int i; numVertices = vertices.length; this.vertices = new Point[numVertices]; for (i=0; i<numVertices; i++) { this.vertices[i] = new Point (vertices[i]); } } // next slide

8. Polygon hierarchy public Polygon (double x[], double y[]) { int i; numVertices = x.length; vertices = new Point[numVertices]; for (i=0; i<numVertices; i++) { vertices[i] = new Point (x[i], y[i]); } } // next slide

9. Polygon hierarchy public double Perimeter () { int i; double perimeter = 0; // Assume that the vertices are in order for (i=0; i<numVertices-1; i++) { perimeter += vertices[i].Distance (vertices[i+1]); } perimeter += vertices[i].Distance (vertices[0]); System.out.println (“This is perimeter of Polygon class.”); return perimeter; } // next slide

10. Polygon hierarchy public boolean isRegular () { int i; double lastSide = vertices[0].Distance (vertices[1]); double thisSide; for (i=1; i<numVertices-1; i++) { thisSide = vertices[i].Distance (vertices[i+1]); if (lastSide != thisSide) return false; } // next slide

11. Polygon hierarchy thisSide = vertices[i].Distance (vertices[0]); if (lastSide != thisSide) return false; return true; } // next slide

12. Polygon hierarchy public Point Centroid () { int i; double x = 0, y = 0; for (i=0; i<numVertices; i++) { x += vertices[i].GetX(); y += vertices[i].GetY(); } return (new Point (x/numVertices, y/numVertices)); } } // end class

13. Polygon hierarchy class Triangle extends Polygon { private double a, b, c; // new members public Triangle (Point vertices[]) { super (vertices); // base class constr. // Other member initialization must // come after call to super a = vertices[0].Distance (vertices[1]); b = vertices[1].Distance (vertices[2]); c = vertices[2].Distance (vertices[0]); } // next slide

14. Polygon hierarchy public Triangle (double x[], double y[]) { super (x, y); a = vertices[0].Distance (vertices[1]); b = vertices[1].Distance (vertices[2]); c = vertices[2].Distance (vertices[0]); } // next slide

15. Polygon hierarchy // Add a new method public double Area () { double term1 = 0.5*Perimeter () – a; double term2 = 0.5*Perimeter () – b; double term3 = 0.5*Perimeter () – c; return (Math.sqrt (0.5*Perimeter () * term1 * term2 * term3)); } // next slide

16. Polygon hierarchy // One more new method public double[] Angles () { double angles[] = new double[3]; angles[0] = Math.asin (2*Area()/(b*c)); angles[1] = Math.asin (2*Area()/(c*a)); angles[2] = Math.asin (2*Area()/(a*b)); return angles; } // next slide

17. Polygon hierarchy // Override Perimeter with a simpler one public double Perimeter () { System.out.println (“This is perimeter of Triangle class.”); return (a+b+c); } } // end class // next slide

18. Polygon hierarchy class Equilateral extends Triangle { public Equilateral (Point vertices[]) { super (vertices); } public Equilateral (double x[], double y[]) { super (x, y); } public double Median () { return (0.5*vertices[0].Distance(vertices[1])*Math.sqrt (3.0)); } } // end class

19. Polygon hierarchy class PolygonBuilder { public static void main (String a[]) { double x[] = {0, 0.5, -0.5}; double y[] = {0.5*Math.sqrt(3.0), 0, 0}; Equilateral eqT = new Equilateral (x, y); System.out.println (“Perimeter: ” + eqT.Perimeter()); System.out.println (“Area: ” + eqT.Area()); System.out.println (“Centroid: (” + eqT.Centroid().GetX() + “, ” + eqT.Centroid().GetY() + “)”); System.out.println (“Median: ” + eqT.Median()); } } // end class

20. protected Data & Methods • A protected data or method in a public can be accessed by any class in the same package or subclass in other package

21. Example package p1; public class C1{ protected int y; public int x; private int u; protected void m(){ } }

22. public class C2{ } public class C3 extends C1{ } package p2; public class C4 extends C1{ } public class C5{ }

23. Preventing Extending and Overriding Use Keyword final public final class C{ } //no subclasses public class test{ public final void m(){ } }

24. Abstract classes A superclass which can not have any specific instances can be declared abstract. Methods which can not be implemented in an abstract class use modifier abstract.

25. public abstract class Geometricobject{ private String color = “white”; private boolean filled; private java.util.DatedateCreated; protected Geometricobject(){ dateCreated=new java.util.Date(); } public String getColor(){ return color; } …. public abstract double getArea(); public abstract double getPerimeter(); }

26. public class TestGO{ public static void main(String[] args){ GeometricObject o1= new Circle(5); GeometricObject o2= new rect(5,3); System.out.println (“Equal area?”+ equalArea (o1,o2); displayGO(o1); displayGO(o2); } public static boolean equalArea (GeometricObject o1, GeometricObject o2){ return o1.getArea()==o2.getArea(); } public static void displayGO(GeometricObject o){ System.out.println (); System.out.println (“Area” + o.getArea()); System.out.println (“Perimeter” + o.getPerimeter()); } }

27. Multiple inheritance • Java does not allow inheritance from more than one base classes • At most one extension • However, one can “implement” multiple interfaces • Interface is a collection of abstract methods i.e. no method body is specified • A class implementing an interface must provide the suitable method bodies

28. Multiple inheritance interface RegularPolygon { public double Circumradius (); //abstract } class Equilateral extends Triangle implements RegularPolygon { public Equilateral (Point vertices[]) { super (vertices); } public Equilateral (double x[], double y[]) { super (x, y); } // next slide

29. Multiple inheritance public double Median () { return (0.5*vertices[0].Distance(vertices[1])*Math.sqrt (3.0)); } public double Circumradius () { return (2*Median()/3); } } // end class // You can now print eqT.Circumradius() in // PolygonBuilder class.

30. Comparable interface package java.lang; public interface Comparable{ public int compareTo(Object o); } public class String extends Object implements Comparable{ } public class Date extends Object implements Comparable{ } Each of these have to define method compareTo in its body.