Advanced Object-Oriented Programming. 11 Features. C# Programming: From Problem Analysis to Program Design. 4th Edition

Size: px

Start display at page:

Download "Advanced Object-Oriented Programming. 11 Features. C# Programming: From Problem Analysis to Program Design. 4th Edition"

Poppy Griffith
6 years ago
Views:

1 11 Features Advanced Object-Oriented Programming C# Programming: From Problem Analysis to Program Design C# Programming: From Problem Analysis to Program Design 1 4th Edition

2 Chapter Objectives 2

3 Chapter Objectives (continued) 3

4 Chapter Objectives (continued) C# Programming: From Problem Analysis to Program Design 4

5 Object-Oriented Language Features 5

6 Component-Based Development Figure 11-1 Component-based development 6

7 Component-Based Development (continued) 7

8 Component-Based Development (continued) C# Programming: From Problem Analysis to Program Design 8

9 Inheritance 9

10 Inheriting from the Object Class 10

11 Inheriting from Other.NET FCL Classes System.Windows.Forms.Form C# Programming: From Problem Analysis to Program Design 11

12 Inheriting from Other.NET FCL Classes Derived class Figure 11-3 Derived class Base class C# Programming: From Problem Analysis to Program Design 12

13 Creating Base Classes for Inheritance C# Programming: From Problem Analysis to Program Design 13

14 Class Diagram: Person - Student Base class Sub-class (Derived) 14

15 Person Class (Base) 1 of 2 class Person //data members private string lastname = "n.a"; private string firstname= "n.a"; 1 private int age = 0; private string occupation = "n.a"; 2 //Properties // Verbose style - Property for last name public string LastName get return lastname; } set lastname = value; } } // Properties using C# 7.0 style- Expression Bodied Method notation public string FirstName get => firstname; set => firstname = value; } public int Age get return age; } set => age = Math.Abs(value); } public string Occupation get return occupation; } set => occupation = value; } 15

Person Class (Base) 2 of 2 // Constructor with zero arguments public Person() } 3 4 5 } // Constructor with four arguments public Person( string lnamevalue, string fnamevalue, int agevalue) LastName

16 Person Class (Base) 2 of 2 // Constructor with zero arguments public Person() } } // Constructor with four arguments public Person( string lnamevalue, string fnamevalue, int agevalue) LastName = lnamevalue; FirstName = fnamevalue; Age = agevalue; } //user-defined methods (new formatting feature C# 7.0) public override string ToString() return string.format( $"Person [ " + $"First= FirstName} Last= LastName} " + $"Age= age} " + $"Ocuppation= Occupation} ]"); } //a virtual method could be overridden by its derived sub-classes public virtual int GetSleepAmount() return 8; } 16

17 6 Student Class (Derived/Sub class) 1 of 2 class Student : Person 7 //data members private string major = "not declared yet"; private double gpa = 0.0; private int studentid = 0; 8 //properties (bodied expressions) public string Major get => major; set => major = value; } public double Gpa get => gpa; set => gpa = value; } public int StudentId get=> studentid; set=> studentid = value; } //constructors public Student() :base() } 9 public Student(string lnamevalue,string fnamevalue, int agevalue, int idvalue, string majorvalue, double gpavalue) :base(lnamevalue, fnamevalue, agevalue) StudentId = idvalue; Major = majorvalue; Gpa = gpavalue; } 17

18 Student Class (Derived/Sub class) 2 of 2 10 //user-defined methods public override string ToString() return string.format( $"\nstudent [ ID= StudentId} Major= Major} GPA= Gpa}" + $"\n\t" + base.tostring() + $" ]"); } 11 public override int GetSleepAmount() //return base.getsleepamount(); return 6; } } 18

19 Access Modifiers Ancestor private... protected public Subclass Only ancestor's public & protected members are visible 19

20 Creating Base Classes for Inheritance 1 class Person Base class //data members private string lastname = "n.a"; private string firstname= "n.a"; private int age = 0; private string occupation = "n.a"; All derived classes will include these four attributes All data members are customarily defined private. Good practice! These default values could be used by zero-args constructor 20

21 Classic verbose style Properties (Verbose Style) 2 // Property for last name public string LastName } get } set } return lastname; lastname = value; Private data member RHS of an assignment 21

occupation; set => occupation = value; } 2 public string LastName get=> lastname; set=> lastname

