Object-Oriented Programming:

Inheritance
Outline
1.Introduction

2.Base Classes and Derived Classes

3.protected Members
4.Property and Encapsulation
5.CreatingBase Classes and Derived Classes
Constructors and Destructors in Derived Classes
6.Software Engineering with Inheritance
7.Case Study: Point, Circle, Cylinder

1
Introduction to Inheritance
 Inheritance allows us to define a class in terms of another
class, which makes it easier to create and maintain an
application. This also provides an opportunity to reuse the
code functionality and speeds up implementation time.
 When creating a class, instead of writing completely new
data members and member functions, the programmer can
designate that the new class should inherit the members of
an existing class. This existing class is called
the base class, and the new class is referred to as
the derived 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 access functions
2
Base Classes and Derived
Classes
 An object often is an object of another class
 Every derived-class is an object of its base class
 Inheritance forms a tree-like heirarchy
 To specify class one is derived from class two
 class one : two
 Composition:
 Formed by “has a” relationships
 Constructors are not inherited

3
Base Classes and Derived
Classes

4
 Base Classes and Derived
Classes CommunityMemeber

Employee Student Alumnus

Faculty Staff

Administrator Teacher

Inheritance hierarchy for university Community Members.

5
Base Classes and Derived Classes
Shape

TwoDimensionalShape ThreeDimensionalShape

Circle Square Triangle Sphere Cube Cylinder

Portion of a Shape class hierarchy.

6
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

7
Properties and Encapsulation
 The meaning of Encapsulation, is to make sure that
"sensitive" data is hidden from users. To achieve this,
you must:
 declare fields/variables as private
 provide public get and set methods, through properties, to
access and update the value of a private field.
 A property is like a combination of a variable and a
method, and it has two methods: a get and a set method.

8
 Example Property
class Person static void Main(string[] args)
{ { Person myObj = new Person();
private string name; // field myObj.Name = "Liam";
public string Name // property Console.WriteLine(myObj.Name);
{ get { return name; } // get method }
set { name = value; } // set method
}}

Example explained
•The Name property is associated with the name field. It is a good practice to use
the same name for both the property and the private field, but with an uppercase
first letter.

•The get method returns the value of the variable name.

•The set method assigns a value to the name variable.

•The value keyword represents the value we assign to the property.

9
 10
1 // Fig. 9.4: Point.cs Outline
2 // Point class represents an x-y coordinate pair.
3
4 using System;
5 Point.cs
6 // Point class definition implicitly inherits from Object
7 public class Point
8 {
X and Y coordinates, declared
9 // point coordinates private so other classes cannot
10 private int x, y; directly access them
11
12 // default (no-argument) constructor
13 public Point()
14 {
15 // implicit call to Object constructor occurs here Default point constructor
16 } with implicit call to
17 Object constructor
18 // constructor
19 public Point( int xValue, int yValue )
20 {
21 // implicit call to Object constructor occurs here Constructor to set
22 X = xValue;
23 Y = yValue; coordinates to parameters,
24 } also has implicit call to
25 Object constructor
26 // property X
27 public int X
28 {
29 get
30 {
31 return x;
32 }
33
 2002 Prentice Hall.
All rights reserved.
 11
34 set Outline
35 {
36 x = value; // no need for validation
37 }
38 Point.cs
39 } // end property X
40
41 // property Y
42 public int Y
43 {
44 get
45 { Definition of overridden
46 return y;
47 }
method ToString
48
49 set
50 {
51 y = value; // no need for validation
52 }
53
54 } // end property Y
55
56 // return string representation of Point
57 public override string ToString()
58 {
59 return "[" + x + ", " + y + "]";
60 }
61
62 } // end class Point
Program Output

 2002 Prentice Hall.

All rights reserved.
 12
1 // Fig. 9.5: PointTest.cs Outline
2 // Testing class Point.
3
Create a Point object
4 using System; Calls the ToString method
5 using System.Windows.Forms; of class Point implicitly PointTest.cs
6
7 // PointTest class definition
8 class PointTest Change coordinates of Point object
9 {
10 // main entry point for application
11 static void Main( string[] args )
12 {
13 // instantiate Point object
14 Point point = new Point( 72, 115 );
15
16 // display point coordinates via X and Y properties
17 string output = "X coordinate is " + point.X +
18 "\n" + "Y coordinate is " + point.Y;
19
20 point.X = 10; // set x-coordinate via X property
21 point.Y = 10; // set y-coordinate via Y property
22
23 // display new point value
24 output += "\n\nThe new location of point is " + point;
25
26 MessageBox.Show( output, "Demonstrating Class Point" );
27
28 } // end method Main
29
30 } // end class PointTest

