1.  Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class fills in methods left blank in the parent’s class  Reserved Words  implements, interface: Multiple-inheritance  abstract: Class with some methods left blank

2.  Inheritance allows  Programs to make use of parent class methods  A degree of polymorphism when the parent class has a default version of a method to be overridden  Limitations  Programs can only extend a single class  There is no accounting for methods for which there is not a version in the parent class Note: Java’s use of inheritance providing limited polymorphism is not universal. C++, for example, always calls parent class methods, even if they are overridden.

3.  When there are multiple levels of inheritance  The classes at the top of the hierarchy are more and more general  Child classes become more specific to the application  Issues to address  Anticipating methods that all child classes must include (reserved word abstract)  Providing categories of methods that classes of a particular category must include (reserved words interface and implements)

4. GeoMetric Object -color: Color -filled: boolean +getColor(): Color +setColor(color: Color): void +isFilled(): boolean +findArea(): double +findPerimeter(): double Circle -radius: double +getRadius(): double +setRadius(radius: double): void Rectangle -width: double -height: double +getWidth(): double +setWidth(width: double): void +getHeight(): double +setHeight(double: height): void Cylinder -height: double +getHeight(): double +setHeight(height: double): void +findVolume(): double Object -private, + public, # protected -How does GeometricObject code findArea and findPerimeter

5. Definition: Some methods are left to implement in child classes Note: Parent abstract classes, with empty methods, can’t be instantiated public abstract class GeometricObject { private Color color; protected GeometricObject() {} protected GeometricObject(Color color) { this.color = color; } public String getColor()() { return color; } public void setColor(String color) { this.color = color; } public boolean isFilled() { return color==null; } public abstract double findArea(); public abstract double findPerimeter(); } Note the semicolon at the end of the abstract methods (meaning no body)

6.  In Circle public double findArea() { return radius * radius * Math.PI; } public double findPerimeter( return 2 * radius * Math.PI; }  In Rectangle public double findArea() { return width * height; } public double findPerimeter( 2 * (width + height); }  In Cylinder public double findArea() { return 2 * (super.findArea() + getRadius() * Math.PI * height; } public double findVolume() { return super.findArea() * height; }

7.  Any class with abstract methods must also be declared to be abstract  A class with no abstract methods can be declared to be abstract  Any class declared abstract cannot be instantiated  A child class of a concrete (not abstract) parent can be declared abstract  Consider: abstract class Test {}  Legal: Test test;  Illegal: Test test1 = new Test();

8.  Definition: A class-like construct consisting of constants and method signatures  Syntax: modifier interface interfaceName { *** constant declarations *** *** method signatures *** }  Usage: public class myClass implements interface1, …, interfaceN

9.  Most interfaces are public  Illegal private interface Foo{ } protected interface Bar{ }  Legal public class Enclosing { private interface Foo{ } protected interface Bar{ } }  Interface member scope  variables are public final static  methods are public Note: public interface T { public static final int x=1; public abstract void p(); } Is equivalent to: public interface T { int x = 1; void p(); }

10.  abstract class advantages over interfaces  abstract classes can have methods with bodies  abstract classes can have non-constant variables  abstract classes allows protected, private scope  Abstract classes inherit from the Object class  Interface advantages over abstract classes  A class can implement more than one interface  An interface can extend more than one parent interface  Interfaces do not inherit from a root Object  Both abstract classes and interfaces allow  Interface or abstract class names are valid types

11. public class S extends P { public static void main(String[] args) { S s = new S(); P p; Q q; R r; p = s;q = s; r = s;} interface Q {} interface R {} abstract class P implements Q, R {}

12. public class Class2 extends Class1 implements face4, face5 {} abstract class Class1 implements face3 {} interface face1 {} interface face2 {} interface face3 extends face1, face2 {} interface face4 extends face3 {} interface face5 {} face5 face4face3 face2 face1 ObjectClass1 Class2

13. public class TestEdible { public static void main(String[] args) { Object[] objs = {new Tiger(), new Chick(), new Apple() }; for (int i=0; i<objs.length; i++) if (objs[i] instanceof Eat) System.out.println(((Eat)objs[i]).how()); } interface Eat { public String how(); } class Fruit implements Eat {public String how() { return "Eat Fresh";} } class Apple extends Fruit { public String how() { return "Apple Cider"; } } abstract class Animal {} class Tiger extends Animal {} class Chick extends Animal implements Eat { public String how() { return "Nuggets"; } } Output Nuggets Apple Cider

14. public class Max { public static Object max(Object o1, Object o2) { if (((Comparable)o1).compareTo(o2) > 0)return o1; else return o2; } } public class CompareRect extends Rectangle implements comparable {public CompareRect(double width, double height) { super(width, height); } public int compareTo(Object o) { return findArea() - ((CompareRect)o).findArea()); } } package java.lang; public interface Comparable { public int compareTo(Object o); }

15. public class House implements Cloneable { public GregorianCalendar built; public House(GregorianCalendar b) { built=b; } public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException ex) { return null; } } public static void main(String[] args) { House h1 = new House( new GregorianCalendar(35, 11, 10) ); House h2 = (House)h1.clone(); h2.built.set(50, 2, 20); System.out.println( h1.built.get(Calendar.YEAR) + " " + h2.built.get(Calendar.YEAR)); } } Output: 50 50 because addresses, not contents, of built copied

16. Modify the cloneable method from the previous slide public Object clone() { try { House house = (House)super.clone(); house.built = new GregorianCalendar( built.get(Calendar.YEAR), built.get(Calendar.MONTH), built.get(Calendar.DAY_OF_MONTH)); return house; } catch (CloneNotSupportedException ex) { return null; } } Output: 35 50 because we cloned the instance variable Alternative: house.built = (GregorianCalendar)built.clone(); Many Java API classes implement “deep” clone operations

17.  Definition: A class that adds functionality to a primitive variable or another class  Examples: Double, Float, Long, Integer, Short, Byte, Character, Boolean  Additional functionality:  Implements Comparable for Java’s generic sort capabilities  Parses strings into primitive types (Integer.parseInt("32");  Java’s default conversions to and from primitive variables. int x = Integer.parseInt("1A", 16); sets x to 26 Integer intObject = 2;

18.  Definition: Automatic conversion from a primitive variable to its wrapper  Definition: Un-boxing is the automatic conversion from a wrapper object to its primitive variable counterpart  Examples:  Integer x = 3; // Boxing  int x = Integer(3); // Unboxing  double d = Double.valueOf(“93.55”); // Unboxing  String h = (Double.valueOf("23.4")).toString(); (The toString method of Double is called)

19. Java.lang.Number +byteValue(): byte +shortValue(): short +intValue(): int +longValue(): long +floatValue(): float +doubleValue(): double Java.lang.Integer -value: int +MAX_VALUE: int +MIN_VALUE: int +Integer(vallue: int) +Integer(s: String) +valueOf(s: String): Integer +valueOf(s: String, radix:int): Ingeter +parseInt(s: String): int +parseInt(s: String, radix: int): int Java.lang.Comparable +compareTo(o: Object): int