1. Section 9.1
Introduction

2. OOP Review Encapsulation Polymorphism Class Interaction
Object Oriented Programming (OOP) is a style of programming that incorporates these 3 features:
Encapsulation
Polymorphism
Class Interaction

3. Class Interaction There are 3 types of class interaction.
One is inheritance, which the main focus of this chapter.
Another is composition, which we will look at briefly.
The third is utility classes which is explained on the next slide.

4. Utility Classes
You have been working with Utility Classes for a while.
These are classes which are not used to create objects, but still contain several useful methods.
The Math class and the Expo class are both perfect examples of this.

5. Section 9.2
“Is-A” & “Has-A”
Relationships

6. Inheritance
Inheritance is the process of using features (both attributes and methods) from an existing class.
The existing class is called the superclass and the new class, which inherits the superclass features, is called the subclass.
superclass: Car
subclasses:
Truck, Limo & Racecar

7. “Is-A” and “Has-A”
The creation of new classes with the help of existing classes makes an important distinction between two approaches.
An "is-a" relationship declares a new class as a special “new-and-improved” case of an existing class. In Geometry, a parallelogram "is-a" quadrilateral with special properties.
A “has-a” relationship declares a new class composed of an existing class or classes. A line "has" points, a square "has" lines, and a cube "has" squares.
A truck "is-a" car, but it "has-an" engine.

8. Composition
Composition occurs when the data attributes of one class are objects of another class.
You do NOT say “A Car is-an Engine” or “A Car is 4 tires” but you DO say “A Car has-an Engine” & “A car has 4 tires.”
class: Car
Contained
Objects:
1 Engine
4 Tires

9. Inheritance vs. Composition
In computer science an "is-a" relationship is called inheritance
and a "has-a" relationship is called composition.
“A TireSwing is-a Swing”.
“A TireSwing has-a Tire.”
Subclass:
TireSwing
Superclass:
Swing
Contained
class: Tire

10. Section 9.3
Superclass
& Subclass

11. // Java0901.java
// This program presents a <Person> class and a <Student> class.
// The main method calls the <showAge> method with a <Student> object.
// This program will not compile. Java cannot find the <showAge> method.   
public class Java0901 {
public static void main(String args[])
System.out.println("\nJAVA0901\n");
Student tom = new Student();
tom.showAge();
tom.showGrade();
System.out.println(); }
class Person
private int age;
public void showAge() { System.out.println("Person's Age is unknown right now"); }
class Student
private int grade;
  public void showGrade() { System.out.println("Student's Grade is unknown right now"); }

12. // Now the program compiles and executes correctly.
// Java0902.java
// This program demonstrates fundamental inheritance with <extends>.
// The <Student> is declared as a subclass of the <Person> superclass.
// Now the program compiles and executes correctly.   
public class Java0902 {
public static void main(String args[])
System.out.println("\nJAVA0902\n");
Student tom = new Student();
tom.showAge();
tom.showGrade();
System.out.println(); }
class Person
private int age;
public void showAge() { System.out.println("Person's Age is unknown right now"); }
class Student extends Person
private int grade;
  public void showGrade() { System.out.println("Student's Grade is unknown right now"); }

13. public static void main(String args[])
// Java0903.java
// This program adds constructors to the <Person> &<Student> classes. Note how the <Person>
// constructor is called, even though there does not appear to be a <Person> object instantiated.   
public class Java0903 {
public static void main(String args[])
System.out.println("\nJAVA0903\n");
Student tom = new Student();
System.out.println(); }
class Person
private int age;
public Person() { System.out.println("Person Constructor"); age = 17; }
class Student extends Person
private int grade;
public Student() { System.out.println("Student Constructor"); grade = 12; }

14. Inheritance and Constructors
When an object of a subclass is instantiated, the constructor of the superclass is called first, followed by a call to the constructor of the subclass.

15. Section 9.4
Private and
Protected
Access

