1. 1 / 71 COP 3503 FALL 2012 SHAYAN JAVED LECTURE 4 Programming Fundamentals using Java 1

2. 2 / 71 Inheritance  Derive new classes (subclass) from existing ones (superclass).  Only the Object class (java.lang) has no superclass  Every class = subclass of Object.

3. 3 / 71 Inheritance  Code reuse – methods and properties.  Use classes to model objects of the same type  Define general class  Then define specialized classes.

4. 4 / 71 Inheritance  Can only inherit from one class.  Can inherit from multiple classes in other languages (C++)

5. 5 / 71 Example  Let’s say you create the following classes:  Circle  Rectangle  Triangle  etc.  Share certain properties, but also specialized properties

6. 6 / 71 Example public class GeometricObject { private String Color; private String name; private float area; // constructors... public GeometricObject(String color, String name) { … } // get/set methods, etc. }

7. 7 / 71 Example public class Circle extends GeometricObject { private double radius;// specific property public Circle(double radius, String color, String name) { this.radius = radius; this.color = color; this.name = name; } // get/set methods, etc. public double getArea() { return radius * radius * Math.PI; }

8. 8 / 71 Example  An error in the constructor! public Circle(double radius, String color, String name) { this.radius = radius; this.color = color; this.name = name; }  Why can’t we use “this.color” and “this.name”?

9. 9 / 71 Example  They are private properties.  NOT accessible by subclasses.  Should use setColor() instead.  public methods/properties inherited.

10. 10 / 71 Example public class Rectangle extends GeometricObject { private double width, height;// specific properties public Rectangle(double w, double h, String color, String name) { this.height = h; this.width = w; setColor(color); setName(name); } // get/set methods, etc. public double getArea() { return width * height; }

11. 11 / 71 The super keyword  Are constructors inherited?  Yes. super used for:  calling a super class constructor  calling a super class method

12. 12 / 71 The super keyword  Constructors:  super() calls the default constructor  super(arguments) calls the constructors according to the arguments

13. 13 / 71 The super keyword  Constructors: public Circle(double radius, String color, String name) { super(color, name); this.radius = radius; }

14. 14 / 71 The super keyword  Constructors: public Circle(double radius, String color, String name) { super(color, name); this.radius = radius; } public GeometricObject(String color, String name) { this.color = color; this.name = name; }

15. 15 / 71 The super keyword What if we don’t add the super(..) constructor call?

16. 16 / 71 The super keyword public Circle(double radius, String color, String name) { this.radius = radius; }

17. 17 / 71 The super keyword public Circle(double radius, String color, String name) { this.radius = radius; } Is the same as: public Circle(double radius, String color, String name) { super(); this.radius = radius; }

18. 18 / 71 The super keyword Called Constructor Chaining

19. 19 / 71 The super keyword  Calling the super class methods  super.method(parameters)...  Optional

20. 20 / 71  Using get/set methods to access properties of the superclass is cumbersome…

21. 21 / 71 The protected keyword  Often want subclasses to directly access properties/methods  Use protected instead of private/public  Subclasses can now directly access

22. 22 / 71 Private public class GeometricObject { private String Color; private String name; private float area; // constructors... // get/set methods, etc. }

23. 23 / 71 The protected keyword public class GeometricObject { protected String Color; protected String name; protected float area; // constructors... // get/set methods, etc. }

24. 24 / 71 The protected keyword public class Circle extends GeometricObject { private double radius;// specific property public Circle(double radius, String color, String name) { this.radius = radius; this.color = color; this.name = name; } Now works!

25. 25 / 71 Polymorphism  Important aspect of OOP

26. 26 / 71 Polymorphism  Important aspect of OOP  “capability of an action or method to do different things based on the object that it is acting upon. ”

27. 27 / 71 Polymorphism  Important aspect of OOP  “capability of an action or method to do different things based on the object that it is acting upon. ”  “characteristic of being able to assign a different meaning or usage to something in different contexts - specifically, to allow an entity such as a variable, a function, or an object to have more than one form.”

28. 28 / 71 Polymorphism 1. Overriding Methods 2. Overloaded methods 3. Dynamic (late) method binding

29. 29 / 71 Overriding Methods  Sometimes need to overwrite methods written in the superclass  Re-define the method in the subclass.

30. 30 / 71 Overriding Methods  The Object class and toString()  toString() = String output when you print the object

31. 31 / 71 Overriding Methods  The Object class and toString()  toString() = String output when you print the object  Object class has default toString() method

32. 32 / 71 The toString() method public String toString() { String str;... return str; }

33. 33 / 71 The toString() method Circle circle1 = new Circle(“Circle1”, “Red”, 3.5); System.out.println(circle1); Output: ?

34. 34 / 71 The toString() method Circle circle1 = new Circle(“Circle1”, “Red”, 3.5); System.out.println(circle1); Output: Circle@19821f

35. 35 / 71 The toString() method  So override the method public String toString() { String str = “”; str += “Circle: ” + getName() + “,”; str += “Color: ” + getColor() + “,”; str += “Radius: ” + getRadius(); return str; }

36. 36 / 71 The toString() method Circle circle1 = new Circle(“Circle1”, “Red”, 3.5); System.out.println(circle1); Output: Circle: Circle1,Color: Red,Radius: 3.5

37. 37 / 71 The equals() method  The Object class and equals()  equals (Object obj) = returns whether the object passed in and this one are the same

38. 38 / 71 The equals() method  Default implementation: public boolean equals(Object obj) { return (this == obj); } Compares references

39. 39 / 71 The equals() method Circle circle1 = new Circle(3.5); Circle circle2 = new Circle(3.5);

40. 40 / 71 The equals() method Circle circle1 = new Circle(3.5); Circle circle2 = new Circle(3.5); circle1.equals(circle2); // ?

41. 41 / 71 The equals() method Circle circle1 = new Circle(3.5); Circle circle2 = new Circle(3.5); circle1.equals(circle2); // returns false!

42. 42 / 71 The equals() method Circle circle1 = new Circle(3.5); Circle circle2 = new Circle(3.5); circle1.equals(circle2); // returns false! Circle circle3 = circle1; circle1.equals(circle3); // ?

43. 43 / 71 The equals() method Circle circle1 = new Circle(3.5); Circle circle2 = new Circle(3.5); circle1.equals(circle2); // returns false! Circle circle3 = circle1; circle1.equals(circle3); // returns true!

44. 44 / 71 The equals() method  Override it public boolean equals(Object obj) { if (obj instanceof Circle) return this.radius == ((Circle)obj).getRadius(); else return false; }

45. 45 / 71 The instanceof operator  Test if object is of a specified type if (object instanceof Class)

46. 46 / 71 The instanceof operator  Test if object is of a specified type if (object instanceof Class)  Example: Circle circle1 = new Circle(3.4); if (circle1 instanceof Circle) { … }

47. 47 / 71 The instanceof operator  Testing with the SuperClass: if (subclassObj instanceof SuperClass) { … } ?

48. 48 / 71 The instanceof operator  Testing with the SuperClass: if (Circle instanceof GeometricObject) { … } ?

49. 49 / 71 The instanceof operator  Testing with the SuperClass: if (subclassObj instanceof SuperClass) { … } returns true!

50. 50 / 71 The instanceof operator  Example: Circle circle1 = new Circle(3.4); if (circle1 instanceof GeometricObject) { … } returns true!

51. 51 / 71 The instanceof operator What if we write: if (SuperClassObj instanceof subclass) { … }

52. 52 / 71 The instanceof operator if (SuperClassObj instanceof subclass) { … }  returns true as long as the object is an instance of the subclass

53. 53 / 71 The instanceof operator  Example: Object is a superclass of Circle public boolean equals(Object obj) { if (obj instanceof Circle) return this.radius == ((Circle)obj).getRadius(); else return false; }

54. 54 / 71 The instanceof operator  Be careful with null objects String s = null; s instanceof String = false

55. 55 / 71 Object casting  So we can determine if (SuperClassObj instanceof subclass)  Convert it to subclass by casting

56. 56 / 71 Object casting  So we can determine if (SuperClassObj instanceof subclass)  Convert it to subclass by casting  Can now access members/properties

57. 57 / 71 Object casting Once again... public boolean equals(Object obj) { if (obj instanceof Circle) { return this.radius == ((Circle)obj).getRadius(); } else return false; }

58. 58 / 71 Object casting Once again... public boolean equals(Object obj) { if (obj instanceof Circle) { Circle circle = (Circle)obj; // casting return this.radius == circle.getRadius(); } else return false; }

59. 59 / 71 Overloading Methods  Looked at it before.  Can have multiple methods with the same name.  But different parameters, return type

60. 60 / 71 Dynamic binding  Object type is determined at run-time  ability of a program to resolve references to subclass methods at runtime.

61. 61 / 71 Dynamic binding public class GeometricObject { protected String Color; protected String name; protected float area; public float getArea() { return -1; }

62. 62 / 71 Dynamic binding // Circle public class Circle { public float getArea() { return Math.PI * radius * radius; } // Rectangle public class Rectangle { public float getArea() { return width * height; }

63. 63 / 71 Dynamic binding GeometricObject[] objs = new GeometricObject[2];

64. 64 / 71 Dynamic binding GeometricObject[] objs = new GeometricObject[2]; objs[0] = new Circle(3); objs[1] = new Rectangle(1, 2);

65. 65 / 71 Dynamic binding GeometricObject[] objs = new GeometricObject[2]; objs[0] = new Circle(3); objs[1] = new Rectangle(1, 2); for (GeometricObject i : objs) { System.out.println(i.getArea()); }

66. 66 / 71 Dynamic binding GeometricObject[] objs = new GeometricObject[2]; objs[0] = new Circle(3); objs[1] = new Rectangle(1, 2); for (GeometricObject i : objs) { System.out.println(i.getArea()); } What’s the output?

67. 67 / 71 Dynamic binding Output: 9.0 2.0 The subclass getArea() methods are called. At run-time, Java dynamically determines the class.

68. 68 / 71 final Classes  Sometimes classes shouldn’t be allowed to be extended.  The String class for example. Use the keyword “final” final class String {... }

69. 69 / 71 final Methods  Methods which can’t be overridden in the subclasses.

70. 70 / 71 Summary...  Inheritance  super  protected  Polymorphism  Overloading  Overwriting  Dynamic binding  instanceof  Object casting  final classes and methods

71. 71 / 71 Next lecture...  Abstract Classes  Interfaces