22 Properties (Compressed notation) => (~Person() =>... //Properties (using Expression Bodied Method's notation) public string Occupation get => occupation; set => occupation = value; } 2 public string LastName get=> lastname; set=> lastname = value; } public string FirstName get => firstname; set => firstname = value; } public int Age get return age; } set => age = Math.Abs(value); } 22

23 Public Access Modifier LastName lastname Property field/data member 23

24 Creating Base Classes for Inheritance: Constructors 3 // Constructor with zero arguments public Person( ) } // Constructor with four arguments public Person (string lnamevalue,string fnamevalue, } int agevalue) LastName = lnamevalue; FirstName = fnamevalue; Age = agevalue; All the object's data-members will used their already declared default values Notice, constructor is a method, has same name as class (Person), has no return type, and is overloaded Properties 24

25 Overriding Methods public override string ToString( ) // Defined in Person public virtual int GetSleepAmt( ) // Defined in Person virtual, abstract, override override 25

$format( $"\nperson [ ID= IdNumber} Age= age} " + $"First= FirstName} Last= LastName} "$

26 Overriding Methods The Person class example overrides ToString() Base class ToString( ) method 4 //using string interpolation - new C# 6.0 formatting feature public override string ToString() return string.format( $"\nperson [ ID= IdNumber} Age= age} " + $"First= FirstName} Last= LastName} " + $"Ocuppation= Occupation} ]"); } Person Object Object 26

27 Virtual Methods (continued) 5 //a virtual method could be overridden by its derived sub-classes public virtual int GetSleepAmount() return 8; } HeavyCoffeeDrinker 27

28 Virtual Methods (continued) Object 28

29 Creating Derived Classes C# Programming: From Problem Analysis to Program Design 29

30 Derived Classes class Student : Person Reference to base class 6 //data members private string major = "not declared yet"; private double gpa = 0.0; private int studentid = 0; Additional subclass data members //properties (bodied expressions)... //constructors public Student() :base() } Indicates which base class constructor to use C# Programming: From Problem Analysis to Program Design 30

Calling the Base Constructor 9 //all-arguments constructor public Student(string fnamevalue, string lnamevalue, int agevalue, string majvalue, string studentidvalue)

31 Calling the Base Constructor 9 //all-arguments constructor public Student(string fnamevalue, string lnamevalue, int agevalue, string majvalue, string studentidvalue) : base(lnamevalue, fnamevalue, agevalue) // calling base constructor } Major = majvalue; StudentId = studentidvalue; Use base constructor to create a Person object 31

32 Calling the Base Constructor (cont) Student s2 = new Student("Parker", "Peter", 21, , "CHEM", 4.0); Student anotherstudent = new Student(); Person Student new Student() 32

33 Calling Overridden Methods of the Base Class return base.getsleepamt( ) // Calls GetSleepAmt( ) in // parent class C# Programming: From Problem Analysis to Program Design 33

34 Relationship between the Person and Student Classes Figure 11-5 Inheritance class diagram 34

35 35

36 Abstract Classes 36

37 Abstract Classes Person abstract public abstract class Person... 37

38 Abstract Classes Person new Person() new Student() 38

39 Abstract Methods 39

40 Abstract Methods (continued) [access modifier] abstract returntype MethodIdentifier // No } included ([parameter list]) ; 40

activityvalue); //assume List<string> listhobbies has been added to data

41 Abstract Methods (continued) Student SetHobby public override void SetHobby(string activityvalue) } public abstract void SetHobby(string activityvalue); //assume List<string> listhobbies has been added to data members listhobbies.add(activityvalue); Defined in Person Defined in Student 41

42 Sealed Classes Sealed public sealed class Student public class UndergraduateStudent : Student 42

43 Sealed Methods public virtual void RaiseSalary(double incrementvalue)...} public sealed override void RaiseSalary(double incrementvalue)...} 43

44 Partial Classes partial public abstract partial class Person 44

45 GeometricObject Example 1 of 9 45

46 1 GeometricObject Example 2 of 9 public abstract class GeometricObject private string color = "White"; private DateTime datecreated = new DateTime(2017, 12, 31, 23, 59, 59); private bool filled = false; // Properties (classic style) public string Color get return color; } set string temp = value.toupper(); char firstletter = temp[0]; color = firstletter + temp.substring(1).tolower(); } } public DateTime DateCreated get return datecreated; } private set datecreated = value; } } public bool Filled get return filled; } set filled = value; } } 2 //constructors public GeometricObject() Color = "White"; Filled = true; DateCreated = DateTime.Now; } 46

47 GeometricObject Example 3 of public GeometricObject(string colorvalue, bool filledvalue) Color = colorvalue; Filled = filledvalue; DateCreated = DateTime.Now; } //user-defined methods public override string ToString() return string.format($"geometricobject [Color: Color}, " + $"Filled:Filled}, " + $"DateCreated:DateCreated.ToString("yyy-MM-dd")}]"); } //Observe that the following two methods have no body! //Descendants of the GeometricObject class MUST implement them. public abstract double GetArea(); public abstract double GetArea(int numdecimals); public abstract double GetPerimeter(); public virtual int CalculateCost() //this VIRTUAL method may be overridden by descendants //an arbitrary way to assess figure's cost int cost = 0; if (Color == "Gold" Color=="Silver") cost += 300; } if (filled) cost += 200; return cost; } } //GeometricObject 47

