• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
C# Summer course - Lecture 4
 

C# Summer course - Lecture 4

on

  • 840 views

C# summer training for FCIS, 2010. Lecture 4

C# summer training for FCIS, 2010. Lecture 4

Statistics

Views

Total Views
840
Views on SlideShare
840
Embed Views
0

Actions

Likes
0
Downloads
10
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    C# Summer course - Lecture 4 C# Summer course - Lecture 4 Presentation Transcript

    • Introduction to C# Lecture 4 FCISSummer training 2010, 1st year.
    • Contents  Inheritance  Calling base class constructors  The protected keyword  Dynamic binding; virtual and override  Polymorphism and assignment compatibility  All classes inherit from object  The need for down casts  Abstract classes  Examples
    • Inheritance class Employee { int salary; public Employee( ) { salary = 100; } public void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; }  In this code, the class Teacher extends the employee class. This means: – Members of Employee like salary, Raise( ) are also members of teacher (Inheritance). – Objects of type teacher can be assigned to variables of type employee (Polymorphism).
    • Inheritance class Test { static void Main() { Teacher t = new Teacher(); t.Raise( ); // OK Employee e1 = new Employee(); // OK Employee e2 = new Teacher(); // OK } }
    • Calling base constructors  It is important for the derived classs constructor to call the constructor of its parent.  Calling the base constructor is done via the base keyword.  Some useful rules:  If (a) The derived constructor (e.g Teacher) doesnt call a base constructor, and (b) The base has a parameterless constructor, then the base parameterless constructor is called automatically.  Otherwise, the derived constructor must call the base constructor explicitly and give it parameters.
    • Calling base constructors - 2 This code is correct, since Teachers default constructor calls Employees default constructor class Employee { int salary; public Employee( ) { salary = 100; } public void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; }
    • Calling base constructors - 3 This code is also correct, since Teachers Employees default constructor is still called.  class Employee { int salary; public Employee( ) { salary = 100; } public void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; public Teacher() { } }
    • Calling base constructors - 4 But this code is incorrect, since the compiler cannot know what parameters to give to Employees only constructor!  class Employee { int salary; public Employee(int s) { salary = s; } public void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; public Teacher() { } // ??? }
    • Calling base constructors - 4 Now the code is correct, since all of Teachers constructors give the required parameters to the base classs constructors.  class Employee { int salary; public Employee(int s) { salary = s; } public void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; public Teacher() : base(100) { } // OK public Teacher(int _salary): base(_salary) {} // OK }
    • Protected - 1class Employee{ int salary; public Employee( ) { salary = 100; } public void Raise( ) { salary += 50;}}class Teacher : Employee{ string researchTopic; public Teacher( ) { salary = 500; // WRONG! salary is private }}
    • Protected - 2class Employee{ protected int salary; public Employee( ) { salary = 100; } public void Raise( ) { salary += 50;}}class Teacher : Employee{ string researchTopic; public Teacher( ) { salary = 500; // OK! salary is protected }}
    • Overriding  A class like Teacher inherits all data members and methods from its parent class.  But what if some of Teachers behavior is different from employee?  For example, what if Raise( ) should increment the salary by a different amount (say 51 instead of 50?).  In this case the derived class can override the method from its parent class.  But the parent class must allow overriding of this method by making it virtual.
    • Overriding class Employee { int salary; public Employee() { salary = 100; } public virtual void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; public Teacher() { } public override void Raise( ) { salary += 51; } }
    • Dynamic binding class Employee { int salary; public Employee() { salary = 100; } public virtual void Raise( ) { salary += 50;} } class Teacher : Employee { string researchTopic; public Teacher() { } public override void Raise( ) { salary += 51; } } class Test { static void Main( ) { Employee e = new Teacher( ); e.Raise( ); } }  Is e.salary now equal to 150 or 151?
    • Object...  All classes inherit from object. So an instance of any class can be assigned to a variable of type object, stored in an array of objects, passed to functions that take objects....etc  Also, object includes functions like ToString( ), which (a) Can be overriden and (b) Are used by standard .net code like Console.WriteLine and list boxes.  What about value types (which are not classes)? When you assign them to objects they are first copied into an object with a reference. This is called boxing.
    • Downcasts Employee e1, e2; Teacher t1, t2, t3; e1 = new Employee( ); // OK, same type Teacher t1 = new Teacher( ); e1 = t1; // OK, Teacher is a // subtype of Employee Teacher t2 = e2; // WRONG! Teacher t3 = (Teacher) e2; // OK for the compiler  The last line is a downcast. It means "assume e2 is really a reference to a Teacher object"  There will be a runtime check that this is the case, and an exception will be thrown if e2 isnt the correct type. Otherwise the program will go on normally.  Downcasts are sometimes needed, but are usually a sign of bad design; use polymorphism instead.
    • Abstract classesclass Shape { public virtual double GetArea() { ... }} ‫ماذا نضع‬class Square : Shape { ‫هنا؟؟؟‬ double side; public Square(double s) { side = s;} public override double GetArea() { return side*side;}}class Circle : Shape { double radius; public Circle(double r) { radius = r;} public override double GetArea() { return Math.PI * radius*radius;}}
    • Abstract classesabstract class Shape { public abstract double GetArea();}class Square : Shape { double side; public Square(double s) { side = s;} public override double GetArea() { return side*side;}}class Circle : Shape { double radius; public Circle(double r) { radius = r;} public override double GetArea() { return Math.PI * radius*radius;}}
    • Abstract classes Abstract classes represent common concepts between many concrete classes. A class that has one or more abstract functions must also be declared abstract. You cannot create instances of abstract classes (but youre free to create references whose types are abstract classes). If a class inherits from an abstract class, it can become concrete by overriding all the abstract methods with real methods. Now it can be instantiated.
    • Extra: A simple dialog box...To end the session, well show how to create a simple dialog box that reads a name from the user...
    • Creating the dialog box... Value Property ObjectbtnOk btnCancel btnOk AcceptButton Form btnCancel CancelButton Form txtName OK DialogResult btnOk Cancel DialogResult btnCancel
    • Creating the dialog box...In Form2:public string GetName( ){ return txtName.Text;}
    • Using a dialog box...In Form1 void btnGetName_Click(object sender, EventArgs e){ Form2 f = new Form2(); DialogResult r = f.ShowDialog( ); // Show modal if(r == DialogResult.OK) { string name = f.GetName( ); lblResult.Text = f; }}