class SavingsAccount extends BankAccount {

  <new methods>

  <new instance variables>   

} 

class Vehicle {
  String owner; 
  Vehicle (String owner) { 
    this.owner = owner; 
  }
  public String toString() {
    return "I belong to: " + this.owner; 
  } 
  public static void main(String[] args) {
    Vehicle a = new Vehicle("Michael Jordan");
    System.out.println(a.toString()); 
  } 
} 

class Vehicle {
  String owner; 
  Vehicle (String owner) { 
    this.owner = owner; 
  }
  public String toString() {
    return "I belong to: " + this.owner; 
  } 
  public static void main(String[] args) {
    Vehicle a = new Vehicle("Michael Jordan");
    System.out.println(a           ); 
  } 
} 

class Vehicle {
  String owner; 
  Vehicle (String owner) { 
    this.owner = owner; 
  }



  public static void main(String[] args) {
    Vehicle a = new Vehicle("Michael Jordan");
    System.out.println(a.toString()); 
  } 
} 

public class SavingsAccount extends BankAccount {

  double interestRate; 

  public SavingsAccount (double rate) {
    this.interestRate = rate; 
  } 

  public void addInterest() {
    double interest; 
    interest = this.getBalance() * this.interestRate / 100; 
    this.deposit(interest); 
  } 

} 

public class SavingsAccount extends BankAccount { 

  double interestRate;

  public SavingsAccount (double rate) {
    this.interestRate = rate; 
  } 

  public void addInterest() {
    double interest; 
    interest = this.getBalance() * this.interestRate / 100; 
    this.deposit(interest); 
  } 

} 

collegeFund.deposit(___); 
collegeFund.withdraw(___); 
collegeFund.getBalance(); 
collegeFund.addInterest(); 

BankAccount b = new SavingsAccount(10); 

SavingsAccount a = new BankAccount(___); 

SavingsAccount          collegeFund = new SavingsAccount(10); 
BankAccount anAccount = collegeFund; 
Object      anObject  = collegeFund; 

void transfer (BankAccount other, double amount) {
  this.withdraw(amount); 
  other.deposit(amount); 
} 

Object myObj = new SavingsAccount(10); 

SavingsAccount x = (SavingsAccount)myObj; 

BankAccount[] a = new BankAccount[100];

Vector v = new Vector();
v.addElement(new Rectangle(_,_,_,_));
(v.elementAt(0)).translate(_,_);

Vector v = new Vector();
v.addElement(new Rectangle(_,_,_,_));
((Rectangle)(v.elementAt(0))).translate(_,_);

if (anObject instanceOf SavingsAccount) {
  // ... do savings account type of work 
} else if (anObject instanceOf CheckingAccount) {
  // ... do checking account type of work 
} else {
  // ... in which case the tiny scientist reports an error  
} 

INHERITANCE MECHANISM REVEALED

We first defined class Point.

A Point has a position (x, y).

class Point {
  int x;
  int y; 
} 

• an x coordinate, and
• a y coordinate

A Pixel is a Point with Color.

In Java this is easy to write:

class Pixel extends Point {
  Color c; 
} 

• an x coordinate (which is an int)
• a y coordinate (which is an int)
• a Color, call it color

• the features of a Point and
• the one new feature that class Pixel is defining

That's fine, but set union means that names should be kept distinct.

We'll come back to this in a second.

How do we use Point and Pixel?

Nothing unusual. We use new and expect the blueprints to define the resulting structures.

// somewhere in a method... 
Point a = new Point(); 
Pixel b = new Pixel(); 
a.x = 2; 
a.y = -10; 
b.x = 3; 
b.y = 24;
b.color = Color.blue; 

Next we asked: have you ever seen a Horse?

The answer was: yes.

Can you describe a Horse?

The answer was: that's actually quite complicated.

OK, so fortunately we know what we're talking about:

class Horse {
  // lots of features ... 
}

The answer was: no.

Can you describe a Unicorn though?

Everybody said: yes, that's easy.

class Unicorn extends Horse {
  Horn h; 
}

• everybody has seen horses, but nobody felt it was easy to describe them
• nobody has seen unicorns, but everybody thought it was easy to describe them

Now we said: let's write a play with horses and unicorns.

In our play we could have:

Horse   h = new Horse(); 
Unicorn u = new Unicorn(); 

If you put them on you should see the features that their type is defining.

So h.mane and u.mane make sense.

So does u.horn but h.horn doesn't.

For this reason it's not adequate to say:

Unicorn g = new Horse(); 

From our description it follows that all Unicorns are Horses.

That's called polymorphism.

So writing something like this is acceptable:

Horse z = new Unicorn(); 

We could come up with the following similar example:

class Shape {
  // two coordinates 
} 

class Circle extends Shape {
  // add a radius 
}

class Rectangle extends Shape {
  // add a width and a height 
} 

class Triangle extends Shape {
  // add two other points relative to location 
} 

If you want to create an array that can store

• Circles,
• Triangles, and
• Rectangles,

Shape p[] = new Shape[100]; 

There's no other way around it, as far as arrays are concerned.

Now we want to explore the name collision problem.

Consider this example:

class Horse {
  void neigh() { System.out.println("Horse: Howdy!"); } 
} 

class Unicorn extends Horse {
  void neigh() { System.out.println("Unicorn: Bonjour! "); } 
}

If Horse had not had it already listed things would've been easy.

But Horses already know how to neigh. They say: "Howdy!".

So Unicorns redefine the feature by saying "Hello!" in French.

That's called overriding.

The mechanism is that no matter how you look at a Unicorn,

• as the Unicorn that it is, or
• as the Horse that it is

Here's the proof:

frilled.cs.indiana.edu%cat Ionesco.java
class Horse {
    void neigh() { System.out.println("I am a Horse: Howdy!"); }
} 

class Unicorn extends Horse {
    void neigh() { System.out.println("I am a Unicorn: Bonjour! "); }
} 

class Ionesco {
    public static void main(String[] args) {
	Unicorn a = new Unicorn(); 
	Horse   b = new Unicorn(); 
	a.neigh(); 
	b.neigh();

	Horse c = new Horse(); 
	c.neigh(); 

    } 
} 
frilled.cs.indiana.edu%javac Ionesco.java
frilled.cs.indiana.edu%java Ionesco
I am a Unicorn: Bonjour! 
I am a Unicorn: Bonjour! 
I am a Horse: Howdy!
frilled.cs.indiana.edu%