1 / 29

Inheritance

Inheritance. Inheritance. Early programmers often wrote code very similar to existing code Example: A human resources system might handle different types of personnel. Much of the code for different classifications of personnel would be identical

ramona
Download Presentation

Inheritance

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Inheritance

  2. Inheritance • Early programmers often wrote code very similar to existing code • Example: A human resources system might handle different types of personnel. Much of the code for different classifications of personnel would be identical • This was often handled by cutting and pasting code and then modifying • Needed a way to capture and formalize the similarity

  3. Inheritance Natural, hierarchical way of organizing things. (superclass) Staff Member Employee Volunteer Hourly Salaried Consultant (subclass of Staff) (subclass of Employee) (subclass of Hourly) Think in terms of “is a” relationships: An Employee is a Staff Member, as is a Volunteer. An Hourly worker is a(n) Employee. A Consultant is a(n) Hourly employee.

  4. Classes and Subclasses Don’t worry about “private” and “public” for now class Animal { public String name = ""; public String noise = ""; public int numTimesPerformed = 0; // constructors, accessors & modifiers go here public void identifySelf( ) { System.out.println(“My name is “ + name); } // of identifySelf public void perform( ) { doYourThing( ); numTimesPerformed++; } // of perform public void doYourThing( ) { ; // ‘no-op’ method } // of doYourThing } // of Animal So, animals have a name and noise and they can identify themselves, perform and do their thing. Animal harpo = new Animal(); harpo.setName(“Harpo”); harpo.doYourThing(); // says nothing

  5. Animal Dog Cat Human Subclasses (Dog extends Animal i.e. “A dog is an animal” or “All dogs are animals”) class Dog extends Animal { public Dog() { noise = “Woof”; } // of constructor public void doYourThing ( ) { identifySelf(); System.out.println(“I am a dog”); System.out.println(noise); } // of doYourThing } // of Dog Recall: The Animal class had a no-op method for doYourThing() Dog pickles = new Dog(); pickles.setName(“Pickles”); pickles.doYourThing(); // output: // “My name is Pickles” // “I am a dog” // “Woof”

  6. Animal Dog Cat Human Subclasses (Cat extends Animal i.e. “A cat is an animal” or “All cats are animals”) class Cat extends Animal { public Cat() { noise = “Miaow”; } // of constructor public void doYourThing ( ) { identifySelf(); System.out.println(“I am a cat”); System.out.println(noise); } // of doYourThing } // of Cat Cat abby = new Cat(); abby.setName(“Abby”); abby.doYourThing(); // output: // “My name is Abby” // “I am a cat” // “Miaow”

  7. Animal Dog Cat Human Subclasses (Human extends Animal i.e. “A human is an animal” or “All humans are animals”) class Human extends Animal { public Human() { noise = “I think therefore I am”; } // of constructor public void doYourThing ( ) { identifySelf(); System.out.println(“I am a sentient being”); System.out.println(noise); } // of doYourThing } // of Human Human descartes = new Human(); descartes.setName(“Rene”); descartes.doYourThing(); // output: // “My name is Rene” // “I am a sentient being” // “I think therefore I am”

  8. Questions?

  9. Inheritance & Scope Using super & this

  10. Inheritance and Scope • Variables (e.g. noise): • Java first examines current method, looks for local variable or parameter; • Java then examines current class (e.g. Dog); • Java then examines superclass (e.g. Animal); • Java continues up the class hierarchy until no more superclasses to examine. • Methods (e.g. doYourThing() or identifySelf()): • Java first examines current class; • Java then examines superclass; • Java continues up inheritance hierarchy until no more superclasses to examine.

  11. Specifying Scope Java allows you to override the scope rules by saying which variable/method you’re referring to: Keyword super: keyword for specifying method or variable from superclass, e.g., super.doYourThing( ) Keyword this: keyword for specifying method or variable in current object, e.g., this.doYourThing( )

  12. Animal Dog Cat Human Using super & this (but why??) Same (in this case) as noise = “Woof”; and this.noise = “Woof”; class Dog extends Animal { public Dog() { super.noise = “Woof”; } // of constructor public void doYourThing ( ) { super.identifySelf(); System.out.println(“I am a dog”); System.out.println(noise); } // of doYourThing } // of Dog Same (in this case) as identifySelf(); or this.identifySelf();

  13. Using super and this class Animal { String name; } class Dog extends Animal { String name; /* Just so I don't forget! */ void twoNames() { System.out.println ("My dog name is " + name); System.out.println ("My animal name is " + super.name); } } Good idea?

  14. Animal Dog Cat Human If omitted??? Using super class Dog extends Animal { // constructor as before public void doYourThing() { identifySelf(); System.out.println(noise); } // of doYourThing public void identifySelf() { super.identifySelf(); System.out.println(“I am a dog”); } // of identifySelf } // of Dog I.e. this.identifySelf() (newly defined below) I.e. the identifySelf() (defined in Animal)

  15. A geometry example Shape Rectangle Circle class Shape { public String name; public String getName () { return (this.name); } // getName public int area () { return (0); } // area } // Shape Each extending object would override the area() method.

  16. Constructor “chaining” class Rectangle extends Shape { private int length, width; Rectangle () { this(0, 0); } // constructor Rectangle (int l, int w) { this( l, w, “rectangle”); } // constructor Rectangle (int l, int w, String n) { length = l; width = l; name = n; } // constructor public int area () { return (length * width); } // area public String getName () { if (length == width) return "square"; else return super.getName()); } // getName public String toString () { String s; s = new String ("A " + getName() + " with length " + length + " and width " + width); return (s); } } // toString } // Rectangle The Circle class implementation is left as an exercise to the reader.

  17. implied call to Animal() here Constructors and Inheritance • Java’s rule: • If first line of constructor is not an explicit call to a superclass constructor, Java will implicitly put super( ) as the first line, calling the superclass default constructor.public Dog() { • strNoise = “Woof”; • } // of constructor • An exception to this rule: chainedconstructor call to • this(params) will defer(ertelemek) super( ) call • To use superclass constructors with params, call them explicitly, e.g., super(strName)

  18. Look Closer... class Rectangle extends Shape { private int length, width; Rectangle () { this(0, 0); } // constructor Rectangle (int l, int w) { this( l, w, “rectangle”); } // constructor Rectangle (int l, int w, String n) { length = l; width = l; name = n; } // constructor public int area () { return (length * width); } // area What if I want a Shape constructor run here? Shape(); What if there is no Shape()??? Error

  19. Inheritance and Scoping Examples: super(xxx) // calls a superclass constructor super.xxx // accesses superclass’ variable super.xxx( ) // calls superclass’ method this(xxx) // calls a current-class constructor this.xxx // accesses current class’s variable this.xxx( ) // calls current class’ method Note: cannot do super.super<something> (can achieve this effect via casting, but rarely should; details later...)

  20. Chaining, superclass example

  21. class Parent { String name; public Parent() { setName("NONE"); cp(1); } public Parent(String name) { setName(name); cp(2); } public void setName(String name) { this.name = name; cp(3); } public void cp(int n) { System.out.println("At checkpoint "+n+" "+name); } public static void main(String args[]) { Child c = new Child(); } } // Parent class Child extends Parent { public Child() { this("NONAME"); cp(4); } public Child(String name) { this.name = name; cp(5); } } // Child Output: At checkpoint 3 NONE At checkpoint 1 NONE At checkpoint 5 NONAME At checkpoint 4 NONAME

  22. class Parent { String name; public Parent() { setName("NONE"); cp(1); } public Parent(String name) { setName(name); cp(2); } public void setName(String name) { this.name = name; cp(3); } public void cp(int n) { System.out.println("At checkpoint "+n+" "+name); } public static void main(String args[]) { Child c = new Child("Bob"); } } // Parent class Child extends Parent { public Child() { this("NONAME"); cp(4); } public Child(String name) { this.name = name; cp(5); } } // Child Output: At checkpoint 3 NONE At checkpoint 1 NONE At checkpoint 5 Bob

  23. Recall: Class Object • Java provides a base class, Object • All classes that do not have an extends clause implicitly inherit directly from class java.lang.Object • Examples utilizing this fact: • public boolean equals (Object o); • public boolean String toString (); • When you create your own toString( ) method for a class, you are overriding the toString( ) provided by Object.

  24. Object Animal Dog Cat Human Employee Salaried Hourly Object Animal Dog Cat Human Employee Salaried Hourly Object Hierarchy • class Object methods: • String toString() • boolean equals(Object obj) • and a few others... Or how about...

  25. Questions?

  26. Wrapper Classes Primitive types (e.g., int) are not classes But sometimes, we may have need to make use of primitive types in a context that requires that we manipulate objects, not primitives e.g. many collection classes are collections of Objects Java provides a set of wrapper classes (a.k.a. type wrappers, a.k.a. envelope classes) to support treating primitives as objects. It does this by providing a specific class that corresponds to each primitive data type They are in java.lang, so the names are universally available The names are mostly identical to primitive types, but capitalized...

  27. Wrapper Classes Class corresponds to Primitive Boolean boolean Character char Byte byte Short short Integer int Long long Float float Double double • Each one: • allows us to manipulate primitives as objects • contains useful conversion methods. E.g. Integer containsstatic Integer valueOf(String s) Integer.valueOf("27")is the object corresponding to int 27 • contains useful utility methods (e.g. for hashing)

  28. Wrapper Classes Using wrappers to bridge between objects and primitives: // create and initialize an int int i = 7; // create an Integer object and convert the int to it Integer intObject = new Integer( i ); // retrieve the int by unwrapping it from the object System.out.println( intObject.intValue() ); // convert a string into an Integer object String strS = "27"; Integer intObject intObject = new Integer (strS); // then to an int int a = intObject.intValue(); // one way int b = Integer.parseInt(strS); // second way

  29. Questions?

More Related