Overloading

• The ability to have methods share the same name
• Provides a natural and intuitive expressivesness

  System.out.println(3);
  System.out.println("Hello");
  System.out.println(employee);		// instance of class Employee
  		

  String initialValue = ...;
  TextField t1 = new TextField(initialValue);
  TextField t2 = new TextField(4);	
  		

• Legal as long as the signatures (i.e., method name, and the number and resp. type of parms) are different
  • Return type is not used for overload resolution

    ...
    int f() {...}
    double f() {...}
    ...
    System.out.println(f());
    ...
    				

• Resolution occurs at compile time

• Operators are (usually) symbols predefined by the language and known to the compiler
• Operators are often overloaded (by the compiler) on built-in types

  double d1, d2;
  int i1, i2;
  ...
  d1 = d1 + d2;
  i1 = i1 + i2;
  d1 = d1 + i1;
  		

• Recent languages (Ada, C++) provide user-defined operator overload
  • User-defined types can associate an operator with a block of executable code

    class Complex {
    	...
    	operator +(Complex c2);
    	...
    }
    ...
    Complex c1, c2;
    ...
    c1 = c1 + c2;
    				

• No user-defined operator overloading in Java
  • Overloading of primitive type operators
    +, -, ... <, ...
  • There is minimal operator oveloading on reference types
    • + and += for String

Extending Classes

• Inheritance
• superclass/subclass
• parent/child class
• base/derived class
• extended class (subclass)

• Invoking another constructor of the same class
  • Given

    class Counter {
    	Counter(int val, int min, int max, int increment) {
    		this.val = val;
    		this.min = min;
    		this.max = max;
    		this.increment = increment);
    	}
    	...
    }
    				

    want to add default constructor that
    • sets val to 0
    • min to 0
    • max to 10
    • increment to 1

    	Counter() {this(0, 0, 10, 1);}
    				

• Invoking the constructor of superclass
  • Given:

    class Window {
    	Window(int width, int height) {...}	// No default constructor
    	...
    }
    				

    and now we extend Window

    class TitledWindow extends Window {
    	TitledWindow(String title, int width, int height) {???}
    	...
    	private String title;
    }
    				

  • Creating a TitledWindow object

    TitledWindow tw = new TitledWindow("My First Window", 20, 40);
    				

    involves a Window object creation
    • (Not a separate object-- the Window object is PART of the TitledWindow object-- that's the whole idea of inheritance!)
    • The Window object's state needs to be properly initialized
      • This would be done by an invocation of the Window constructor
      • But we're creating the TitledWindow object
  • The extended class needs to ensure the Window class is properly initialized (i.e., the constructor is invoked).
    • If there were a default constructor-- no problem
      • Without any effort by the subclass, the default constructor of the superclass is implicitly invoked
    • However if initialization values MUST be suppplied, it becomes the responsibility of the extended class to do so

      class TitledWindow extends Window {
      	TitledWindow(String title, int width, int height) {
      		super(width, height);
      		this.title = title
      	}
      	...
      	private String title;
      }
      			

    • The super constructor inviocation MUST be the frst executable statement of the constructor
  • the extended class can itself supply the initialization valiues (rather than receiving them via its constructor

     
    class TitledWindow extends Window {
    	TitledWindow(String title) {
    		super(WIDTH, HEIGHT);
    		this.title = title
    	}
    	...
    	private String title;
    	static final int
    		WIDTH = 100,
    		HEIGHT = 50;
    }
    			

  Polymorphism

  Some terminology
  • Compile-time
  • Run-time
  • Variable - storage location with an associated type
  • Object - instance of a class
  • Binding - the association of a program element with a property
    • Binding of a variable with its type
    • Binding of a variable with its value
    • Binding of a variable with its storage location
    • Binding of a method invocation to a specific block of code
  • Binding time - the point at which a binding takes place
    • Static-binding - binding occurs at compile-time
      • Variable to its type
    • Dynamic-binding - binding occurs at run-time
      • Variable to its value

  Types, References and Objects in Java

  class Super {
  	...
  }
  class Sub extends Super {
  	...
  }
  

  • We distinguish between
    • The type of a reference variable
      • A static binding (static type)

      Super sup;		// Type of reference variable is Super
      Sub sub;			// Type of reference variable is Sub
      			

    • The type of an object
      • A dynamic binding (dynamic, or run-time, type)

      ... = new Super();	// Type of object is Super
      ... = new Sub();		// Type of object is Sub
      				

  • Introducing subtypes into the equation
    • The is-a relationship becomes important

      sup = new Sub();		// legal-- a Sub is-a Super
      				

    • We can thus always assign up the hierarchy

      sup = sub;		// legal-- a Sub is-a Super
      				

    • What about down the hierarchy?

      sub = sup;	//	legal?
      				

      • A Super object is not a Sub object
        • Can't substitute for a Sub object
        • (Probably) missing instance variables, methods

          
        sub = new Super();	//	illegal-- a Super is not necessarily a Sub
        						

      • But what about?

        sub = sup;	//	legal?
        						

        • Here are two pieces of code leading up to the above

          sub = new Sub();
          sup = sub;					// sup referencing a Sub object
          ...	
          sub = sup;
          								

          class Sub2 extends Super {
          	...
          }
          sub2 = new Sub2();		// sup referencing a Sub2 object
          sup = sub2;
          ...	
          sub = sup;			
          								

        • What type of object sup points to can't be determined until run-time
          • Don't forget objects have dynamic type.
        • In summary

          sub = sup;
          									

          • May or may not be legal
          • Can;t tell until run-time