 2002 Prentice Hall.

All rights reserved.
 13
1 // Fig. 9.6: Circle.cs Outline
2 // Circle class contains x-y coordinate pair and radius.
3
4 using System;
5 Circle.cs
6 // Circle class definition implicitly inherits from Object
7 public class Circle
8 { Declare coordinates and
9 private int x, y; // coordinates of Circle's center
10 private double radius; // Circle's radius radius of circle as private
11
12 // default constructor
13 public Circle()
14 {
15 // implicit call to Object constructor occurs here
16 }
17
18 // constructor Circle constructors
19 public Circle( int xValue, int yValue, double radiusValue )
20 {
21 // implicit call to Object constructor occurs here
22 x = xValue;
23 y = yValue;
24 Radius = radiusValue;
25 }
26
27 // property X
28 public int X
29 {
30 get
31 {
32 return x;
33 }
34
 2002 Prentice Hall.
All rights reserved.
 14
35 set Outline
36 {
37 x = value; // no need for validation
38 }
39 Circle.cs
40 } // end property X
41
42 // property Y
43 public int Y
44 {
45 get
46 {
47 return y;
48 }
49
50 set
51 {
52 y = value; // no need for validation
53 }
54
55 } // end property Y
56
57 // property Radius
58 public double Radius
59 {
60 get
61 {
62 return radius;
63 }
64
65 set
66 {
67 if ( value >= 0 ) // validation needed
68 radius = value;
69 }
 2002 Prentice Hall.
All rights reserved.
 15
70 Outline
71 } // end property Radius
72
73 // calculate Circle diameter
74 public double Diameter() Circle.cs
75 {
76 return radius * 2;
77 }
78
79 // calculate Circle circumference
80 public double Circumference()
81 {
82 return Math.PI * Diameter();
83 }
84 Definition of overridden
85 // calculate Circle area method ToString
86 public double Area()
87 {
88 return Math.PI * Math.Pow( radius, 2 );
89 }
90
91 // return string representation of Circle
92 public override string ToString()
93 {
94 return "Center = [" + x + ", " + y + "]" +
95 "; Radius = " + radius;
96 }
97
98 } // end class Circle

 2002 Prentice Hall.

All rights reserved.
 16
1 // Fig. 9.7: CircleTest.cs Outline
2 // Testing class Circle.
3 Create a Circle object
4 using System;
5 using System.Windows.Forms; CircleTest.cs
6
7 // CircleTest class definition
8 class CircleTest
9 {
10 // main entry point for application.
11 static void Main( string[] args )
Change coordinates and
12 { radius of Circle object
13 // instantiate Circle
14 Circle circle = new Circle( 37, 43, 2.5 );
15
16 // get Circle's initial x-y coordinates and radius
17 string output = "X coordinate is " + circle.X +
18 "\nY coordinate is " + circle.Y + "\nRadius is " +
19 circle.Radius;
20
21 // set Circle's x-y coordinates and radius to new values
22 circle.X = 2;
23 circle.Y = 2;
24 circle.Radius = 4.25; Implicit call to circle’s
25 ToString method
26 // display Circle's string representation
27 output += "\n\nThe new location and radius of " +
28 "circle are \n" + circle + "\n";
29
30 // display Circle's diameter
31 output += "Diameter is " +
32 String.Format( "{0:F}", circle.Diameter() ) + "\n";
33
 2002 Prentice Hall.
All rights reserved.
 17
34 // display Circle's circumference Outline
35 output += "Circumference is " +
36 String.Format( "{0:F}", circle.Circumference() ) + "\n";
37
38 // display Circle's area CircleTest.cs
Call Circle’s
39 output += "Area is " + Circumference and Area
40 String.Format( "{0:F}", circle.Area() );
41 methods for output
42 MessageBox.Show( output, "Demonstrating Class Circle" );
43
44 } // end method Main
45
46 } // end class CircleTest

