; lect8 Poly
Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out
Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

lect8 Poly

VIEWS: 24 PAGES: 55

programming language c sharp ,learn c# by slides

More Info
  • pg 1
									                       1




Advanced Programming

      Lecture 7
     Inheritance
         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
                                            6
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;
      }
  }
                                            7
    public string LastName
    {
       get
       {
          return lastName;
       }
       set
       {
          lastName = value;
       }
    }
    public string toString()
    {
       return FirstName + " " + LastName;
    }
    public abstract decimal Earnings();
}
                                                                 8
    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;
          }
      }
                                            9
    public override decimal Earnings()
    {
       return WeeklySalary;
    }
    public override string ToString()
    {
       return "Boss: " + base.ToString();
    }
}
                                                               10
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;
      }
                                             11
    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;
    }
                                                       12
      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
                                                                  13
    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;
         }
     }
                                                   14
    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();
    }
}
                                                                      15
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;
         }
    }
                                                              16
    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 );
                                                        17
               return basePay + overtimePay;
           }
        }
        public override string toString()
        {
           return "HourlyWorker: " + base.ToString();
}
    }
                                                                        18
 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;
                                                                  19
 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";
       }
   }
         20




String
                                                            21
 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
                                                          23
 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
                                                                       25
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";
                                                                  26
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
                                                                      29
    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)
                                                                35
 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
                                                            36
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;
      }
                                                 37
      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
                                                              38
  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;
      }
                                                   39
      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
                                                                      40
    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" );
                                                                      41
 // 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
                                                      42

                     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
                                                      43

                    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
                                                                    44

    public interface Ishape
    {
    // classes that implement IShape must implement these methods
       // and this property
       double Area();
       double Volume();
      string Name { get; }
}
                                              45
// 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;
     }
                                                     46
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       {
                                                           47
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
                                                         48
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      }
                                                     49
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 );
                                                      50
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
                                                           51
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;
                                                       52
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()
                                                       53
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
                                                          54
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
                                                         55
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