Definition: Accessing child class methods through a parent object Example: Child class overrides...

19
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

Transcript of Definition: Accessing child class methods through a parent object Example: Child class overrides...

Page 1: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 2: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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.

Page 3: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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)

Page 4: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 5: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

Definition: Some methods are left to implement in child classesNote: 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)

Page 6: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

In Circlepublic double findArea() { return radius * radius * Math.PI; }public double findPerimeter( return 2 * radius * Math.PI; }

In Rectanglepublic double findArea() { return width * height; }public double findPerimeter( 2 * (width + height); }

In Cylinderpublic double findArea() { return 2 * (super.findArea() + getRadius() * Math.PI * height; }public double findVolume() { return super.findArea() * height; }

Page 7: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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();

Page 8: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 9: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

Most interfaces are public Illegal

private   interface Foo{  }  protected interface Bar{ }  

Legalpublic 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();}

Page 10: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 11: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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 {}

Page 12: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Object Class1 Class2

Page 13: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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"; } }

OutputNuggetsApple Cider

Page 14: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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); }

Page 15: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 16: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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

Page 17: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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 26Integer intObject = 2;

Page 18: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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)

Page 19: Definition: Accessing child class methods through a parent object  Example: Child class overrides default parent class methods  Example: Child class.

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): intJava.lang.Comparable

+compareTo(o: Object): int