Object Oriented Programming

Transcription

1

2 Object Oriented Programming Objects self-contained working units encapsulate data and operations exist independantly of each other (functionally, they may depend) cooperate and communicate to perform a common task Classes are Object Types (abstract data types) are instantiated as Objects Inherit from other Classes form Type Hierarchies may redefine inherited behavior Polymorphically (c)schmiedecke 13 C#-2 - Classes and Objects 2

3 Classes are types are "blueprints" for objects (heap objects, indefinite scope) can form type hierarchies by inheritance Namespaces are "containers" for types (classes -- and interfaces, enumerations, structs, delegates) may be nested determine their members' fully qualified name public classes (etc.) can be used, if they are referenced i.e. their path is known to the project using is a shorthand to omit the namespace path of a classname it is not an act of import! (c)schmiedecke 13 C#-2 - Classes and Objects 3

4 The following class definitions are equivalent: using System.IO; namespace fileutils { public class FileInformation { public void PrintFileInformation(string filename) { if (File.Exists(filename)) { string fileinfo = RetrieveFileInfo(filename); //... namespace fileutils { public class FileInformation { public void PrintFileInformation(string filename) { if (System.IO.File.Exists(filename)) { string fileinfo = RetrieveFileInfo(filename); //... (c)schmiedecke 13 C#-2 - Classes and Objects 4

5 C# Constructors (Destructors) Fields Properties Indexer Events Methods Overloaded Operators Inner Types JAVA Constructors Fields Methods Inner Types (c)schmiedecke 13 C#-2 - Classes and Objects 5

6 no headers needed compiler extracts info about public members declaration order is irrelevant compiler builds name table destructors not necessary (and not recommendable) "dead" (i.e. unreferenced) objects are automatically collected by the garbage collector much easier and much safer! (c)schmiedecke 13 C#-2 - Classes and Objects 6

7 variables, instance and static should be private, for internal use only naming convention: camelcase (start with small letter) extra modifiers for constants: const (compiletime value) static const (global constant) readonly (immutable after initialization) (usually) public class Person { private char internalstatus; // cryptic on purpose private static int currentwaitingtime; public const int ID; (c)schmiedecke 13 C#-2 - Classes and Objects 7

8 restricted dynamic typing standard in functional programming best known from scripting languages, like python, ruby, in C# mainly used in Lambda Expressions type of variable open until first assignation var MyVariant; // type yet unknown MyVariant = new DateTime(); // typed fixed to DateTime (c)schmiedecke 13 C#-2 - Classes and Objects 8

9 Programming best practice in all oo programs! private fields with get and set accessors shorthand declaration in C# readonly by omitting the setter class Person { private char internalstatus; // cryptic on purpose private static int currentwaitingtime; private int id; public int Id { get { return id; set { id = value; //automatic property: public int Id { get ; set //with resticted access public int Id { get ; private set (c)schmiedecke 13 C#-2 - Classes and Objects 9

10 void methods and functions like in Java naming convention PascalCase methods can take parameters and throw and handle exceptions (without declaring them) an instance method reads or modifies "its" instance fields a static method gets ist data from parameters. public class BankAccount { private decimal Balance; private decimal DebtLimit; private decimal Transit; public void Add(decimal amount) { public void Transfer(decimal amount, BankAccount acc) { if (Balance + DebtLimit < amount) throw new BankingException(); Transit=amount; acc.add(amount); Transit=0; (c)schmiedecke 13 C#-2 - Classes and Objects 10

11 Each object has an identity a state, with characteristic features (constants) and changing features (properties) state initialization at object construction using a constructor (or direct initialization) implicit default constructor initializes to 0, false and null public class NewTime { public NewTime(int h, int, m, int s) // constr. w/ 3 params { SetTime(h, m, s); public NewTime(int h) : this(h, 0, 0){ // using constructor // initializer : this //... (c)schmiedecke 13 C#-2 - Classes and Objects 11

12 public class Time1 { private int hour; // 0-23 private int minute; // 0-59 private int second; // 0-59 public void SetTime( int h, int m, int s ) { hour = ( ( h >= 0 && h < 24 )? h : 0 ); // validate hour minute = ( ( m >= 0 && m < 60 )? m : 0 ); // validate minute second = ( ( s >= 0 && s < 60 )? s : 0 ); // validate second // convert to string in universal-time format (HH:MM:SS) public string ToUniversalString() { return string.format( "{0:D2:{1:D2:{2:D2", hour, minute, second ); // convert to string in standard-time format (H:MM:SS AM or PM) public override string ToString() { return string.format( "{0:{1:D2:{2:D2 {3", ( ( hour == 0 hour == 12 )? 12 : hour % 12 ), minute, second, ( hour < 12? "AM" : "PM" ) ); // end class Time1 // example taken from Deitel&Deitel, C# (c)schmiedecke 13 C#-2 - Classes and Objects 12

13 each time object holds a 3-member time value can be set and read as string in two formats members cannot be read or set individually for outside change of internal representation without effect to "clients" (e.g to standard unix time, millisecs since 1974) setting an inconsistent state is prevented SetTime is robust (c)schmiedecke 13 C#-2 - Classes and Objects 13

14 Write another class with a Main method inside Main, set different time values and print the output (c)schmiedecke 13 C#-2 - Classes and Objects 14

15 Use Properties insead for robustness every setter checks for validity SetTime can simply use setters use of getters and setters is implicit: Hour = h; // setter is called return string.format( "{0:D2:{1:D2:{2:D2", Hour, Minute, Second ); // getter is called (c)schmiedecke 13 C#-2 - Classes and Objects 15

16 public class Time { public int Hour { // 0-23 private get ; set { hour = ( ( h >= 0 && h < 24 )? h : 0 ); // validate hour public int Minute { // 0 59 private get ; set { minute = ( ( m >= 0 && m < 60 )? m : 0 ); // validate minute public int Second { // 0-59 private get ; set { second = ( ( s >= 0 && s < 60 )? s : 0 ); // validate second public void SetTime( int h, int m, int s ) { Hour = h; Minute = m; Second = s; // convert to string in universal time format (HH:MM:SS) public string ToUniversalString() { return string.format( "{0:D2:{1:D2:{2:D2", Hour, Minute, Second ); //... (c)schmiedecke 13 C#-2 - Classes and Objects 16

17 Overloading: "Defining another method using the same name, but different parameters, either in number or type." C# allows for constructor overloading method overloading operator overloading implicit default constructor initializes to 0, false and null overloading constructors remove implicit constructor when overloading, make sure to add a default constructor! (c)schmiedecke 13 C#-2 - Classes and Objects 17

18 Constuctor definition like a method with name of class. Constructor overloading: Define more than one constructor. Constructor initializer: reuse another constructor (rather than redundantly redifining it) using :this - body starts with calling other constructor. public class NewTime { public NewTime(int h, int, m, int s) // constr. w/ 3 params { SetTime(h, m, s); public NewTime(int h) : this(h, 0, 0){ // using constructor // initializer : this //... (c)schmiedecke 13 C#-2 - Classes and Objects 18

19 Finish defining class Time2 with all necessary constructors. Use constructor initialization wherever possible. Test it. (c)schmiedecke 13 C#-2 - Classes and Objects 19

20 Time has no overloaded constructors but public properties that should be initialized Object initilizers "invent" a constructor by calling it using the names of the properties as parameter names no need to mention all, others initialized to 0 / false / null Time MyTime = new Time(Hour=11, Minute=15, Second=0); Time YourTime = new Time(Hour=14); // all others 0 (c)schmiedecke 13 C#-2 - Classes and Objects 20

21 change your Main method so that it uses overloaded constructors object initializers (c)schmiedecke 13 C#-2 - Classes and Objects 21

22 Write a class Date which does the following: stores day, month, year (not day of the week) as properties makes sure that only valid dates can be stored provides a method public override string tostring() which returns the TURKISH way of writing a date (e.g. 26/02/2013) Test it! Hint: A year is a leap year (29 days in february) if it can be divided by 400 OR it can be divided by 4, but not by 100. Hint: If you need an array, this is how you define it: MyType[] MyArray = new MyType[200]; (c)schmiedecke 13 C#-2 - Classes and Objects 22

23 Time and Date look useful Let's make them reusable by putting them into a library: Put them into a new namespace (e.g. TimeUtilites) Create a new project of type Class Library Copy both classes into the project and build it. In your file system (or under "all files") you will find a.dll file Create a new solution right-click on it it in the sol'n explorer Choose "Add Reference" and find your.dll file Now copy one of the test progams here Add the appropriate using directive and run it. using System, using TimeUtilities; (c)schmiedecke 13 C#-2 - Classes and Objects 23

24 Our Time class does not allow us to add hours (like "postpone for 3 hours" It's a published library class, you should not change it Glue an additional method onto it public static Time AddHours( this Time tm, int hours) { Time newtime = new Time(tm.Hour, tm.minute, tm.second); newtimehour = (tm.hour + hours) % 24; return NewTime; Time mytime = new Time (22, 12, 08); mytime = mytime.addhours(3); Console.WriteLine(mytime); // 01:12:08 (c)schmiedecke 13 C#-2 - Classes and Objects 24

25 Must be static Must be members of a static class Can only access public properties and methods of the extended class. public static class TimeExtensions { public static Time AddHours( this Time tm, int hours) { Time newtime = new Time(tm.Hour, tm.minute, tm.second); newtimehour = (tm.hour + hours) % 24; return NewTime; (c)schmiedecke 13 C#-2 - Classes and Objects 25

26 Warning! A n instance method with the same signature HIDES the extension So, if later on, a similar method is added to the class or to one of ist superclasses, your extension method will no longer be called! (c)schmiedecke 13 C#-2 - Classes and Objects 26

27 none, internal accessible within assembly (=project) OR public accessible from anywhere static contains only static members abstract only for subclassing, no instantiation OR sealed subclassing prohibited OR none find contradicting combinations! (c)schmiedecke 13 C#-2 - Classes and Objects 27

28 public accessible anywhere none, internal accessible within assembly (=project) protected accessible in subclasses private accessible within class (even other instances) static member belongs to class, not instance abstract not for fields virtual method: open for polymorphic overriding override method: polymorphic overriding const field: compiletime constant readonly field: immutable after initialization (c)schmiedecke 13 C#-2 - Classes and Objects 28

29 static fields are not specific to instances the type manages them for all instances (family property) Class Windsor Chief: Queen E II Res: Buckingham P Home: Windsor C. static methods cannot access the instance use static fields, call static methods receive data via parameters create instance to call instance methods Charles William Elizabeth II static classes Kate contain only static members (c)schmiedecke 13 C#-2 - Classes and Objects 29

30 Utilities Global Constants General Computations and Conversions int age = Math.Min(myAge, yourage); string datestring = Convert.ToString(DateTime.Now); File.WriteAllText((@".\logfile.txt", logoutput, Encoding.UTF8); (c)schmiedecke 13 C#-2 - Classes and Objects 30

31 could Compute day of the week for a given Date Convert Date to other calendar Validate a Date Compute next leap year for a given Date Provide national output formats for Date All makes sense without storing a Date, i.e. without an instance state. (But it would also make sense as instance methods) static class DateUtilities { public static string DayOfTheWeek(Date date) {... public static bool IsValidDate (int day, int month, int year) { (c)schmiedecke 13 C#-2 - Classes and Objects 31

32 (c)schmiedecke 13 C#-2 - Classes and Objects 32