// TSRJ Workshop 2008 - Advanced Track
// Lecture - Wednesday pm - Part 1: Lifting methods to super classes

// CS U213 Spring 2007
// Lecture 13: February 7, 2007

/*

Goals:

 - More on abstract classes: adding concrete and abstract methods

Introduction:

Sometimes it is uselful to lift common fiels and methods of classes
in a common abstract superclass. Lifting methods can be done in two 
ways. Methods can be added as concrete methods in the abstract class
and then maybe overriden by the subclasses. Alternatively methods 
can be added as abstact methods in the abstract class and then  
implemented by the subclasses.

Let's consider the following example:


                     +------------------------------+
                     |           IShape             | 
                     +------------------------------+ 
                     | double distanceTo()          |
                     | boolean closerTo(IShape that)|
                     | double area()                |        
                     +------------------------------+   
                                   |
                                  / \
                                   |
                     +------------------------------+                     
                     |          AShape              |                     
                     +------------------------------+
 +------------------>| Posn location                |
 |                   +------------------------------+ 
 |                   | double distanceTo0()         |
 |                   | boolean closerTo(IShape that)|
 |                   | double area()                |                      
 |                   +------------------------------+
 |                                / \                            
 |                                ---                            
 |                                 |                             
 |             ----------------------------------------        
 |             |                   |                  |        
 |     +---------------+       +--------+      +-----------+  
 |     | Circle        |       | Line   |      | Rectangle |  
 |     +---------------+       +--------+      +-----------+  
 |     | int radius    |       | int dx |      | int w     |  
 |     +---------------+       | int dy |      | int h     |         
 |                             +--------+      +-----------+  
 |
 |
 |
 |
 |   +-----------------+
 +---|    Posn         |
     +-----------------+
     | int x           |
     | int y           |
     +-----------------+
     |double distTo0() |
     +-----------------+    


Classes Circle, Line and Rectangle share common fields and methods.
We lift all of them to the common abstract class AShape.

Let's see how we will design and implement each one of the common methods:                                                           

--------------- 
--distanceTo0--
---------------

This method has similar behavior for the Rectangle and Line but not for Circle.
So we can implement this method as concrete method in IShape and have Circle 
override it with his own implementation. When Rectangle and Line refer to 
distanceTo0, the superclass's method is invoked. However when Circle refers to 
distanceTo0, the its own method is invoked.This way we skip repeating code for 
Rectangle and Line.

//In AShape
//compute this shape's distance from (0,0)
double distanceTo0(){
 return this.location.distTo0()}

//In Circle
//compute this circle's distance from (0,0)
double distanceTo0(){
 return this.location.distTo0()-this.radius}

//No additions in Rectangle and Line 

---------------- 
----closerTo----
----------------

This method has similar behavior for all shapes.
So we can implement this method as concrete method in IShape.
This way we skip repeating code.

//In AShape
//compare this shape's distance from (0,0) 
//with this shape's distance from (0,0) 
boolean closerTo(){
 return this.distanceTo0()<that.distanceTo0()}

//No additions in Circle, Rectangle and Line 


------------ 
----area----
------------

This method has unique behavior for each shape.
So we can add this method as and method in IShape
and implement it explicitely in each one of the other
classes.

//In AShape
//compute the area of this shape 
abstract double area();

//In Circle
//compute the area of this circle 
double area(){ 
   return 3.14*this.radius*this.radius};

//In Rectangle
//compute the area of this rectangle 
double area(){ 
   return this.w*this.h};

//In Line
//compute the area of this line 
double area(){ 
   return 0};

*/

//to represent a cartesian point
class Posn{
 int x;
 int y;

 Posn(int x,int y)
 {
  this.x=x;
  this.y=y;
 }

 double distTo0(){
 return Math.sqrt(this.x*this.x+this.y*this.y);}
}


// to represent a shape
interface IShape{

//compute this shape's area 
double area();
//compute this shape's distance from (0,0)
double distanceTo0();
//compare this shape's distance from (0,0)
//with that shape's distance from (0,0)  
boolean closerTo(IShape that);
}


abstract class AShape implements IShape{
  Posn location;

  AShape(Posn location){
    this.location=location;}

//compute this shape's area 
  abstract double area();

//compute this shape's distance from (0,0)
  double distanceTo0(){
  return this.location.distTo0();}

//compare this shape's distance from (0,0)
//with that shape's distance from (0,0)  
 boolean closerTo(IShape that){
 return this.distanceTo0()<that.distanceTo0();}

}

// to represent a circle
class Circle extends AShape {
  int radius;

 Circle(Posn location,int radius) {
    super(location);
    this.radius = radius;
 }


//compute the area of this circle 
double area(){ 
   return 3.14*this.radius*this.radius;}


//compute this circle's distance from (0,0)
  double distanceTo0(){
return this.location.distTo0()-this.radius;}

}

// to represent a rectangle
class Rectangle extends AShape {
  int w;
  int h;

 Rectangle(Posn location,int w, int h) {
    super(location);
    this.w = w;
    this.h=h;
 }


//compute the area of this rectangle 
double area(){ 
   return this.w*this.h;}


//compute this rectangle's distance from (0,0)
  double distanceTo0(){
return this.location.distTo0();}

}

// to represent a line
class Line extends AShape {
  int dx;
  int dy;

 Line(Posn location,int dx, int dy) {
    super(location);
    this.dx = dx;
    this.dy=dy;
 }


//compute the area of this line 
double area(){ 
   return 0;}


//compute this line's distance from (0,0)
  double distanceTo0(){
return this.location.distTo0();}

}

class Examples{

 Posn a = new Posn(2,3);
 Posn b = new Posn(3,3);
 IShape c=new Circle(a,10);
 IShape r=new Rectangle(a,10,10);
 IShape l=new Line(b,10,10);

 boolean test1 = check this.c.area() expect 3.14*100 within 0.01;
 boolean test2 = check this.c.closerTo(this.r) expect true;
 boolean test3 = check this.l.area() expect 0 within 0.01;
 boolean test4 = check this.r.closerTo(this.l) expect true;

}