16. // Java0904.java
// This program shows that the subclass does not have access to the private data
// of the superclass. This program will not compile.
public class Java0904 {
public static void main(String args[])
System.out.println("\nJAVA0904\n");
Student tom = new Student();
tom.showData();
System.out.println(); }
class Person
private int age;
public Person() { System.out.println("Person Constructor"); age = 17; }
class Student extends Person
private int grade;
public Student() { System.out.println("Student Constructor"); grade = 12; }
public void showData()
System.out.println("Student's Grade is " + grade);
System.out.println("Student's Age is " + age );

17. // Java0905.java
// This program changes private super class data access to "protected".
// The Student class can now access data from the Person class.
public class Java0905 {
public static void main(String args[])
System.out.println("\nJAVA0905\n");
Student tom = new Student();
tom.showData();
System.out.println(); }
class Person
protected int age;
public Person() { System.out.println("Person Constructor"); age = 17; }
class Student extends Person
private int grade;
public Student() { System.out.println("Student Constructor"); grade = 12; }
public void showData()
System.out.println("Student's Grade is " + grade);
System.out.println("Student's Age is " + age );

18. public, private & protected
Attributes & methods declared public can be accessed by methods declared both outside and inside the class.
Attributes & methods declared private can only be accessed by methods declared inside the class.
Attributes & methods declared protected can be accessed by methods declared inside the class or subclass.

19. Section 9.5
Multi-Level
Inheritance

20. // Java0906.java This program demonstrates inheritance at three levels.
public class Java0906 {
public static void main(String args[])
System.out.println("\nJAVA0906\n");
Cat cat = new Cat("Tiger");
System.out.println();
System.out.println("Animal type: " + cat.getType());
System.out.println("Animal weight: " + cat.getWeight());
System.out.println("Animal age: " + cat.getAge()); }
class Animal
protected int age;
public Animal()
System.out.println("Animal Constructor Called");
age = 15;
public int getAge() { return age; }
class Mammal extends Animal
public int weight;
public Mammal()
weight = 500;
System.out.println(
"Mammal Constructor Called");
public int getWeight() { return weight; }
class Cat extends Mammal
private String type;
public Cat()
type = "Tiger";
"Cat Constructor Called");
public String getType() { return type; }

21. Multi-Level Inheritance & Multiple Inheritance
The previous program showed an example of Multi-Level Inheritance.
Multiple Inheritance is something different. It occurs when one subclass inherits from two or more superclasses.
This feature is available in C++.
It is NOT available in Java.

22. Multi-Level Inheritance
Multiple Inheritance
Animal
Reptile
Extinct
Mammal
Dinosaur
Dog
Terrier

23. GridWorld
Example of
Inheritance

24. Inheritance Demonstrated with GridWorld-1
In GridWorld, if you click on an Actor object, you will see all of the methods available from the Actor class.

25. Inheritance Demonstrated with GridWorld-2
If you click on a Bug object, you will see all of the Bug methods.
You will also see all of the methods Bug inherits from Actor.

26. Inheritance Demonstrated with GridWorld-3
Here, Multi-Level Inheritance is demonstrated because an OctagonBug (Spider) inherits from a Bug, and a Bug inherits from an Actor.

27. Section 9.6
The Fish class
Case Study

28. // Java0907.java The Fish class, Stage #1
// The Fish1 class can only draw a fish at a fixed starting location.
import java.awt.*;
import java.applet.*;
public class Java0907 extends Applet {
public void paint(Graphics g)
Fish1 f1 = new Fish1();
f1.drawFish(g); }
class Fish1
protected int x; // center X coordinate of the fish
protected int y; // center Y coordinate of the fish
protected int direction; // one of 4 directions fish is facing: 0-N, 90-E, 180-S, 270-W
public Fish1()
x = 500;
y = 300;
direction = 0;