 2002 Prentice Hall.

All rights reserved.
 18
1 // Fig. 9.8: Circle2.cs Outline
2 // Circle2 class that inherits from class Point.
3
Declare class Circle to
4 using System; derive from class Point
5 Circle2.cs
6 // Circle2 class definition inherits from Point
7 class Circle2 : Point
8 { Declare radius as private
9 private double radius; // Circle2's radius
10
11 // default constructor
Implicit calls to base class constructor
12 public Circle2()
13 {
14 // implicit call to Point constructor occurs here
15 }
16
17 // constructor
18 public Circle2( int xValue, int yValue, double radiusValue )
19 {
20 // implicit call to Point constructor occurs here
21 x = xValue;
22 y = yValue; Attempt to directly change
23 Radius = radiusValue; private base class methods
24 } results in an error
25
26 // property Radius
27 public double Radius
28 {
29 get
30 {
31 return radius;
32 }
33
 2002 Prentice Hall.
All rights reserved.
 19
34 set Outline
35 {
36 if ( value >= 0 )
37 radius = value;
38 } Circle2.cs
39
40 } // end property Radius
41
42 // calculate Circle diameter
43 public double Diameter()
44 {
45 return radius * 2;
46 }
47
48 // calculate Circle circumference
49 public double Circumference()
50 {
51 return Math.PI * Diameter();
52 }
53
54 // calculate Circle area
55 public virtual double area()
56 {
57 return Math.PI * Math.Pow( radius, 2 );
58 } Attempt to directly access
59 private base class members
60 // return string representation Circle
61 public override string ToString() results in an error
62 {
63 return "Center = [" + x + ", " + y + "]" +
64 "; Radius = " + radius;
65 }
66
67 } // end class Circle2
 2002 Prentice Hall.
All rights reserved.
 20
Outline

Circle2.cs
program output

 2002 Prentice Hall.

All rights reserved.
 21
1 // Fig. 9.9: Point2.cs Outline
2 // Point2 class contains an x-y coordinate pair as protected data.
3
4 using System;
5 Point2.cs
6 // Point2 class definition implicitly inherits from Object
7 public class Point2
8 {
9 // point coordinate Declare coordinates as
10 protected int x, y;
11
protected so derived classes
12 // default constructor can directly access them
13 public Point2()
14 {
15 // implicit call to Object constructor occurs here
16 }
17
18 // constructor
19 public Point2( int xValue, int yValue )
20 {
21 // implicit call to Object constructor occurs here
22 X = xValue;
23 Y = yValue;
24 }
25
26 // property X
27 public int X
28 {
29 get
30 {
31 return x;
32 }
33
 2002 Prentice Hall.
All rights reserved.
 22
34 set Outline
35 {
36 x = value; // no need for validation
37 }
38 Point2.cs
39 } // end property X
40
41 // property Y
42 public int Y
43 {
44 get
45 {
46 return y;
47 }
48
49 set
50 {
51 y = value; // no need for validation
52 }
53
54 } // end property Y
55
56 // return string representation of Point2
57 public override string ToString()
58 {
59 return "[" + x + ", " + y + "]";
60 }
61
62 } // end class Point2