48 GeometricObject Example 4 of 9 7 class Circle : GeometricObject //data member(s) private double radius = 0; //properties public double Radius get return radius; } set radius = Math.Abs(value); } } 8 //constructor(s) public Circle() : base() Radius = 0; } public Circle(string colorvalue, bool filledvalue, double radiusvalue) :base(colorvalue, filledvalue) Radius = radiusvalue; } 48

49 GeometricObject Example 5 of //user-defined methods public override string ToString() //showing two possible versions of the ToString() method int option = 1; switch (option) case 1: //OPTION1. mixed message child + ancestor string ancestormsg = base.tostring(); string childmsg1 = string.format($"circle [Radius: Radius} ] "); return childmsg1 + " child of " + ancestormsg; case 2: //OPTION2. only child's msg string childmsg2 = string.format($"circle [Radius:Radius}, " + $"Color:Color}, Filled:Filled}, " + $"Created:DateCreated} ]"); return childmsg2; } return "Circle"; } //The following three methods override the empty definition imposed by ancestor class. //The base class demanded that its ABSTRACT METHODS must be implemented by its children. public override double GetArea() //NOTE: this method could be implemented instead as a read-only property //(see above defintion of property Area) return Math.PI * Math.Pow(Radius, 2); 49 }

50 11 12 GeometricObject Example 6 of 9 public override double GetArea(int numdecimals) //display area using a given number of decimal positions double area = Math.PI * Math.Pow(Radius, 2); string numformat = "0:N" + numdecimals + "}"; string strarea = string.format(numformat, area); return Convert.ToDouble(strArea); } public override double GetPerimeter() return 2 * Math.PI * Radius; } }//Circle 50

51 13 GeometricObject Example 7 of 9 class Rectangle : GeometricObject //data members private double height = 0; private double width = 0; //properties public double Width get return width; } set width = value; } } public double Height get return height; } set height = value; } } 14 //constructors public Rectangle() : base() Height = 0; Width = 0; } 51

52 GeometricObject Example 8 of public Rectangle(double widthvalue, double heightvalue, string colorvalue, bool filledvalue) :base(colorvalue, filledvalue) Width = widthvalue; Height = heightvalue; } //user defined methods public override string ToString() return string.format($"rectangle [Height:Height:N2}, Width:Width:N2}, " + $"Color:Color}, Filled:Filled}, " + $"Created:DateCreated} ]"); } //The following three methods override the empty definition imposed by ancestor class. //The base class demanded that its ABSTRACT METHODS must be implemented by its children. public override double GetArea() return Height * Width; } public override double GetArea(int numdecimals) //display area using a given number of decimal positions double area = Height * Width; string numformat = "0:N" + numdecimals + "}"; string strarea = string.format(numformat, area); return Convert.ToDouble(strArea); } 52

53 17 GeometricObject Example 9 of 9 public override double GetPerimeter() return 2 * (Height + Width); } } //Rectangle 53

54 Interfaces 54

55 Using.NET Interfaces Icomparable CompareTo() this this.compareto(other) other this this this other other other 55

56 Using.NET Interfaces public class Person : IComparable<Person> public virtual int CompareTo(Person other) if (this.age == other.age) return 0; else if (this.age > other.age) return 1; else return -1; }. 56

57 Using.NET Interfaces Person p1 = new Person("Prince", "Diane", 22); Person p2 = new Person(); if (p1.compareto(p2)!=0) Console.WriteLine("Different people!"); } 57

58 Polymorphism ToString( ) 58

59 Generics public class Stack<T> private T[] items; private int stackpointer = 0; public Stack(int size) } items = new T[size]; Generic Stack class 59

60 Generic Classes (continued) public T Pop( ) return items[--stackpointer]; } } public void Push(T anitem) items[stackpointer] = anitem; stackpointer++; } 60

61 Generic Methods 61

62 Generic Methods (continued) public void SwapData <T> (ref T first, ref T second) T temp; temp = first; first = second; second = temp; } //To call the method, specify the type following method name SwapData <string> (ref firstvalue, ref secondvalue); 62

63 Dynamic C# Programming: From Problem Analysis to Program Design 63

64 Dynamic Data Type 64

45m; dynamic adate = System.DateTime.Today; Console.

65 Dynamic Data Type (continued) dynamic intvalue = 1000; dynamic stringvalue = "C#"; dynamic decimalvalue = 23.45m; dynamic adate = System.DateTime.Today; Console.WriteLine("0} 1} 2} 3}", intvalue, stringvalue, decimalvalue, adate); 1000C# /16/ :00:00 AM Si 65

