inheritance by 64b5SWe

VIEWS: 0 PAGES: 32

									Inheritance in Java

CS 3331
Fall 2009




                      1
Outline

   Overloading
   Inheritance and object initialization
   Subtyping
   Overriding
   Hiding




                                            2
Overloading of Methods and
Constructors

   Def. Overloading
       The ability to allow different methods or constructors
       of a class to share the same name.
                                      constructor
    public class Point {              overloading
      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


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

                                                          4
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) { /* … */ }
   // …
 }




                                                                 5
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());
   }
   // …
 }




                                                                 6
Outline

   Overloading
   Inheritance and object initialization
   Subtyping
   Overriding
   Hiding




                                            7
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.




                                                                 8
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.


                                                       9
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(0,0);
      this.y = 0;
    }
}




                                              10
Example of “super” Calls
public class ColoredPoint extends Point {
                                                                   Point
 private Color color;
                                                         -x: int
    public ColoredPoint(int x, int y, Color color) {     -y: int
      this.x = x;                                        +Point()
      super(x,y);
      this.y = y;                                        +Point(x: int, y: int)
      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?
    }
}

                                                                             11
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?




                                                       12
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 {        public class T {
  int y = 30; // 3: third           int x = 10; // 1: first

     public S() {                      public T() {
       super();                          x = 20; // 2: second
       y = 40; // 4: fourth            }
     }                                 // ...
     // ...                        }
 }


                                                                13
Exercise
    What value will be printed and why?

      class Super {
        protected int x = 100;
      }

      class Sub extends Super {
       { x = 200; }

          public static void main(String[] args) {
            System.out.println(new Sub().x);
          }
      }


                                                     14
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 {       class Room {
       private int capacity = 60;           private int number = 100;
       public ClassRoom(int c) {            public Room() {
         capacity = c;                        this(++nextNum);
       }                                    }
       public ClassRoom(int n, int c) {     public Room(int n) {
         super(n);                            number = n;
       }                                    }
       { if (number % 2 == 1)               private static int nextNum = 100;
            capacity *= 2;                  static { nextNum += 100; }
       }                                    { number += 2; }
     }                                    }

                                                                            15
Outline

   Overloading
   Inheritance
   Subtyping
   Overriding
   Hiding




                  16
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.)




                                                              17
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


                                                                 18
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(Student s);
    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();
                                                                   19
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

                                                                 20
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




                                                                  21
Outline

   Overloading
   Inheritance
   Subtyping
   Overriding
   Hiding




                  22
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



                                                      23
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




                                24
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?
                                                           25
Overriding Methods (Cont.)

   Q. How overriding differ from overloading?




                                            26
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.




                                                              27
Dynamic Binding (Cont.)
class Point {
                                                               CIR for Point
   private int x, y;
   public Point(int x, int y) { this.x = x; this.y = y; }     x
   public int getX() { return x; }                            y
   public int getY() { return y; }                            …
}

class ColoredPoint extends Point {
   private Color color;                                     CIR for ColoredPoint
   public ColoredPoint(int x, int y, Color c) {               x
      super(x, y);                                            y
      color = c;                                              color
   }                                                          …
  public Color getColor() { return color; }
}


                                                                               28
 Dynamic Binding (Cont.)
                                                   Object.class
ColoredPoint p
  = new ColoredPoint(10,20,Color.RED);              super:
p.getColor();                                       vmt:
p.getX();                                           …
                                    Point.class
                                     super:
                                     vmt:
                                                          getX:
                                     …
p: class:                                                 getY:
    x: 10                                                 …
    y: 20
    color:          ColoredPoint.class
                          super:
                          vmt:                getColor:
                          …                   …
     Color.RED

 Q: What if getX is overridden in ColoredPoint?
                                                                  29
Outline

   Overloading
   Inheritance
   Subtyping
   Overriding
   Hiding




                  30
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




                                                      31
Example
class Student {
  protected String description = “Student”;
  public String getDescription() {
          return description;                 hiding of
  }                                               field
}
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?




                                                            32

								
To top