29. public void drawFish(Graphics g){
Expo.setColor(g,Expo.black);
switch (direction)
case 0:
Expo.fillOval(g,x,y,15,30);
Expo.fillPolygon(g,x,y+30,x-15,y+40,x+15,y+40);
break;
case 90:
Expo.fillOval(g,x,y,30,15);
Expo.fillPolygon(g,x-30,y,x-40,y-15,x-40,y+15);
case 180:
Expo.fillPolygon(g,x,y-30,x-15,y-40,x+15,y-40);
case 270:
Expo.fillPolygon(g,x+30,y,x+40,y-15,x+40,y+15);
default:
System.out.println("ERROR!!! Direction must be 0,90,180,270"); }

30. // Java0908.java The Fish class, Stage #2
// The Fish2 class inherits the drawFish method.
// Additionally, it adds a method to erase the fish and turn the fish.
import java.awt.*;
import java.applet.*;
public class Java0908 extends Applet {
public void paint(Graphics g)
Fish2 f2 = new Fish2();
f2.drawFish(g);
f2.turnFish(g); }
class Fish2 extends Fish1
public void turnFish(Graphics g)
Expo.delay(1000);
eraseFish(g);
direction += 90;
if (direction == 360)
direction = 0;
drawFish(g);

31. public void eraseFish(Graphics g){
Expo.setColor(g,Expo.white);
switch (direction)
case 0:
Expo.fillOval(g,x,y,15,30);
Expo.fillPolygon(g,x,y+30,x-15,y+40,x+15,y+40);
break;
case 90:
Expo.fillOval(g,x,y,30,15);
Expo.fillPolygon(g,x-30,y,x-40,y-15,x-40,y+15);
case 180:
Expo.fillPolygon(g,x,y-30,x-15,y-40,x+15,y-40);
case 270:
Expo.fillPolygon(g,x+30,y,x+40,y-15,x+40,y+15);
default:
System.out.println("ERROR!!! Direction must be 0,90,180,270"); }

32. // Java0909.java The Fish class, Stage #3
// The Fish3 class adds method moveFish, which moves the Fish object to a specified coordinate.
import java.awt.*;
import java.applet.*;  
public class Java0909 extends Applet {
public void paint(Graphics g)
Fish3 f3 = new Fish3();
f3.drawFish(g);
f3.moveFish(g,800,200);
f3.turnFish(g);
f3.moveFish(g,300,500); }   
class Fish3 extends Fish2
public void moveFish(Graphics g, int newX, int newY)
Expo.delay(1000);
eraseFish(g);
x = newX;
y = newY;
drawFish(g);

33. // Java0910.java The Fish class, Stage #4
// The Fish4 class redefines the moveFish method. Fish objects will now move without erasing themselves.
// Additionally, the Fish4 class adds a constructor, which draws a Fish object at a specified starting location.
import java.awt.*;
import java.applet.*;
public class Java0910 extends Applet {
public void paint(Graphics g)
int xPos = 100;
int yPos = 100;
int direction = 90;
Fish4 f4 = new Fish4(xPos,yPos,direction);
for (int k = 1; k <= 8; k++)
xPos += 80;
f4.moveFish(g,xPos,yPos); }
class Fish4 extends Fish3
public Fish4(Graphics g, int xPos, int yPos, int dir) {
x = xPos;
y = yPos;
direction = dir;
drawFish(g); }
public void moveFish(Graphics g, int newX, int newY)
Expo.delay(1000);
x = newX;
y = newY;

34. Square Fish
Challenge

35. Square Fish Challenge for (int k = 1; k <= 6 ; k++) { xPos += 80;
Change Program Java0910.java so that it displays a “square” of fish. To make the square fit, change the number of fish in the for loop from 8 to 6.
NOTE: This will be similar to the GridWorld labs.
for (int k = 1; k <= 6 ; k++) {
xPos += 80;
f4.moveFish(g,xPos,yPos); }