66 var Data Type var 66

67 var Data Type (continued) var somevalue = 1000; C# Programming: From Problem Analysis to Program Design 67

StudentGov Application Example Figure 11-18 Problem specification for

68 StudentGov Application Example Figure Problem specification for StudentGov example C# Programming: From Problem Analysis to Program Design 68

69 StudentGov Application Example (continued) Table 11-1 Data fields organized by class C# Programming: From Problem Analysis to Program Design 69

StudentGov Example (continued) Figure 11-19 Prototype for

70 StudentGov Example (continued) Figure Prototype for StudentGov example C# Programming: From Problem Analysis to Program Design 70

StudentGov Example (continued) Figure 11-20 Class diagrams for

71 StudentGov Example (continued) Figure Class diagrams for StudentGov example C# Programming: From Problem Analysis to Program Design 71

StudentGov Example (continued) Figure 11-21 References added to

72 StudentGov Example (continued) Figure References added to StudentGov example C# Programming: From Problem Analysis to Program Design 72

StudentGov Example (continued) Figure 11-21 References added to StudentGov

73 StudentGov Example (continued) Figure References added to StudentGov example (continued) C# Programming: From Problem Analysis to Program Design 73

74 StudentGov Example (continued) Table 11-2 PresentationGUI property values C# Programming: From Problem Analysis to Program Design 74

75 StudentGov Example (continued) Table 11-2 PresentationGUI property values (continued) C# Programming: From Problem Analysis to Program Design 75

76 StudentGov Example (continued) Table 11-2 PresentationGUI property values (continued) C# Programming: From Problem Analysis to Program Design 76

77 StudentGov Example (continued) Table 11-2 PresentationGUI property values (continued) C# Programming: From Problem Analysis to Program Design 77

StudentGov Example (continued) Figure 11-22 Setting the StartUp

78 StudentGov Example (continued) Figure Setting the StartUp Project C# Programming: From Problem Analysis to Program Design 78

StudentGov Application Example (continued) Figure 11-23 Part of the

79 StudentGov Application Example (continued) Figure Part of the PresentationGUI assembly C# Programming: From Problem Analysis to Program Design 79

StudentGov Application Example (continued) Figure 11-24 Output from

80 StudentGov Application Example (continued) Figure Output from StudentGov example C# Programming: From Problem Analysis to Program Design 80

81 Coding Standards C# Programming: From Problem Analysis to Program Design 81

82 Resources C# Programming: From Problem Analysis to Program Design 82

83 Chapter Summary 83

84 Chapter Summary (continued) 84

85 Chapter Summary (continued) C# Programming: From Problem Analysis to Program Design 85

86 APPENDIX Making Stand-Alone Components 86

87 APPENDIX Dynamic Link Library (DLL) C# Programming: From Problem Analysis to Program Design 87

88 Using Visual Studio to Create DLL Files Figure 11-6 Creating a DLL component 88

89 Build Instead of Run to Create DLL C# Programming: From Problem Analysis to Program Design 89

90 Build Instead of Run to Create DLL Figure 11-7 Attempting to run a class library file 90

91 Build Instead of Run to Create DLL (continued) using using PersonNamespace; C# Programming: From Problem Analysis to Program Design 91

92 Add Reference to Base Class One of the first things to do is Add a Reference to the Parent DLL 92

93 Add Reference to Base Class (continued) Use Browse button to locate DLL Figure 11-9 Add Reference dialog box 93

94 Add Reference to Base Class (continued) Figure Locating the Person.dll component 94

95 Adding a New Using Statement public class Student : Person 95

96 Adding a New Using Statement (continued) Notice fully qualified name public class Student : PersonNamespace.Person using PersonNamespace; // Use whatever name you // typed for the namespace for Person 96

97 Creating a Client Application to Use the DLL C# Programming: From Problem Analysis to Program Design 97

98 Creating a Client Application to Use the DLL (continued) 98

99 Declaring an Object of the Component Type public class PresentationGUI : System.Windows.Forms.Form private Student astudent; astudent = new Student(" ", "Maria", "Woo", "CS", "1111"); 99

100 Creating a Client Application to Use the DLL (continued) Figure PresentationGUI output referencing two DLLs 100

101 Using ILDASM to View the Assembly 101

102 Using ILDASM to View the Assembly (continued) C# Programming: From Problem Analysis to Program Design 102

103 ILDASM to View the Assembly Data fields.ctors are constructors IL code for the method Properties converted to methods 103

Lesson11-Inheritance-Abstract-Classes. The GeometricObject case

Lesson11-Inheritance-Abstract-Classes The GeometricObject case GeometricObject class public abstract class GeometricObject private string color = "White"; private DateTime datecreated = new DateTime(2017,