 2002 Prentice Hall.

All rights reserved.
 23
1 // Fig. 9.10: Circle3.cs Outline
2 // Circle2 class that inherits from class Point2.
3
4 using System;
5 Circle3.cs
6 // Circle3 class definition inherits from Point2
7 public class Circle3 : Point2
8 { Class Circle3 inherits
9 private double radius; // Circle's radius from Point2
10
11 // default constructor
12 public Circle3()
13 {
14 // implicit call to Point constructor occurs here
15 }
16
17 // constructor
18 public Circle3(
19 int xValue, int yValue, double radiusValue )
20 {
21 // implicit call to Point constructor occurs here
22 x = xValue;
23 y = yValue; Directly changing protected
24 Radius = radiusValue;
25 } base class members does not
26 result in error
27 // property Radius
28 public double Radius
29 {
30 get
31 {
32 return radius;
33 }
34
 2002 Prentice Hall.
All rights reserved.
 24
35 set Outline
36 {
37 if ( value >= 0 )
38 radius = value;
39 } Circle3.cs
40
41 } // end property Radius
42
43 // calculate Circle diameter
44 public double Diameter()
45 {
46 return radius * 2;
47 }
48
49 // calculate circumference
50 public double Circumference()
51 {
52 return Math.PI * Diameter();
53 }
54
55 // calculate Circle area
56 public virtual double Area()
57 {
58 return Math.PI * Math.Pow( radius, 2 );
59 }
60
61 // return string representation of Circle3
62 public override string ToString()
63 { Directly accessing
64 return "Center = [" + x + ", " + y + "]" +
65 "; Radius = " + radius; protected members
66 } does not result in error
67
68 } // end class Circle3
 2002 Prentice Hall.
All rights reserved.
 25
1 / Fig. 9.11: CircleTest3.cs Outline
2 // Testing class Circle3.
3
4 using System;
5 using System.Windows.Forms; CircleTest3.cs
6
7 // CircleTest3 class definition
8 class CircleTest3
9 {
10 // main entry point for application
11 static void Main( string[] args )
Change coordinates and
12 { radius of Circle3 object
13 // instantiate Circle3
14 Circle3 circle = new Circle3( 37, 43, 2.5 );
15
16 // get Circle3's initial x-y coordinates and radius
Create new Circle3 object
17 string output = "X coordinate is " + circle.X + "\n" +
18 "Y coordinate is " + circle.Y + "\nRadius is " +
19 circle.Radius;
20
21 // set Circle3's x-y coordinates and radius to new values
22 circle.X = 2;
23 circle.Y = 2;
24 circle.Radius = 4.25;
25
26 // display Circle3's string representation
27 output += "\n\n" +
28 "The new location and radius of circle are " + Implicit call to
29 "\n" + circle + "\n"; Circle3’s ToString
30
31 // display Circle3's Diameter method
32 output += "Diameter is " +
33 String.Format( "{0:F}", circle.Diameter() ) + "\n";
34
 2002 Prentice Hall.
All rights reserved.
 26
35 // display Circle3's Circumference Outline
36 output += "Circumference is " +
37 String.Format( "{0:F}", circle.Circumference() ) + "\n";
38
39 // display Circle3's Area CircleTest3.cs
Call Circle’s
40 output += "Area is " + Circumference and Area
41 String.Format( "{0:F}", circle.Area() );
42 methods for output
43 MessageBox.Show( output, "Demonstrating Class Circle3" );
44
45 } // end method Main
46
47 } // end class CircleTest3

 2002 Prentice Hall.

All rights reserved.
 27
1 // Fig. 9.12: Point3.cs Outline
2 // Point3 class represents an x-y coordinate pair.
3
4 using System;
5 Point3.cs
6 // Point3 class definition implicitly inherits from Object
7 public class Point3
8 {
9 // point coordinate
10 private int x, y; Declare coordinates as private
11
12 // default constructor
13 public Point3()
14 {
15 // implicit call to Object constructor occurs here
16 }
17
18 // constructor
19 public Point3( int xValue, int yValue )
20 {
21 // implicit call to Object constructor occurs here
22 X = xValue; // use property X
23 Y = yValue; // use property Y
24 }
25
26 // property X
27 public int X
28 {
29 get
30 {
31 return x;
32 }
33
 2002 Prentice Hall.
All rights reserved.
 28
34 set Outline
35 {
36 x = value; // no need for validation
37 }
38 Point3.cs
39 } // end property X
40
41 // property Y
42 public int Y
43 { Methods to set x
44 get and y coordinates
45 {
46 return y;
47 }
48
49 set
50 {
51 y = value; // no need for validation
52 }
53
54 } // end property Y
55
56 // return string representation of Point3
57 public override string ToString()
58 {
59 return "[" + X + ", " + Y + "]"; Overridden ToString method
60 }
61
62 } // end class Point3

