1 / 32

Inheritance in Java

Inheritance in Java. CS 3331 Fall 2009. Outline. Overloading Inheritance and object initialization Subtyping Overriding Hiding. constructor overloading. public class Point { public Point() { /* … */ } public Point(int x, int y) { /* … */ }

tangia
Download Presentation

Inheritance in Java

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 in Java CS 3331 Fall 2009

  2. Outline • Overloading • Inheritance and object initialization • Subtyping • Overriding • Hiding

  3. constructor overloading • public class Point { • public Point() { /* … */ } • public Point(int x, int y) { /* … */ } • public double distance(Point other) { /* … */ } • public double distance(int x, int y) { /* … */ } • public double distance() { /* … */ } • // … • } method overloading Overloading of Methods and Constructors • Def. Overloading The ability to allow different methods or constructors of a class to share the same name.

  4. Overloading (Cont.) • Which overloaded method to invoke? Resolved at compile-time with signature matching, where signature is name and parameter types. • Constructors/Methods Signatures • 1: Point() Point() • 2: Point(int x,int y) Point(int,int) • 3: double distance(Point other) distance(Point) • 4: double distance(int x,int y) distance(int,int) • 5: double distance() distance() • Point p1 = new Point(); // which constructor? • Point p2 = new Point(10,20); • p2.distance(p1); // which method? • p2.distance(20,30); • p2.distance();

  5. When to Overload? When there is a general, nondiscriminative description of the functionality that fits all the overloaded methods. public class StringBuffer { public StringBuffer append(String str) { /* … */ } public StringBuffer append(boolean b) { /* … */ } public StringBuffer append(char c) { /* … */ } public StringBuffer append(int i) { /* … */ } public StringBuffer append(long l) { /* … */ } // … }

  6. When to Overload? (Cont.) When all the overloaded methods offer the same functionality, with some of them providing default arguments. public class String { public String substring(int i, int j) { // base method: return substring from index i to j - 1. } public String substring(int i) { // provide default argument return substring(i, length()); } // … }

  7. Outline • Overloading • Inheritance and object initialization • Subtyping • Overriding • Hiding

  8. Inheritance • Inheritance models the is-a relationship. • If class S extends class T, then all objects of S can act-like an object of T. • Only single inheritance is allowed among classes. • All public and protected members of a superclass are accessible in the subclasses.* *All protected members are also accessible within the package.

  9. Constructors of Subclasses • Can invoke a constructor of the direct superclass. • super(…) must be the first statement. • If the super constructor call is missing, by default the no-arg super() is invoked implicitly. • Can also invoke another constructor of the same class. • this(…) must be the first statement.

  10. this(0,0); Example of “this” Calls public class Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public Point() { // default constructor this.x = 0; this.y = 0; } }

  11. Point -x: int -y: int +Point() +Point(x: int, y: int) super(x,y); Example of “super” Calls public class ColoredPoint extends Point { private Color color; public ColoredPoint(int x, int y, Color color) { this.x = x; this.y = y; this.color = color; } public ColoredPoint(int x, int y) { this(x, y, Color.BLACK); // point with default value } public ColoredPoint() { color = Color.BLACK; // what will be the values of x and y? } }

  12. Default Constructor • If no constructor is defined, the following form of no-arg default constructor is automatically generated by the compiler. public ClassName() { super(); } Q. What would be the use of default constructor?

  13. Execution Order of Constructors Rule: Superclass first and field initialization first - Instance variable initializer vs. instance initializer (or initialization block) Example: S x = new S(); public class S extends T { int y = 30; // 3: third public S() { super(); y = 40; // 4: fourth } // ... } public class T { int x = 10; // 1: first public T() { x = 20; // 2: second } // ... }

  14. Exercise • What value will be printed and why? class Super { protected int x = 100; } class Sub extends Super { { x = 200; } public staticvoid main(String[] args) { System.out.println(new Sub().x); } }

  15. Exercise • What are the room number and capacity of the following two objects, respectively? ClassRoom c1 = new ClassRom(100); ClassRoom c2 = new ClassRoom(300, 100); class ClassRoom extends Room { private int capacity = 60; public ClassRoom(int c) { capacity = c; } public ClassRoom(int n, int c) { super(n); } { if (number % 2 == 1) capacity *= 2; } } class Room { private int number = 100; public Room() { this(++nextNum); } public Room(int n) { number = n; } private static int nextNum = 100; static { nextNum += 100; } { number += 2; } }

  16. Outline • Overloading • Inheritance • Subtyping • Overriding • Hiding

  17. Types • What’re types? • Sets of values • Why types? • To statically detect program errors, called type errors. • Typed- vs. untyped-languages (also, static vs. dynamic typing) • Types in Java • Primitive types (e.g., boolean, int, long, etc.) • Classes (e.g., Object, String, etc.) • Interfaces (e.g., Runnable, List, etc.) • Array types (e.g., int[], Object[], List[][], etc.)

  18. Subtyping • What’s subtyping? • Subset relationship among types (e.g., Manager is a subtype (or subset) of Employee) • Subtype’s values are legitimate values of supertypes. • Why subtyping? • Can organizes types into hierarchy, called subype hierarchy • Can extend programs by adding subtypes • Subtyping in Java • Between classes (subclassing) • Between interfaces (subinterfacing) • Between classes and interfaces (implementation or realization) • Between arrays

  19. Substitution Property • Def. Substitution property • A value of subtype can appear where a value of its supertype is expected, e.g., in arguments, results, receivers, and assignments. // 1. argument // public void register(Students); register(new PhDStudent(“Joe”)); // 2. return value public Student find(String name) { // I am lazy, so I am going to return Joe every time. return new PhDStudent(“Joe”); } // 3. receiver of method call // toString in the class Object new PhDStudent(“Joe”).toString();

  20. Substitution Property (Cont.) • Rules of (polymorphic) assignment • The type of expression at the right-hand side of an assignment must be a subtype of the type of the variable at the left-hand side of the assignment. class Student { … } class Undergraduate extends Student { … } class Graduate extends Student { … } Student s1, s2; s1 = new Undergradute(); // polymorphic assignment s2 = new Graudate(); // polymorphic assignment Graduate s3 = s2; // is this OK? Graduate s3 = (Graduate) s2; // explicit casting

  21. Widening and Narrowing • Def. widening and narrowing • The conversion of a subtype to one of its supertype is called widening, and the conversion of a supertype to one of its subtype is called narrowing (or downcasting). // s is a stack of strings Stack s = new Stack(); s.push(“Hello”); // widening: void push(Object) … // Stack defines a method top, i.e., “public Object top()”. s.top().size(); // okay? ((String) s.top()).size(); // downcasting

  22. Outline • Overloading • Inheritance • Subtyping • Overriding • Hiding

  23. Overriding Methods • Def. Overriding • Refers to the introduction of an instance method in a subclass that has the same name, signature, and return type of a method declared in the superclass. • Consequences • Implementation of the method in the subclass replaces the implementation of the method in the superclass

  24. Overriding Methods (Cont.) public class T { public void m() { … } } public class S extends T { public void m() { … } } T t = new T(); S s = new S(); t.m(); // invoke m of class T s.m(); // invoke m of class S

  25. Overriding Methods (Cont.) • Dynamic dispatch (binding): The method to be invoked is determined at runtime by the runtime type of the object, not by the declared type (static type). class Student { public int minCredits() { return 12; } … } class GraduateStudent extends Student { public int minCredits() { return 9; } … } Student s; // … s.minCredits(); // which minCredits method?

  26. Overriding Methods (Cont.) • Q. How overriding differ from overloading?

  27. Implementation of Dynamic Binding • Storage structure of instance variables • Class instance records (CIRs) store the state of an object • The CIR for a subclass adds its new fields to the parent CIR. • Dynamic bindings of messages to methods • Virtual Method Tables (VMTs) are used for dynamic binding.

  28. Dynamic Binding (Cont.) class Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } } class ColoredPoint extends Point { private Color color; public ColoredPoint(int x, int y, Color c) { super(x, y); color = c; } public Color getColor() { return color; } } CIR for Point x y … CIR for ColoredPoint x y color …

  29. Object.class Point.class p: getX: getY: … super: vmt: … super: vmt: … super: vmt: … ColoredPoint.class class: x: 10 y: 20 color: getColor: … Color.RED Dynamic Binding (Cont.) ColoredPoint p = new ColoredPoint(10,20,Color.RED); p.getColor(); p.getX(); Q: What if getX is overridden in ColoredPoint?

  30. Outline • Overloading • Inheritance • Subtyping • Overriding • Hiding

  31. Hiding Fields and Class Methods • Def. Hiding • Refers to the introduction of a field (instance or class) or a class method in a subclass that has the same name as a field or class method declared in the superclass. • Hiding vs. overriding • Statically resolved (bound) at compile-time vs. dynamically dispatched at run-time

  32. hiding of field Example class Student { protected String description = “Student”; public String getDescription() { return description; } } class Undergraduate extends Student { protected String description = “Undergraduate”; } new Student().getDecription(); // what value is returned? new Undergraduate().getDescription(); // what value? Q. How to refer to hidden fields?

More Related