/*
C# A Beginner's Guide
By Schildt

Publisher: Osborne McGraw-Hill
ISBN: 0072133295
*/

/* 
  Project 8-1 
 
  Build a derived class of Vehicle for trucks. 
*/ 
using System; 
 
class Vehicle {    
  int pri_passengers; // number of passengers    
  int pri_fuelcap;    // fuel capacity in gallons   
  int pri_mpg;        // fuel consumption in miles per gallon   
   
  // This is a constructor for Vehicle.  
  public Vehicle(int p, int f, int m) {  
    passengers = p;  
    fuelcap = f;  
    mpg = m;  
  }  
 
  // Return the range.   
  public int range() {   
    return mpg * fuelcap;   
  }   
   
  // Compute fuel needed for a given distance.  
  public double fuelneeded(int miles) {   
    return (double) miles / mpg;   
  } 
 
  // Properties 
  public int passengers { 
    get { return pri_passengers; } 
    set { pri_passengers = value; } 
  }   
 
  public int fuelcap { 
    get { return pri_fuelcap; } 
    set { pri_fuelcap = value; } 
  }   
 
  public int mpg { 
    get { return pri_mpg; } 
    set { pri_mpg = value; } 
  }   
}    
  
// Use Vehicle to create a Truck specialization.    
class Truck : Vehicle {  
  int pri_cargocap; // cargo capacity in pounds  
  
  // This is a constructor for Truck.  
  public Truck(int p, int f, int m, int c) : base(p, f, m)  
  {  
    cargocap = c;  
  }  
 
  // Property for cargocap. 
  public int cargocap { 
    get { return pri_cargocap; } 
    set { pri_cargocap = value; } 
  }   
}  
    
public class TruckDemo {    
  public static void Main() {    
  
    // construct some trucks 
    Truck semi = new Truck(2, 200, 7, 44000);    
    Truck pickup = new Truck(3, 28, 15, 2000);    
    double gallons;   
    int dist = 252;   
   
    gallons = semi.fuelneeded(dist);    
    
    Console.WriteLine("Semi can carry " + semi.cargocap +  
                       " pounds."); 
    Console.WriteLine("To go " + dist + " miles semi needs " +   
                       gallons + " gallons of fuel.
");   
       
    gallons = pickup.fuelneeded(dist);    
    
    Console.WriteLine("Pickup can carry " + pickup.cargocap +  
                       " pounds."); 
    Console.WriteLine("To go " + dist + " miles pickup needs " +   
                       gallons + " gallons of fuel.");  
  }    
}


           
          

   

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


/*  In a multilevel hierarchy, the  
    first override of a virtual method 
    that is found while moving up the 
    heirarchy is the one executed. */ 
  
using System;  
  
class Base {  
  // Create virtual method in the base class.   
  public virtual void who() {  
    Console.WriteLine("who() in Base");  
  }  
}  
  
class Derived1 : Base {  
  // Override who() in a derived class.  
  public override void who() {  
    Console.WriteLine("who() in Derived1");  
  }  
}  
  
class Derived2 : Derived1 {  
  // This class also does not override who().  
}  
 
class Derived3 : Derived2 {  
  // This class does not override who().  
}  
 
public class NoOverrideDemo2 {  
  public static void Main() {  
    Derived3 dOb = new Derived3();  
    Base baseRef; // a base-class reference  
  
    baseRef = dOb;   
    baseRef.who(); // calls Derived1's who()  
  }  
}


           
          

   

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


// Pass a derived class reference to a base class reference. 
 
using System; 
 
class TwoDShape { 
  double pri_width;  // private 
  double pri_height; // private 
 
  // Default constructor. 
  public TwoDShape() { 
    width = height = 0.0; 
  } 
 
  // Constructor for TwoDShape. 
  public TwoDShape(double w, double h) { 
    width = w; 
    height = h; 
  } 
 
  // Construct object with equal width and height. 
  public TwoDShape(double x) { 
    width = height = x; 
  } 
 
  // Construct object from an object. 
  public TwoDShape(TwoDShape ob) { 
    width = ob.width; 
    height = ob.height; 
  } 
 
  // Properties for width and height. 
  public double width { 
     get { return pri_width; } 
     set { pri_width = value; } 
  } 
 
  public double height { 
     get { return pri_height; } 
     set { pri_height = value; } 
  } 
 
  public void showDim() { 
    Console.WriteLine("Width and height are " + 
                       width + " and " + height); 
  } 
} 
 
// A derived class of TwoDShape for triangles. 
class Triangle : TwoDShape { 
  string style; // private 
   
  // A default constructor. 
  public Triangle() { 
    style = "null"; 
  } 
 
  // Constructor for Triangle. 
  public Triangle(string s, double w, double h) : base(w, h) { 
    style = s;  
  } 
 
  // Construct an isosceles triangle. 
  public Triangle(double x) : base(x) { 
    style = "isosceles";  
  } 
 
  // Construct an object from an object. 
  public Triangle(Triangle ob) : base(ob) { 
    style = ob.style; 
  } 
 
  // Return area of triangle. 
  public double area() { 
    return width * height / 2; 
  } 
 
  // Display a triangle's style. 
  public void showStyle() { 
    Console.WriteLine("Triangle is " + style); 
  } 
} 
 
public class Shapes7 { 
  public static void Main() { 
    Triangle t1 = new Triangle("right", 8.0, 12.0); 
 
    // make a copy of t1 
    Triangle t2 = new Triangle(t1); 
 
    Console.WriteLine("Info for t1: "); 
    t1.showStyle(); 
    t1.showDim(); 
    Console.WriteLine("Area is " + t1.area()); 
 
    Console.WriteLine(); 
 
    Console.WriteLine("Info for t2: "); 
    t2.showStyle(); 
    t2.showDim(); 
    Console.WriteLine("Area is " + t2.area()); 
  } 
}


           
          

   

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


// A base class reference can refer to a derived class object. 
 
using System; 
 
class X { 
  public int a; 
 
