lect7 Inhirt by mohamed.aly12

VIEWS: 3 PAGES: 85

									                       1




Advanced Programming

      Lecture 7
     Inheritance
                                                       2

             static Class Members

• Every object of a class has its own copy of all
  instance variables
• Sometimes it is useful if all instances of a class
  share the same copy of a variable
• Declare variables using keyword static to create
  only one copy of the variable at a time (shared by
  all objects of the type)
• Scope may be defined for static variables (public,
  private, etc.)
                                                  3
     using System;
    public class Employee   {
       private string firstName;
       private string lastName;
       private static int count;
public Employee( string fName, string lName )
{
  firstName = fName;lastName = lName; ++count;
   Console.WriteLine( "Employee object
constructor: " +firstName + " " + lastName + ";
count = " + Count );
}
~Employee() {
          --count;
Console.WriteLine( "Employee object destructor:
" +firstName + " " + lastName + "; count = " +
Count );}
                               4
 public string FirstName   {
      get
      {
         return firstName;
      } }
   public string LastName
   {
      get
      {
         return lastName;
      }
   }
   public static int Count
   {
      get
      {
         return count;
      }
   }
} // end class Employee
                                                  5
   using System;
    class StaticTest {
 static void Main( string[] args ) {
Console.WriteLine( "Employees before
instantiation: " +Employee.Count + "\n" );

Employee employee1 = new Employee( "Susan",
"Baker" );
Employee employee2 = new Employee( "Bob",
"Jones" );
Console.WriteLine( "\nEmployees after
instantiation: " +"Employee.Count = " +
Employee.Count + "\n" );
Console.WriteLine( "Employee 1: " +
  employee1.FirstName + " " +employee1.LastName
+"\nEmployee 2: " + employee2.FirstName +
 " + employee2.LastName + "\n" );
   employee1 = null;   employee2 = null;
                                                             6
36           Console.WriteLine(
37              "\nEmployees after garbage collection: " +
38              Employee.Count );
39       }
40   }


Employees before instantiation: 0

Employee object constructor: Susan Baker; count = 1
Employee object constructor: Bob Jones; count = 2

Employees after instantiation: Employee.Count = 2

Employee 1: Susan Baker
Employee 2: Bob Jones

Employee object destructor: Bob Jones; count = 1
Employee object destructor: Susan Baker; count = 0

Employees after garbage collection: 0
                                                                7

                     Inheritance

Classes are created by absorbing the methods and
variables of an existing class
– It then adds its own methods to enhance its capabilities
– This class is called a derived class because it inherits
  methods and variables from a base class
– Objects of derived class are objects of base class, but not
  vice versa
– “Is a” relationship: derived class object can be treated as
  base class object
– “Has a” relationship: class object has object references as
  members
– A derived class can only access non-private base class
  members unless it inherits accessor funcitons
                                                       8

      Base Classes and Derived Classes

• Every derived-class is an object of its base class
• Inheritance forms a tree-like hierarchy
• To specify class one is derived from class two
   – class one : two
• Composition:
   – Formed by “has a” relationships
• Constructors are not inherited
                                                    9

                Base Classes and Derived Classes

Ba se c la ss                Derived c la sses
Student                      GraduateStudent
                             UndergraduateStudent

Shape                        Circle
                             Triangle
                             Rectangle
Loan                         CarLoan
                             HomeImprovementLoan
                             MortgageLoan
Employee                     FacultyMember
                             StaffMember
Account                      CheckingAccount
                             SavingsAccount
Fig. 9.1        Inherita nc e exa mp les.
                                                                 10

                Base Classes and Derived Classes

                                    CommunityMemeber




                 Employee               Student        Alumnus



          Faculty           Staff




Administrator     Teacher
                                                                       11

         Base Classes and Derived Classes

                                Shape




     TwoDimensionalShape                   ThreeDimensionalShape




Circle     Square    Triangle           Sphere    Cube      Cylinder
                                                    12
    using System;
public class Point
    {
private int x, y;

public Point()
      {
     }
public Point( int xValue, int yValue )
      {                                  Point.cs
     X = xValue;
        Y = yValue;
      }
public int X
      {
         get
         {
             return x;
         }
                                                13
      set
      {
         x = value; // no need for validation
      }
   } // end property X
   public int Y
   {
      get
      {
         return y;
      }
      set
      {
         y = value; // no need for validation
      }
   } // end property Y

   public override string ToString()
   {
      return "[" + x + ", " + y + "]";
   }
} // end class Point
                                   Declare class Circle to    14
   using System;                   derive from class Point
  class Circle : Point
   {
      private double radius; // Circle2's radius
     public Circle()
     {
     }
public Circle( int xValue, int yValue, double radiusValue )
     {
        x = xValue;
        y = yValue;
        Radius = radiusValue;                   Circle2.cs
     }
     public double Radius
     {
        get
        {
            return radius;
        }
                                                              15
      set {
         if ( value >= 0 ) radius = value;        }
   } // end property Radius
   public double Diameter()
   {
      return radius * 2;
   }
   public double Circumference()
   {
      return Math.PI * Diameter();
   }
   public virtual double area()
                                                 Circle2.cs
   {
      return Math.PI * Math.Pow( radius, 2 );
   }
   public override string ToString()
   {
      return "Center = [" + x + ", " + y + "]" +
         "; Radius = " + radius;
   }
} // end class Circle2
16
                                                                    17

     protected and internal Members

• protected members
   – Can be accessed by base class or any class derived from that
     base class
• internal members:
   – Can only be accessed by classed declared in the same
     assembly
• Overridden base class members can be accessed:
   – base.member
                                                  18
using System;

public class Point2
{
  protected int x, y;
  public Point2()
  {
  }
  public Point2( int xValue, int yValue )
  {                                   Point2.cs
     X = xValue;
     Y = yValue;
  }
  public int X
  {
     get
     {
         return x;
     }
                                             19
   set
   {
      x = value; // no need for validation
   }

} // end property X
public int Y
{
   get
  {
     return y;
   }

   set
   {
      y = value; // no need for validation
   }

} // end property Y

public override string ToString()
{
   return "[" + x + ", " + y + "]";
}
                                                                          20
using System;
   public class Circle3 : Point2
    {
       private double radius; // Circle's radius
      public Circle3()
      {
         // implicit call to Point constructor occurs here
      }

      // constructor
      public Circle3(
int xValue, int yValue, double radiusValue )
     {
         // implicit call to Point constructor occurs here
         x = xValue;
         y = yValue;                                         Circle3.cs
         Radius = radiusValue;
      }

      // property Radius
      public double Radius
     {
        get
         {
            return radius;
         }
                                                                   21
         set
         {
            if ( value >= 0 )
               radius = value;
         }

      } // end property Radius
public double Diameter()
      {
         return radius * 2;
      }

public double Circumference()
      {
         return Math.PI * Diameter();
      }                                               Circle3.cs

      // calculate Circle area
      public virtual double Area()
      {
         return Math.PI * Math.Pow( radius, 2 );
      }

public override string ToString()
      {
         return "Center = [" + x + ", " + y + "]" +
            "; Radius = " + radius;
      }
   } // end class Circle3
                                                                     22
    using System;
    using System.Windows.Forms;

    // CircleTest3 class definition
    class CircleTest3
    {
      // main entry point for application
      static void Main( string[] args )
{
        // instantiate Circle3
       Circle3 circle = new Circle3( 37, 43, 2.5 );

         string output = "X coordinate is " + circle.X + "\n" +
           "Y coordinate is " + circle.Y + "\nRadius is " +
           circle.Radius;

         // set Circle3's x-y coordinates and radius to new values
         circle.X = 2;
         circle.Y = 2;
         circle.Radius = 4.25;

         // display Circle3's string representation
         output += "\n\n" +
            "The new location and radius of circle are " +
            "\n" + circle + "\n";

         // display Circle3's Diameter
         output += "Diameter is " +
            String.Format( "{0:F}", circle.Diameter() ) + "\n";
                                                                    23
      // display Circle3's Circumference
      output += "Circumference is " +
         String.Format( "{0:F}", circle.Circumference() ) + "\n";

      // display Circle3's Area
      output += "Area is " +
         String.Format( "{0:F}", circle.Area() );

      MessageBox.Show( output, "Demonstrating Class Circle3" );

   } // end method Main

} // end class CircleTest3
     Case Study: Three-Level Inheritance
                 Hierarchy


• Three-level inheritance example:


   – Class Cylinder inherits from class Circle


   – Class Circle inherits from class Point
                                                                     25
     using System;
   // Cylinder class definition inherits from Circle4
   public class Cylinder : Circle4
   {
      private double height;

     // default constructor
public Cylinder( int xValue, int yValue, double radiusValue,
        double heightValue ) : base( xValue, yValue, radiusValue )
     {
        Height = heightValue; // set Cylinder height
     }
     // property Height
     public double Height
     {
        get
        {
           return height;
        }

        set
        {
           if ( value >= 0 ) // validate height
             height = value;
                                                                26
      }

   } // end property Height

   // override Circle4 method Area to calculate Cylinder area
   public override double Area()
   {
      return 2 * base.Area() + base.Circumference() * Height;
   }

   // calculate Cylinder volume
   public double Volume()
   {
      return base.Area() * Height;
   }

   // convert Cylinder to string
   public override string ToString()
   {
      return base.ToString() + "; Height = " + Height;
   }

} // end class Cylinder
                                                                   27
 using System;
using System.Windows.Forms;

// CylinderTest class definition
class CylinderTest
{
  // main entry point for application
  static void Main( string[] args )
  {
     // instantiate object of class Cylinder
     Cylinder cylinder = new Cylinder(12, 23, 2.5, 5.7);

     // properties get initial x-y coordinate, radius and height
     string output = "X coordinate is " + cylinder.X + "\n" +
        "Y coordinate is " + cylinder.Y + "\nRadius is " +
        cylinder.Radius + "\n" + "Height is " + cylinder.Height;

     // properties set new x-y coordinate, radius and height
     cylinder.X = 2;
     cylinder.Y = 2;
     cylinder.Radius = 4.25;
     cylinder.Height = 10;

     // get new x-y coordinate and radius
     output += "\n\nThe new location, radius and height of " +
        "cylinder are\n" + cylinder + "\n\n";

     // display Cylinder's Diameter
     output += "Diameter is " +
        String.Format( "{0:F}", cylinder.Diameter() ) + "\n";
                                                                     28
     // display Cylinder's Circumference
     output += "Circumference is " +
        String.Format( "{0:F}", cylinder.Circumference() ) + "\n";

     // display Cylinder's Area
     output += "Area is " +
        String.Format( "{0:F}", cylinder.Area() ) + "\n";

     // display Cylinder's Volume
     output += "Volume is " +
        String.Format( "{0:F}", cylinder.Volume() );

     MessageBox.Show( output, "Demonstrating Class Cylinder" );

  } // end method Main

} // end class CylinderTest
                                                                      29

                           Example

• Imagine a publishing company that markets both Book and
  audio-CD versions of its works. Create a class publication
  that stores the title (string), price (float) and sales (array of
  three floats) of a publication.
• This class is used as base class for two classes: Book
  which has page count (int) and audio-CD which has
  playing time in minutes (float). Each of these three classes
  should have a get_data() and display_data() methods.
• Write a Main class to create Book and audio-CD objects,
  asking user to fill in their data with get_data( ) method, and
  then displaying data with display_data( ) method.
  Relationship between Base Classes and
             Derived Classes
• Use a point-circle hierarchy to represent
  relationship between base and derived classes
• The first thing a derived class does is call its base
  class’ constructor, either explicitly or implicitly
• override keyword is needed if a derived-class
  method overrides a base-class method
• If a base class method is going to be overridden it
  must be declared virtual
  Constructors and Destructors in Derived
                 Classes

• Instantiating a derived class, causes base class
  constructor to be called, implicitly or explicitly
   – Can cause chain reaction when a base class is also a derived
     class

• When a destructor is called, it performs its task
  and then invokes the derived class’ base class
  destructor
         Abstract Classes and Methods

• Abstract classes
   – Cannot be instantiated

   – Used as base classes

   – Class definitions are not complete – derived classes must
     define the missing pieces

   – Can contain abstract methods and/or abstract properties
       • Have no implementation

       • Derived classes must override inherited abstract methods and
         properties to enable instantiation
        Abstract Classes and Methods

• Concrete classes use the keyword override to
  provide implementations for all the abstract
  methods and properties of the base-class
• Any class with an abstract method or property
  must be declared abstract
• Even though abstract classes cannot be
  instantiated, we can use abstract class references
  to refer to instances of any concrete class derived
  from the abstract class
     Case Study: Inheriting Interface and
              Implementation
• Abstract base class Shape
   – Concrete virtual method Area (default return value is 0)
   – Concrete virtual method Volume (default return value is 0)
   – Abstract read-only property Name
• Class Point2 inherits from Shape
   – Overrides property Name (required)
   – Does NOT override methods Area and Volume
• Class Circle2 inherits from Point2
   – Overrides property Name
   – Overrides method Area, but not Volume
• Class Cylinder2 inherits from Circle2
   – Overrides property Name
   – Overrides methods Area and Volume
            Case Study: Payroll System

• Base-class Employee
   – abstract
   – abstract method Earnings
• Classes that derive from Employee
   –   Boss
   –   CommissionWorker
   –   PieceWorker
   –   HourlyWorker
• All derived-classes implement method Earnings
• Driver program uses Employee references to refer to
  instances of derived-classes
• Polymorphism calls the correct version of Earnings
                                            36
using System;
public abstract class Employee
{
    private string firstName;
    private string lastName;
  public Employee( string firstNameValue,
      string lastNameValue )
  {
      FirstName = firstNameValue;
      LastName = lastNameValue;
  }
  public string FirstName
  {
      get
      {
         return firstName;
      }
      set
      {
         firstName = value;
      }
  }
                                            37
    public string LastName
    {
       get
       {
          return lastName;
       }
       set
       {
          lastName = value;
       }
    }
    public string toString()
    {
       return FirstName + " " + LastName;
    }
    public abstract decimal Earnings();
}
                                                                38
    using System;
    public class Boss : Employee
    {
        private decimal salary;
public Boss( string firstNameValue, string stNameValue,
        decimal salaryValue): base( firstNameValue,lastNameValue )
      {
          WeeklySalary = salaryValue;
      }
      public decimal WeeklySalary
      {
          get
          {
             return salary;
          }

          set
          {
             if ( value > 0 )
                salary = value;
          }
      }
                                            39
    public override decimal Earnings()
    {
       return WeeklySalary;
    }
    public override string ToString()
    {
       return "Boss: " + base.ToString();
    }
}
                                                               40
using System;
public class CommissionWorker : Employee
{
    private decimal salary;     // base weekly salary
    private decimal commission; // amount paid per item sold
    private int quantity;       // total items sold
  public CommissionWorker( string firstNameValue,
      string lastNameValue, decimal salaryValue,
      decimal commissionValue, int quantityValue )
      : base( firstNameValue, lastNameValue )
  {
      WeeklySalary = salaryValue;
      Commission = commissionValue;
      Quantity = quantityValue;
  }
  public decimal WeeklySalary
  {
      get
      {
         return salary;
      }
                                             41
    set
    {
       // ensure non-negative salary value
       if ( value > 0 )
          salary = value;
    }
}
 public decimal Commission
 {
    get
    {
       return commission;
    }
     set
    {
        if ( value > 0 )
           commission = value;
     }
 }
 public int Quantity
 {
    get
    {
       return quantity;
    }
                                                       42
      set
      {
         if ( value > 0 )
            quantity = value;
      }
   }
   public override decimal Earnings()
   {
      return WeeklySalary + Commission * Quantity;
   }

   public override string toString()
   {
      return "CommissionWorker: " + base.ToString();
   }
} // end class CommissionWorker
                                                                  43
    using System;
    public class PieceWorker : Employee
{
       private decimal wagePerPiece; // wage per piece produced
       private int quantity;         // quantity of pieces
    public PieceWorker( string firstNameValue,
         string lastNameValue, decimal wagePerPieceValue,
         int quantityValue )
         : base( firstNameValue, lastNameValue )
     {
         WagePerPiece = wagePerPieceValue;
         Quantity = quantityValue;
     }
     public decimal WagePerPiece
     {
         get
         {
             return wagePerPiece;
         }

         set
         {
               if ( value > 0 )
                  wagePerPiece = value;
         }
     }
                                                   44
    public int Quantity
    {
       get
       {
           return quantity;
       }
       set
       {
           if ( value > 0 )
              quantity = value;
       }
    }
    public override decimal Earnings()
    {
       return Quantity * WagePerPiece;
    }
    public override string ToString()
    {
       return "PieceWorker: " + base.ToString();
    }
}
                                                                      45
using System;
public class HourlyWorker : Employee
{
      private decimal wage;        // wage per hour of work
      private double hoursWorked; // hours worked during week
  public HourlyWorker( string firstNameValue, string LastNameValue,
         decimal wageValue, double hoursWorkedValue )
         : base( firstNameValue, LastNameValue )
    {
         Wage = wageValue;
         HoursWorked = hoursWorkedValue;
  }
  public decimal Wage
    {
         get
         {
             return wage;
         }
         set
       {
           if ( value > 0 )
                wage = value;
         }
    }
                                                              46
    public double HoursWorked
    {
       get
       {
           return hoursWorked;
       }
       set
       {
           if ( value > 0 )
              hoursWorked = value;
       }
    }
    public override decimal Earnings()
{
       if ( HoursWorked <= 40 )
       {
          return Wage * Convert.ToDecimal( HoursWorked );
       }
       else
       {
          decimal basePay = Wage * Convert.ToDecimal( 40 );
          decimal overtimePay = Wage * 1.5M *
             Convert.ToDecimal( HoursWorked - 40 );
                                                        47
               return basePay + overtimePay;
           }
        }
        public override string toString()
        {
           return "HourlyWorker: " + base.ToString();
}
    }
                                                                        48
 public class EmployeesTest    {
     public static void Main( string[] args ) {
      Boss boss = new Boss( "John", "Smith", 800 );
  CommissionWorker commissionWorker =
      new CommissionWorker( "Sue", "Jones", 400, 3, 150 );
 PieceWorker pieceWorker = new PieceWorker( "Bob","Lewis",
             Convert.ToDecimal( 2.5 ), 200 );
   HourlyWorker hourlyWorker = new HourlyWorker( "Karen",
             "Price", Convert.ToDecimal( 13.75 ), 50 );
        Employee employee = boss;
string output = GetString( employee ) + boss + " earned " +
boss.Earnings().ToString( "C" ) + "\n\n";
          employee = commissionWorker;
      output += GetString( employee ) + commissionWorker +
" earned " +            commissionWorker.Earnings().ToString( "C" ) +
"\n\n";
          employee = pieceWorker;
                                                                  49
 output += GetString( employee ) + pieceWorker +
  " earned " + pieceWorker.Earnings().ToString( "C" ) + "\n\n";
          employee = hourlyWorker;
      output += GetString( employee ) + hourlyWorker +
" earned " + hourlyWorker.Earnings().ToString( "C" ) +"\n\n";
     MessageBox.Show( output, "Demonstrating Polymorphism",
           MessageBoxButtons.OK, MessageBoxIcon.Information );
      } // end method Main
       // return string that contains Employee information
       public static string GetString( Employee worker )
       {
          return worker.ToString() + " earned " +
            worker.Earnings().ToString( "C" ) + "\n";
       }
   }
         50




String
                                                            51
 using System;
using System.Windows.Forms;
   class StringConstructor
{
   static void Main( string[] args )
  {
      string output;
    string originalString, string1, string2, string3, string4;

  char[] characterArray = {'b', 'i', 'r', 't', 'h', ' ', 'd',
                              'a', 'y' };
                                               StringConstruct
  originalString = "Welcome to C# programming!";
                                               or.cs
     string1   =   originalString;
     string2   =   new string( characterArray );
     string3   =   new string( characterArray, 6, 3 );
     string4   =   new string( 'C', 5 );

     output = "string1    = " + "\"" + string1 + "\"\n" +
        "string2 = " +    "\"" + string2 + "\"\n" +
        "string3 = " +    "\"" + string3 + "\"\n" +
        "string4 = " +    "\"" + string4 + "\"\n";
String Indexer, Length Property and CopyTo
                   Method

• String indexer

   – Retrieval of any character in the string

• Length property

   – Returns the length of the string

• CopyTo

   – Copies specified number of characters into a char array
                                                          53
 using System;
 using System.Windows.Forms;
class StringMethods
{
   static void Main( string[] args )
   {
      string string1, output;
      char[] characterArray;

      string1 = "hello there";
      characterArray = new char[ 5 ];        StringMethods.c
                                             s
    output = "string1: \"" + string1 + "\"";
    output += "\nLength of string1: " + string1.Length;

   output += "\nThe string reversed is: ";

      for ( int i = string1.Length - 1; i >= 0; i-- )
         output += string1[ i ];
                   Comparing Strings

• String comparison
  – Greater than

  – Less than

• Method Equals
  – Test objects for equality

  – Return a Boolean

  – Uses lexicographical comparison
                                                                       55
using System;
using System.Windows.Forms;

class StringCompare
{
  static void Main(   string[] args )
  {
     string string1   =   "hello";
     string string2   =   "good bye";
     string string3   =   "Happy Birthday";
     string string4   =   "happy birthday";
     string output;

     // output values of    four strings
                                                          StringCompare.c
     output = "string1 =    \"" + string1 + "\"" +
                                                          s
        "\nstring2 = \""    + string2 + "\"" +
        "\nstring3 = \""    + string3 + "\"" +
        "\nstring4 = \""    + string4 + "\"\n\n";

     // test for equality using Equals method
     if ( string1.Equals( "hello" ) )
        output += "string1 equals \"hello\"\n";
     else
        output += "string1 does not equal \"hello\"\n";

     // test for equality with ==
     if ( string1 == "hello" )
        output += "string1 equals \"hello\"\n";
                                                                  56
using System;
using System.Windows.Forms;

class StringStartEnd
{
  static void Main( string[] args )
  {
    string[] strings = { "started", "starting", "ended", "ending" };
     string output = "";
     for ( int i = 0; i < strings.Length; i++ )
        if ( strings[ i ].StartsWith( "st" ) )
     output += "\"" + strings[ i ] + "\"" + " starts with \"st\"\n";
                                                     StringStartEnd.
     output += "\n";                                 cs

     // test every string to see if it ends with "ed“
     for ( int i = 0; i < strings.Length; i ++ )

        if ( strings[ i ].EndsWith( "ed" ) )
           output += "\"" + strings[ i ] + "\"" +
              " ends with \"ed\"\n";
        Miscellaneous String Methods

• Method Replace
  – Original string remain unchanged
  – Original string return if no occurrence matched
• Method ToUpper
  – Replace lower case letter
  – Original string remain unchanged
  – Original string return if no occurrence matched
• Method ToLower
  – Replace lower case letter
  – Original string remain unchanged
  – Original string return if no occurrence matched
         Miscellaneous String Methods

• Method ToString
  – Can be called to obtain a string representation of any object
• Method Trim
  – Remove whitespaces
  – Remove characters in the array argument
                                                                      59
    using System;
    using System.Windows.Forms;

    class StringMethods2
{
     static void Main(     string[] args )
     {
        string string1     = "cheers!";
        string string2     = "GOOD BYE ";
        string string3     = "   spaces   ";
        string output;

         output = "string1 = \"" + string1 + "\"\n" +
                                                         StringMiscellan
            "string2 = \"" + string2 + "\"\n" +
                                                         eous2.cs
            "string3 = \"" + string3 + "\"";

         // call method Replace
         output +=
            "\n\nReplacing \"e\" with \"E\" in string1: \"" +
            string1.Replace( 'e', 'E' ) + "\"";

         // call ToLower and ToUpper
         output += "\n\nstring1.ToUpper() = \"" +
            string1.ToUpper() + "\"\nstring2.ToLower() = \"" +
            string2.ToLower() + "\"";
You have been provided with the following class that implements a
  phone number directory:
  public class PhoneBook {
  public boolean insert(String phoneNum, String name) { ... }
  public String getPhoneNumber(String name) { ... }
  public String getName(String phoneNum) { ... }
  // other private fields and methods }
• PhoneBook does not accept phone numbers that begin with "0" or
  "1", that do not have exactly 10 digits. It does not allow duplicate
  phone numbers. insert() returns true on a successful phone number
  insertion, false otherwise. getPhoneNumber() and getName() return
  null if they cannot find the desired entry in the PhoneBook.
• Design and implement a subclass of PhoneBook called YellowPages
  (including all of the necessary fields and methods) that supports the
  following additional operations.
• Retrieve the total number of phone numbers stored in the directory.
• Retrieve the percentage of phone numbers stored in the directory that
  are "810" numbers (that have area code "810").
• Design an abstract class named BankAccount with data: balance,
  number of deposits this month, number of withdrawals, annual
  interest rate, and monthly service charges.
• The class has constructor and methods: Deposit (amount) {add
  amount to balance and increment number of deposit by one},
  Withdraw (amount) {subtract amount from balance and increment
  number of withdrawals by one}, CalcInterest() { update balance by
  amount = balance * (annual interest rate /12)}, and MonthlyPocess()
  {subtract the monthly service charge from balance, call calcInterest
  method, set number of deposit, number of withdrawals and monthly
  service charges to zero}.
• Next, design a SavingAccount class which inherits from
  BankAccount class. The class has Boolean status field to represent
  the account is active or inactive {if balance falls below $25}. No
  more withdrawals if account is inactive.
• The class has methods Deposit () {determine if account inactive then
  change the status after deposit above $25, then call base deposit
  method}, Withdraw() method check the class is active then call base
  method, and MonthlyProcess() {check if number of withdrawals
  more than 4, add to service charge $1 for each withdrawals above 4}
• Consider designing and implementing a set of classes to
  represent books, library items, and library books.
• a) An abstract class library item contains two pieces of
  information: a unique ID (string) and a holder (string). The
  holder is the name of person who has checked out this item.
  The ID can not change after it is created, but the holder can
  change.
• b) A book class inherits from library item class. It contains
  data author and title where neither of which can change once
  the book is created. The class has a constructor with two
  parameters author and title, and two methods getAuthor() to
  return author value and getTitle() to return title value.
• c) A library book class is a book that is also a library item
  (inheritance). Suggest the required data and method for this
  class.
• d) A library is a collection of library books (Main class) which
  has operations: add new library book to the library, check out a
  library item by specifying its ID, determine the current holder
  of library book given its ID
What will happen when you attempt to compile and
                 run this code?

class Base{
   abstract public void myfunc();
   public void another(){
   console.writeline("Another method");
   }
   }
   public class Abs : Base{
   public static void main(String argv[]){
   Abs a = new Abs();
   a.amethod();
   }
   public void myfunc(){
    console.writeline("My func");
   }
   public void amethod(){
   myfunc();
   }
   }
  Data Abstraction and Information Hiding

• Classes should hide implementation details
• Stacks
   – Last-in, first-out (LIFO)
   – Items are pushed onto the top of the stack
   – Items are popped off the top of the stack
• Queues
   –   Similar to a waiting line
   –   First-in, first-out (FIFO)
   –   Items are enqueued (added to the end)
   –   Items are dequeued (taken off the front)
                                                                65
 Derived-Class-Object to Base-Class-Object
                Conversion
• Class hierarchies
   – Can assign derived-class objects to base-class
      references
   – Can explicitly cast between types in a class hierarchy
• An object of a derived-class can be treated as an object of
  its base-class
   – Array of base-class references that refer to objects of
      many derived-class types
   – Base-class object is NOT an object of any of its derived
      classes
                                                            66
using System;
// Point class definition implicitly inherits from Object
public class Point
{
    // point coordinate
  private int x, y;
  // default constructor
  public Point()
  {
      // implicit call to Object constructor occurs here
  }
  public Point( int xValue, int yValue )
  {
      // implicit call to Object constructor occurs here
      X = xValue;
      Y = yValue;
  }
  public int X
  {
      get
      {
          return x;
      }
                                                 67
      set
      {
        x = value;   // no need for validation
      }

   } // end property X
   // property Y
   public int Y
   {
      get
      {
          return y;
      }
      set
      {
          y = value; // no need for validation
      }
   } // end property Y
   // return string representation of Point
   public override string ToString()
   {
      return "[" + X + ", " + Y + "]";
   }
} // end class Point
                                                              68
  using System;
  // Circle class definition inherits from Point
  public class Circle : Point
  {
      private double radius; // circle's radius
    // default constructor
    public Circle()
    {
        // implicit call to Point constructor occurs here
    }
public Circle( int xValue, int yValue, double radiusValue )
        : base( xValue, yValue )
    {
        Radius = radiusValue;
    }

   // property Radius
   public double Radius
   {
      get
      {
          return radius;
      }
                                                   69
      set
      {
            if ( value >= 0 ) // validate radius
               radius = value;
      }
   } // end property Radius
   public double Diameter()
   {
      return Radius * 2;
   }
   public double Circumference()
   {
      return Math.PI * Diameter();
   }
  public virtual double Area()
   {
      return Math.PI * Math.Pow( Radius, 2 );
   }
   public override string ToString()
   {
      return "Center = " + base.ToString() +
         "; Radius = " + Radius;
   }
} // end class Circle
                                                                      70
    using System;
    using System.Windows.Forms;
class PointCircleTest
    {
      // main entry point for application.
      static void Main( string[] args )
      {
          Point point1 = new Point( 30, 50 );
         Circle circle1 = new Circle( 120, 89, 2.7 );
        string output = "Point point1: " + point1.ToString() +
             "\nCircle circle1: " + circle1.ToString();

         // use 'is a' relationship to assign
         // Circle circle1 to Point reference
         Point point2 = circle1;
output += "\n\nCCircle circle1 (via point2): " + point2.ToString();
           // downcast (cast base-class reference to derived-class
         // data type) point2 to Circle circle2
         Circle circle2 = ( Circle ) point2;
         output += "\n\nCircle circle1 (via circle2): " +
            circle2.ToString();
         output += "\nArea of circle1 (via circle2): " +
            circle2.Area().ToString( "F" );
                                                                      71
 // attempt to assign point1 object to Circle reference
       if ( point1 is Circle )
       {
          circle2 = ( Circle ) point1;
          output += "\n\ncast successful";
       }
       else
       {
   output += "\n\npoint1 does not refer to a Circle";
       }
MessageBox.Show( output, "Demonstrating the 'is a' relationship" );
    } // end method Main
 } // end class PointCircleTest
                                                      72

                     Interfaces

• Interfaces specify the public services (methods
  and properties) that classes must implement
• Interfaces provide no default implementations vs.
  abstract classes which may provide some default
  implementations
• Interfaces are used to “bring together” or relate
  disparate objects that relate to one another only
  through the interface
                                                      73

                    Interfaces

• Interfaces are defined using keyword interface
• Use inheritance notation to specify a class
  implements an interface (ClassName :
  InterfaceName)
• Classes may implement more than one interface (a
  comma separated list of interfaces)
• Classes that implement an interface, must provide
  implementations for every method and property in
  the interface definition
                                                                    74

    public interface Ishape
    {
    // classes that implement IShape must implement these methods
       // and this property
       double Area();
       double Volume();
      string Name { get; }
}
                                              75
// an x-y coordinate pair.
using System;
public class Point3 : Ishape
{
    private int x, y; // Point3 coordinates
  public Point3()
  {
  }

  // constructor
  public Point3( int xValue, int yValue )
  {
     X = xValue;
     Y = yValue;
  }

  // property X
  public int X
  {
     get
     {
         return x;
     }
                                                     76
32           set
33           {
34                 x = value;
35           }
36       }
37
38       // property Y
39       public int Y
40       {
41          get
42          {
43              return y;
44          }
45
46           set
47           {
48                 y = value;
49           }
50       }
51
52       // return string representation of Point3
object
53       public override string ToString()
54       {
                                                           77
64      // implement interface IShape method Volume
65      public virtual double Volume()
66      {
67         return 0;
68      }
69
70      // implement property Name of IShape
71      public virtual string Name
72      {
73         get
74         {
75             return "Point3";Implementation of IShape
76         }                   property Name (required),
77      }                      declared virtual to allow
78                             deriving classes to
79   } // end class Point3     override
                                                         78
1    // Fig. 10.21: Circle3.cs
2    // Circle3 inherits from class Point3 and
overrides key members.
3    using System;
4
5    // Circle3 inherits from class Point3
6    public class Circle3 : Point3
7    {
8       private double radius; // Circle3 radius
9
10      // default constructor
11      public Circle3()
12      {
13          // implicit call to Point3 constructor
occurs here
14      }
15
16      // constructor
17      public Circle3( int xValue, int yValue, double
radiusValue )
18          : base( xValue, yValue )
19      {
20          Radius = radiusValue;
21      }
                                                     79
31       set
32       {
33             // ensure non-negative Radius value
34             if ( value >= 0 )
35                radius = value;
36       }
37   }
38
39   // calculate Circle3 diameter
40   public double Diameter()
41   {
42      return Radius * 2;
43   }
44
45   // calculate Circle3 circumference
46   public double Circumference()
47   {
48      return Math.PI * Diameter();
49   }
50
51   // calculate Circle3 area
52   public override double Area()
53   {
54      return Math.PI * Math.Pow( Radius, 2 );
                                                      80
64      // override property Name from class Point3
65      public override string Name
66      {
67         get
68         {
69             return "Circle3";
70         }
71      }
72
73   } // end class Circle3
                                                           81
1    // Fig. 10.22: Cylinder3.cs
2    // Cylinder3 inherits from class Circle2 and
overrides key members.
3    using System;
4
5    // Cylinder3 inherits from class Circle3
6    public class Cylinder3 : Circle3
7    {
8       private double height; // Cylinder3 height
9
10      // default constructor
11      public Cylinder3()
12      {
13          // implicit call to Circle3 constructor
occurs here
14      }
15
16      // constructor
17      public Cylinder3( int xValue, int yValue,
double radiusValue,
18          double heightValue ) : base( xValue, yValue,
radiusValue )
19      {
20          Height = heightValue;
                                                       82
31         set
32         {
33             // ensure non-negative Height value
34             if ( value >= 0 )
35                height = value;
36         }
37      }
38
39      // calculate Cylinder3 area
40      public override double Area()
41      {
42         return 2 * base.Area() +
base.Circumference() * Height;
43      }
44
45      // calculate Cylinder3 volume
46      public override double Volume()
47      {
48         return base.Area() * Height;
49      }
50
51      // return string representation of Cylinder3
object
52      public override string ToString()
                                                       83
58      // override property Name from class Circle3
59      public override string Name
60      {
61         get
62         {
63             return "Cylinder3";
64         }
65      }
66
67   } // end class Cylinder3
                                                          84
1    // Fig. 10.23: Interfaces2Test.cs
2    // Demonstrating polymorphism with interfaces in
3    // Point-Circle-Cylinder hierarchy.
4
5    using System.Windows.Forms;
6
7    public class Interfaces2Test
8    {
9       public static void Main( string[] args )
10      {
11         // instantiate Point3, Circle3 and Cylinder3
objects
12         Point3 point = new Point3( 7, 11 );
13         Circle3 circle = new Circle3( 22, 8, 3.5 );
14         Cylinder3 cylinder = new Cylinder3( 10, 10,
3.3, 10 );
15
16         // create array of IShape references
17         IShape[] arrayOfShapes = new IShape[ 3 ];
18
19         // arrayOfShapes[ 0 ] references Point3
object
20         arrayOfShapes[ 0 ] = point;
21
                                                         85
32         foreach ( IShape shape in arrayOfShapes )
33         {
34            output += "\n\n" + shape.Name + ":\nArea
= " +
35               shape.Area() + "\nVolume = " +
shape.Volume();
36         }
37
38         MessageBox.Show( output, "Demonstrating
Polymorphism" );
39      }
40    }

								
To top