 2002 Prentice Hall.

All rights reserved.
 29
1 // Fig. 9.13: Circle4.cs Outline
2 // Circle4 class that inherits from class Point3.
3
4 using System;
5 Circle4.cs
6 // Circle4 class definition inherits from Point3 Constructor with
7 public class Circle4 : Point3 implicit call to base
8 {
9 private double radius;
class constructor
10
11 // default constructor Constructor with
12 public Circle4() explicit call to base
13 {
14 // implicit call to Point constructor occurs here
class constructor
15 }
16
17 // constructor
18 public Circle4( int xValue, int yValue, double radiusValue )
19 : base( xValue, yValue )
20 {
21 Radius = radiusValue; Explicit call to base
22 }
23 class constructor
24 // property Radius
25 public double Radius
26 {
27 get
28 {
29 return radius;
30 }
31
32 set
33 {
34 if ( value >= 0 ) // validation needed
35 radius = value;
 2002 Prentice Hall.
All rights reserved.
 30
36 } Outline
37
38 } // end property Radius
39
40 // calculate Circle diameter Circle4.cs
41 public double Diameter()
42 {
43 return Radius * 2; // use property Radius
44 }
45
46 // calculate Circle circumference
47 public double Circumference()
48 {
49 return Math.PI * Diameter();
50 }
51
Method area declared virtual
52 // calculate Circle area so it can be overridden
53 public virtual double Area()
54 {
55 return Math.PI * Math.Pow( Radius, 2 ); // use property
56 } Circle4’s ToString method
57 overrides Point3’s ToString
58 // return string representation of Circle4
59 public override string ToString()
method
60 {
61 // use base reference to return Point string representation
62 return "Center= " + base.ToString() + Call Point3’s ToString
63 "; Radius = " + Radius; // use property Radius method to display
64 }
coordinates
65
66 } // end class Circle4

 2002 Prentice Hall.

All rights reserved.
 31
1 // Fig. 9.14: CircleTest4.cs Outline
2 // Testing class Circle4.
3
4 using System;
5 using System.Windows.Forms; CircleTest4.cs
6
7 // CircleTest4 class definition
8 class CircleTest4
9 {
10 // main entry point for application
11 static void Main( string[] args )
Change coordinates and
12 { radius of Circle4 object
13 // instantiate Circle4
14 Circle4 circle = new Circle4( 37, 43, 2.5 );
15
16 // get Circle4's initial x-y coordinates and radius
Create new Circle4 object
17 string output = "X coordinate is " + circle.X + "\n" +
18 "Y coordinate is " + circle.Y + "\n" +
19 "Radius is " + circle.Radius;
20
21 // set Circle4's x-y coordinates and radius to new values
22 circle.X = 2;
23 circle.Y = 2;
24 circle.Radius = 4.25;
25
26 // display Circle4's string representation
27 output += "\n\n" +
28 "The new location and radius of circle are " + Implicit call to
29 "\n" + circle + "\n"; Circle4’s ToString
30
31 // display Circle4's Diameter method
32 output += "Diameter is " +
33 String.Format( "{0:F}", circle.Diameter() ) + "\n";
34
 2002 Prentice Hall.
All rights reserved.
 32
35 // display Circle4's Circumference Outline
36 output += "Circumference is " +
37 String.Format( "{0:F}", circle.Circumference() ) + "\n";
38
39 // display Circle4's Area CircleTest4.cs
Call Circle’s
40 output += "Area is " + Circumference and Area
41 String.Format( "{0:F}", circle.Area() );
42 methods for output
43 MessageBox.Show( output, "Demonstrating Class Circle4" );
44
45 } // end method Main
46
47 } // end class CircleTest4

 2002 Prentice Hall.

All rights reserved.
 33
9.5 Case Study: Three-Level Inheritance
Hierarchy
• Three-level inheritance example:
– Class Cylinder inherits from class Circle4
– Class Circle4 inherits from class Point3

 2002 Prentice Hall. All rights reserved.

 34
1 // Fig. 9.15: Cylinder.cs Outline
2 // Cylinder class inherits from class Circle4.
3
4 using System;
5 Cylinder.cs
6 // Cylinder class definition inherits from Circle4
7 public class Cylinder : Circle4 Class Cylinder inherits
8 { from class Circle4
9 private double height;
10
11 // default constructor Declare variable
12 public Cylinder() height as private
13 {
14 // implicit call to Circle4 constructor occurs here
15 } Constructor that
16 implicitly calls base
17 // four-argument constructor
18 public Cylinder( int xValue, int yValue, double class constructor
radiusValue,
19 double heightValue ) : base( xValue, yValue, radiusValue )
20 {
21 Height = heightValue; // set Cylinder height
22 } Constructor that
23
24 // property Height
explicitly calls base
25 public double Height class constructor
26 {
27 get
28 {
29 return height;
30 }
31
32 set
33 {
34 if ( value >= 0 ) // validate height
35 height = value;
 2002 Prentice Hall.
All rights reserved.
 35
36 } Outline
37
38 } // end property Height
39
40 // override Circle4 method Area to calculate Cylinder area Cylinder.cs
41 public override double Area()
42 { Method Area overrides
43 return 2 * base.Area() + base.Circumference() * Height; Circle4’s Area method
44 }
45
46 // calculate Cylinder volume
47 public double Volume() Calculate volume of cylinder
48 {
49 return base.Area() * Height;
50 }
51
52 // convert Cylinder to string Overridden ToString method
53 public override string ToString()
54 {
55 return base.ToString() + "; Height = " + Height;
56 }
57 Call Circle4’s ToString
58 } // end class Cylinder
method to get its output

