Week 10
Oct 29

Summary:
1. Inheritance allows 
	(a) keeping common parts of CD/DVD code in one place (Item)
		[helps prevent Code Duplication in CD & DVD]
	(b) just a single list of Item, rather than separate CD/DVD lists
		[helps prevent Code Duplication in main class!]
2. "extends" keyword, use of super() to call superclass constructor
3. Base-class variable can be assigned derived-class objects:
	Item theItem = new CD(....);	
4. Problem getting specific identity back:
	fixes:
		instanceof (painful)
		OOP magic: most-specific-method rule
			When base class and derived class both have same method,
			the more specific (derived-class) one is invoked

============================================================

inheritance demo

	public class Base
	{
	    private int x;
	
	    public Base(int x)  {
	        this.x = x;
	    }
	
	    public String foo() {
	        return "All your BASE are belong to us!";
	    }
	       
	    public int bar( ) {
	        return x;
	    }
	}


	public class A extends Base {
	    private int y;
	
	    public A(int x, int y) {
	        super(x);
	        this.y = y;
	    }
	
	    public String foo() {
	        return "I am an A";
	    }
	    
	    public int bar() {
	        return super.bar() + y;
	    }
	    
	    public int baz() {
	        return 0xDEADBEEF;
	    }
	}


	public class B extends Base {
	    private int z;
	    
	    public B(int x, int y) {
	        super(x);
	        this.z = y;
	    }
	
	    public String foo() {
	        return "BBBBBB>>>" + super.foo() + "<<<BBBBBB";
	    }
	    
	    public int bar() {
	        return 1000*z + super.bar();
	    }
	}
	
most-specific-method rule in action
java remembers how objects were created
what if we forget a methodholder in the base class?
What if we change a method name?

use of super() in ctor

Simple example with classes Base & Deriv, methods foo() & bar()
1. Main, Base
2. A, failure to compile b2.baz() but b2a.baz() is fine
3. A, how bar manages to return x+y even though x is private
4. remove foo() from A 

5. class B which refers to base.

============================================================

Rule 4 in action with print().
How to get printing to work? Call super.print() first!!

Examples of calls to super.whatever()


======================================================================
======================================================================

Wednesday

Exam in two weeks: Nov 14
Lab on Nov 12 will be start of project 1



8.6: advantages of inheritance:
	* avoid code duplication
	* code reuse
	* localization

There are others


STATIC type and DYNAMIC type

static type is the type of the variable
dynamic type is the type of the contents

	Often they're the same.
	ALWAYS the dynamic type is either same as static, or a subclass.
	

Everything is a subclass of Object.

8.7: subtyping
subclasses and assignment
subclasses and parameters

A variable can hold objects of its declared type 
	or of any subtype of its declared type
Ditto for parameter

This is the "substitution rule". It definitely is a break
in the type rules, but it does make sense.

Also called polymorphism

The *reverse* is not allowed!!!


Draw pictures of Item with slots for foo(),bar()
method dispatch
Why it is a good fit with "substitution rule"

====================================================================

Friday

enum example: just so you can read examples in the book;
we won't use enums in class.

Review:
	static type: type of variable
	dynamic type: type of object; can be subtype (derived class)
	
	static type: guarantees a set of methods are available.
	Anything put into the variable must enforce this guarantee
	So, the method must be present in the *variable* type.
	Other than that, variables are now *polymorphic*
	
	Book description in 9.4: leisurely "search" up the hierarchy.
	This would be consistent with a "do you have a print() method;
	if not, throw an error" approach. But that's TOO SLOW.
	WHen java came out, it was ~100 times slower than C, and didn't
	need to be even worse!
	
	
Print() method: 
advantages of using super.print(): consistent formatting of that part.

How else can we use inheritance?

Shapes project (Monday's lab):
instead of having Circle, Rectangle, Square, Triangle be independent classes,
we'll have the following hierarchy:

	Shape
	  |
	Circle, Rectangle, Triangle
	           |
	        Square

Here are the methods that will be implemented ONLY in Shape:

    * makeVisible
    * makeInvisible
    * moveRight
    * moveLeft
    * moveUp
    * moveDown
    * moveHorizontal(int distance)
    * moveVertical(int distance)
    * slowMoveHorizontal(int distance), slowMoveVertical(int distance)
    * changeColor
    * erase (somewhat surprisingly, this is not shape-specific.) 
	
The draw() method must be implemented separately for each shape.
However, it must be present in Shape, as a "stub".

Here are the other shape-specific methods: 
    * Circle: changeSize(diameter)
    * Rectangle: changeSize(width, height)
    * Square: changeSize(size)
    * Triangle: changeSize(width, height) 


Note that if we have a list of shapes:
	ArrayList<MyShape> picture;
then we can draw each shape with
	for (MyShape s : picture) {
		s.draw();
	}
	
However, we *cannot* do this if we have three unrelated shape classes.
The only class they have in common is Object. That's the only
type that could hold all three. But it's too general to be able to draw()!