  public X(int i) { 
    a = i; 
  } 
} 
 
class Y : X { 
  public int b; 
 
  public Y(int i, int j) : base(j) { 
    b = i; 
  } 
} 
 
public class BaseRef { 
  public static void Main() { 
    X x = new X(10); 
    X x2;  
    Y y = new Y(5, 6); 
 
    x2 = x; // OK, both of same type 
    Console.WriteLine("x2.a: " + x2.a); 
 
    x2 = y; // still Ok because Y is derived from X 
    Console.WriteLine("x2.a: " + x2.a); 
 
    // X references know only about X members 
    x2.a = 19; // OK 
//    x2.b = 27; // Error, X doesn't have a b member 
  } 
}


           
          

   

/*
C#: The Complete Reference 
by Herbert Schildt 

Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/


// A simple class hierarchy. 
 
using System; 


 
public class Shapes { 
  public static void Main() { 
    Triangle t1 = new Triangle(); 
    Triangle t2 = new Triangle(); 
 
    t1.width = 4.0; 
    t1.height = 4.0; 
    t1.style = "isosceles"; 
 
    t2.width = 8.0; 
    t2.height = 12.0; 
    t2.style = "right"; 
 
    Console.WriteLine("Info for t1: "); 
    t1.showStyle(); 
    t1.showDim(); 
    Console.WriteLine("Area is " + t1.area()); 
 
    Console.WriteLine(); 
 
    Console.WriteLine("Info for t2: "); 
    t2.showStyle(); 
    t2.showDim(); 
    Console.WriteLine("Area is " + t2.area()); 
  } 
}

 
// A class for two-dimensional objects. 
public class TwoDShape { 
  public double width; 
  public double height; 
 
  public void showDim() { 
    Console.WriteLine("Width and height are " + 
                       width + " and " + height); 
  } 
} 
 
// Triangle is derived from TwoDShape. 
public class Triangle : TwoDShape { 
  public string style; // style of triangle 
   
  // Return area of triangle. 
  public double area() { 
    return width * height / 2; 
  } 
 
  // Display a triangle's style. 
  public void showStyle() { 
    Console.WriteLine("Triangle is " + style); 
  } 
} 


           
          

/*
Learning C#
by Jesse Liberty

Publisher: O'Reilly
ISBN: 0596003765
*/
using System;

class Window
{
// constructor takes two integers to
// fix location on the console
public Window(int top, int left)
{
this.top = top;
this.left = left;
}

// simulates drawing the window
public virtual void DrawWindow()
{
Console.WriteLine(“Window: drawing Window at {0}, {1}”,
top, left);
}

// these members are protected and thus visible
// to derived class methods. We'll examine this
// later in the chapter
protected int top;
protected int left;

}

// ListBox derives from Window
class ListBox : Window
{
// constructor adds a parameter
public ListBox(
int top,
int left,
string contents):
base(top, left) // call base constructor
{

listBoxContents = contents;
}

// an overridden version (note keyword) because in the
// derived method we change the behavior
public override void DrawWindow()
{
base.DrawWindow(); // invoke the base method
Console.WriteLine (“Writing string to the listbox: {0}”,
listBoxContents);
}

private string listBoxContents; // new member variable
}

class Button : Window
{
public Button(
int top,
int left):
base(top, left)
{
}

// an overridden version (note keyword) because in the
// derived method we change the behavior
public override void DrawWindow()
{
Console.WriteLine(“Drawing a button at {0}, {1}
“,
top, left);
}
}

public class TesterClassArray1
{
static void Main()
{
Window win = new Window(1,2);
ListBox lb = new ListBox(3,4,”Stand alone list box”);
Button b = new Button(5,6);
win.DrawWindow();
lb.DrawWindow();
b.DrawWindow();

Window[] winArray = new Window[3];
winArray[0] = new Window(1,2);
winArray[1] = new ListBox(3,4,”List box in array”);
winArray[2] = new Button(5,6);

for (int i = 0;i < 3; i++) { winArray[i].DrawWindow(); } } } [/csharp]

   

/*
Learning C# 
by Jesse Liberty

Publisher: O'Reilly 
ISBN: 0596003765
*/
 using System;

 class Window
 {
     // constructor takes two integers to
     // fix location on the console
     public Window(int top, int left)
     {
         this.top = top;
         this.left = left;
     }

     // simulates drawing the window
     public void DrawWindow()
     {
         Console.WriteLine("Drawing Window at {0}, {1}",
             top, left);
     }

     // these members are private and thus invisible
     // to derived class methods; we'll examine this
     // later in the chapter
     private int top;
     private int left;
 }

 // ListBox derives from Window
 class ListBox : Window
 {
     // constructor adds a parameter
     public ListBox(
         int top,
         int left,
         string theContents):
         base(top, left)  // call base constructor
     {
         mListBoxContents = theContents;
     }

     // a new version (note keyword) because in the
     // derived method we change the behavior
     public new void DrawWindow()
     {
         base.DrawWindow();  // invoke the base method
         Console.WriteLine ("Writing string to the listbox: {0}",
             mListBoxContents);
     }
     private string mListBoxContents;  // new member variable
 }

 public class HierarchyTester
 {
     public static void Main()
     {
         // create a base instance
         Window w = new Window(5,10);
         w.DrawWindow();

         // create a derived instance
         ListBox lb = new ListBox(20,30,"Hello world");
         lb.DrawWindow();
     }
 }