 2002 Prentice Hall.

All rights reserved.
 36
1 // Fig. 9.16: CylinderTest.cs Outline
2 // Tests class Cylinder.
3
4 using System;
5 using System.Windows.Forms; CylinderTest.cs
6
7 // CylinderTest class definition
8 class CylinderTest
9 {
10 // main entry point for application
11 static void Main( string[] args )
12 {
13 // instantiate object of class Cylinder
Create new cylinder
14 Cylinder cylinder = new Cylinder(12, 23, 2.5, 5.7);
15
16 // properties get initial x-y coordinate, radius and height
17 string output = "X coordinate is " + cylinder.X + "\n" +
18 "Y coordinate is " + cylinder.Y + "\nRadius is " +
19 cylinder.Radius + "\n" + "Height is " + cylinder.Height;
20
21 // properties set new x-y coordinate, radius and height
22 cylinder.X = 2;
23 cylinder.Y = 2; Change coordinates,
24 cylinder.Radius = 4.25;
25 cylinder.Height = 10; radius and height
26
27 // get new x-y coordinate and radius
28 output += "\n\nThe new location, radius and height of " +
29 "cylinder are\n" + cylinder + "\n\n";
30
31 // display Cylinder's Diameter
Implicit call to ToString
32 output += "Diameter is " +
33 String.Format( "{0:F}", cylinder.Diameter() ) + "\n";
34
 2002 Prentice Hall.
All rights reserved.
 37
35 // display Cylinder's Circumference Outline
36 output += "Circumference is " +
37 String.Format( "{0:F}", cylinder.Circumference() ) + "\n";
38
39 // display Cylinder's Area CylinderTest.cs
40 output += "Area is " +
41 String.Format( "{0:F}", cylinder.Area() ) + "\n"; Call methods
42 Circumference,
43 // display Cylinder's Volume Area and Volume
44 output += "Volume is " +
45 String.Format( "{0:F}", cylinder.Volume() );
46
47 MessageBox.Show( output, "Demonstrating Class Cylinder" );
48
49 } // end method Main
50
51 } // end class CylinderTest

 2002 Prentice Hall.

All rights reserved.
 38
9.6 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
constructor

 2002 Prentice Hall. All rights reserved.

 39
1 // Fig. 9.17: Point4.cs Outline
2 // Point4 class represents an x-y coordinate pair.
3
4 using System;
5 Point4.cs
6 // Point4 class definition
7 public class Point4
8 {
9 // point coordinate
10 private int x, y;
11
12 // default constructor
13 public Point4()
14 {
15 // implicit call to Object constructor occurs here
16 Console.WriteLine( "Point4 constructor: {0}", this );
Constructors with output
17 } messages and implicit calls
18 to base class constructor
19 // constructor
20 public Point4( int xValue, int yValue )
21 {
22 // implicit call to Object constructor occurs here
23 X = xValue;
Output statements use
24 Y = yValue; reference this to implicitly
25 Console.WriteLine( "Point4 constructor: {0}", this ); call ToString method
26 }
27
28 // destructor
29 ~Point4() Destructor with
30 {
31 Console.WriteLine( "Point4 destructor: {0}", this ); output message
32 }
33
34 // property X
35 public int X
 2002 Prentice Hall.
All rights reserved.
 40
36 { Outline
37 get
38 {
39 return x;
40 } Point4.cs
41
42 set
43 {
44 x = value; // no need for validation
45 }
46
47 } // end property X
48
49 // property Y
50 public int Y
51 {
52 get
53 {
54 return y;
55 }
56
57 set
58 {
59 y = value; // no need for validation
60 }
61
62 } // end property Y
63
64 // return string representation of Point4
65 public override string ToString()
66 {
67 return "[" + x + ", " + y + "]";
68 }
69
70 } // end class Point4
 2002 Prentice Hall.
All rights reserved.
 41
1 // Fig. 9.18: Circle5.cs Outline
2 // Circle5 class that inherits from class Point4.
3
4 using System;
5 Circle5.cs
6 // Circle5 class definition inherits from Point4
7 public class Circle5 : Point4
8 {
9 private double radius;
10
11 // default constructor
12 public Circle5()
13 {
14 // implicit call to Point3 constructor occurs here
15 Console.WriteLine( "Circle5 constructor: {0}", this ); Constructors with
16 } calls to base class and
17 output statements
18 // constructor
19 public Circle5( int xValue, int yValue, double radiusValue )
20 : base( xValue, yValue )
21 { Output statements use
22 Radius = radiusValue; reference this to implicitly
23 Console.WriteLine( "Circle5 constructor: {0}", this );
24 }
call ToString method
25
26 // destructor overrides version in class Point4
27 ~Circle5()
28 {
Destructor with
29 Console.WriteLine( "Circle5 destructor: {0}", this ); output message
30 }
31
32 // property Radius
33 public double Radius
34 {
 2002 Prentice Hall.
All rights reserved.
 42
35 get Outline
36 {
37 return radius;
38 }
39 Circle5.cs
40 set
41 {
42 if ( value >= 0 )
43 radius = value;
44 }
45
46 } // end property Radius
47
48 // calculate Circle5 diameter
49 public double Diameter()
50 {
51 return Radius * 2;
52 }
53
54 // calculate Circle5 circumference
55 public double Circumference()
56 {
57 return Math.PI * Diameter();
58 }
59
60 // calculate Circle5 area
61 public virtual double Area()
62 {
63 return Math.PI * Math.Pow( Radius, 2 );
64 }
65
66 // return string representation of Circle5
67 public override string ToString()
68 {
 2002 Prentice Hall.
All rights reserved.
 43
69 // use base reference to return Point3 string Outline
70 return "Center = " + base.ToString() +
71 "; Radius = " + Radius;
72 }
73 Circle5.cs
74 } // end class Circle5

 2002 Prentice Hall.

All rights reserved.
 44
1 // Fig. 9.19: ConstructorAndDestructor.cs Outline
2 // Display order in which base-class and derived-class constructors
3 // and destructors are called.
4
5 using System; ConstructorAndDe
6 structor.cs
7 // ConstructorAndFinalizer class definition
8 class ConstructorAndFinalizer
9 {
10 // main entry point for application.
11 static void Main( string[] args )
12 {
13 Circle5 circle1, circle2;
14
15 // instantiate objects
16 circle1 = new Circle5( 72, 29, 4.5 ); Create two objects
17 circle2 = new Circle5( 5, 5, 10 ); of type Circle5
18
19 Console.WriteLine();
20
21 // mark objects for garbage collection
22 circle1 = null; Remove references
23 circle2 = null;
24
to Circle5 objects
25 // inform garbage collector to execute
26 System.GC.Collect();
27 Run the garbage collector
28 } // end method Main
29
30 } // end class ConstructorAndDestructor

 2002 Prentice Hall.

All rights reserved.
 45
Point4 constructor: Center = [72, 29]; Radius = 0 Outline
Circle5 constructor: Center = [72, 29]; Radius = 4.5
Point4 constructor: Center = [5, 5]; Radius = 0
Circle5 constructor: Center = [5, 5]; Radius = 10
  ConstructorAndDe
Circle5 destructor: Center = [5, 5]; Radius = 10 structor.cs
Point4 destructor: Center = [5, 5]; Radius = 10 program output
Circle5 destructor: Center = [72, 29]; Radius = 4.5
Point4 destructor: Center = [72, 29]; Radius = 4.5

 2002 Prentice Hall.

All rights reserved.
Software Engineering with
Inheritance
 Can customize derived classes to meet needs by:
 Creating new member variables
 Creating new methods
 Override base-class members
 .NET Framework Class Library(FCL) allows full reuse of
software through inheritance

46