public class Animal // superclass { public void run() { MessageBox.Show("Animals can run!"); } }

Transcription

1 Lecture #8 What is inheritance? Inheritance and Polymorphism Inheritance is an important object-oriented concept. It allows you to build a hierarchy of related classes, and to reuse functionality defined in existing classes. Inheritance is the IS-A relationship. When on object is a specialized version of another object, there is an IS-A relationship between them. For example, a grasshopper is an insect. Inheritance involves a base class and a derived class. The base class is the general class (insect) and the derived class is the specialized class (grasshopper). So, in C#, inheritance is all about building a derived class that inherits attributes and methods from the base class. C# inheritance One of the fundamental activities of object-oriented programming is establishing relationships between classes. Two fundamental ways to relate classes are inheritance and composition. In object-oriented programming, the relationship happens when two classes interact with each other. Classes can inherit from another class. This is accomplished by putting a colon after the class name when declaring the class, and naming the class to inherit from -- the base class -- after the colon, as follows: public class A public A() public class B : A public B() In the example above, class B is effectively both B and A. When you access a B object, you can use the cast operation to convert it to an A object. The B object is not changed by the cast, but your view of the B object becomes restricted to A s data and behaviors. After casting a B to an A, that A can be cast back to a B. In the following example, the Cat class is related to the Animal class by inheritance, because a cat is a kind of animal. Notice that the Main() method is in the Cat class. By the way, C# does not allow multiple inheritance from classes. public class Animal // superclass public void run() MessageBox.Show("Animals can run!"); public class Cat : Animal // subclass Cat mycat = new Cat(); mycat.run(); Visual C# - Dr. Penn P. Wu 217

2 In biology, the term inheritance refers to attributes acquired via biological heredity from the parents. In a society, inheritance is the practice of passing on property, titles, debts, and obligations upon the death of an individual. However, in object-oriented programming, inheritance refers to creating a new class (called the superclass or base class or parent class) and sharing its class members with other classes (called the subclass or derived class or child class). public class Cat : Animal // subclass Cat c1 = new Cat(); Animal c2 = new Animal(); Animal c3 = new Cat(); Cat c4 = new Animal(); // invalid In the subclass, you can create instance of both superclass and subclass, such as c1 and c2 in the above example. Since, the subclass (Cat) is part of the superclass (Animal), you can say A cat is an animal!, you can create a superclass object and specialize it to the subclass, such as c3. However, An animal is not necessary a cat!, so c4 is an invalid instantiation. The following example has two classes. The parent class is named Base and the child class is called Derived. The child class uses existing code from parent. For example, public class Games // parent private int screenwidth; private int screenheight; private string genre; public Games() // empty default constructor public Games(int swidth, int sheight, string gr) screenwidth = swidth; screenheight = sheight; genre = gr; // method public void display() MessageBox.Show("It is a " + genre + " game."); public class Console : Games // child Games alien = new Games(); Games pacman = new Games(480, 320, "Maze"); pacman.display(); Visual C# - Dr. Penn P. Wu 218

3 Another example, public class Base public String str; public Base() str = "1. Base construct of the Base class.\n"; public void display() str += "4. Function of the Base Class.\n"; public class Derived : Base public Derived() str += "2. Derived Constructor.\n"; show(); public void show() str += "3. Function of the Derived Class.\n"; Derived child = new Derived(); child.display(); MessageBox.Show(child.str); The following Derived declaration tells the compiler to use Base as the base class of Derived. The base class is specified by adding a colon, ":", after the derived class identifier and then specifying the base class name. public class Derived : Base The following code segment declare an object called child, which represents the Derived() construct. Because it is part of the Main() function, the Derived() will be executed automatically to produce an output -- Derived Constructor -- on screen. Derived child = new Derived(); The following line simply tells the compiler to associate the display() method to the child object. Derived does not have its own display() method, so it uses the Base display() method. You can see the results in the 3rd line of output. child.display(); Visual C# - Dr. Penn P. Wu 219

4 The output looks: Notice that derived classes have exactly the same capabilities as Base. Because of this, you can also say Derived is a Base. This is shown in the Main() method of Derived when the display() method is called. C# supports single class inheritance only. Therefore, you can specify only one base class to inherit from. Also, Base classes are automatically instantiated before derived classes. Look at the output from about code; it also indicates the sequence of execution. Basically the Base constructor executed before the Derived constructor. Shape Square Rectangle Rhombus Figure 1. In Figure 1, the Shape class is a superclass and can be specialized to three subclasses: Square, Rectangle, and Rhombus. Consider the following Shape class which contains three instance variables w, h, and cortex as well as one method area(). All of these three class members apply to squares and rectangles. public class Shape public int cortex = 4; public double w, h; public Shape(double x, double y) w = x; h = y; area(); public void area() MessageBox.Show("The area is " + w*h + " and the number of cortex is " + cortex); Shape myshape = new Shape(2,3); Visual C# - Dr. Penn P. Wu 220

5 Since inheritance is the capability of a class to use the properties and methods of another class while adding its own functionality, it will be convenient and efficient to allow both Square and Rectangle class to share these three members. C# uses the : operator to set the relationship between a superclass (parent class) and a subclass (child class). For example, public class Rectangle : Shape public Rectangle(double x, double y) w = x; h = y; area(); public static void main() Rectangle myrectangle1 = new Rectangle(3.1,4.6); In C# the subclass inherits the superclass, so the subclass inherits the superclass. The inheritance relationship means that the subclass inherits the members of the superclass. In the above examples, the Rectangle classes inherits w, h, and area() from the Shape class. Subclass can also have its own constructor. In the following example, the Square class has a constructor named Square() with one parameter x in it. public class Shape public int cortex = 4; public double w, h; public void area() MessageBox.Show("The area is " + w*h); class Square : Shape // inheritance public Square(double x) // constructor of subclass w = h = x; area(); Square mysquare1 = new Square(2.5); The subclass can override the methods it inherits from the superclass. A subclass can override any member of the superclass including instance variables and methods. However, instance variables usually do not have to be overridden because they do not define any special behavior. In the following example, the area() method of the Shape class is overridden by the area() method of the Rectangle class. Both w and h variables of the Shape class are overridden as well. The overriding is done with the new keyword. Visual C# - Dr. Penn P. Wu 221

6 public class Shape public int cortex = 4; public double w, h; public void area() MessageBox.Show("The area is " + w*h + "\n"); public class Rectangle : Shape new int w; // overriding w new int h; // overriding h public Rectangle(int x, int y) w = x; h = y; area(); public new void area() // overriding area() MessageBox.Show(w*h + " is the area.\n"); Rectangle myrectangle1 = new Rectangle(3,4); The output looks: There is another way to inherit from one class without using the : operator. In the following code, the Car class is an individual class that is a reference class. In the Hybrid class, the mycar object is instantiated as Car class. The Hybrid() constructor creates the mycar object, calls the checkthecar() function of the Car class. public class Car public String checkthecar() return "The original car!\n"; Visual C# - Dr. Penn P. Wu 222

7 public class Hybrid Car hybrid1; // declare hybrid1 as instance of Car class public String msg; public Hybrid() hybrid1 = new Car(); // create an instance msg = hybrid1.checkthecar(); msg += newengine(); public String newengine() return "The car is more powerful now with hybrid engine!"; public class mycar Hybrid car1 = new Hybrid(); MessageBox.Show(car1.msg); The output looks: The base method A subclass can inherit accessible members from its superclass. However, the constructor of the superclass is not inherited automatically. A constructor is used to construct an instance of a class. Unlike properties and methods, constructors are not inherited; they cannot be invoked from the subclass. The constructor in a superclass can only be called by its subclasses through the use of base method. The syntax is: SubclassMethod() : base() or For example, SubclassMethod() : base(parameters) public class Person public Person(char gender) // superclass constructor String msg; switch (gender) Visual C# - Dr. Penn P. Wu 223

8 case 'F' : msg = "woman"; break; case 'M' : msg = "man"; break; default : msg = "No such gender"; break; MessageBox.Show(msg); public class MyStudent : Person public MyStudent(char gender) : base(gender) MyStudent obj1 = new MyStudent('F'); The output looks: The super statement must be placed at the first line in order to call the superclass constructor. A subclass constructor may have multiple forms (polymorphism) and can overload its superclass constructor through the use of base method. A later section will discuss polymorphism in details. For example, public class Person public String str; public Person() // superclass constructor form 1 str += "human\n"; public Person(char gender) // superclass constructor form 2 switch (gender) case 'F' : str += "woman\n"; break; case 'M' : str += "man\n"; break; default : str += "No such gender\n"; break; public Person(int age) // superclass constructor form 3 if (age >= 21) str += "adult\n"; else str += "Not adult\n"; Visual C# - Dr. Penn P. Wu 224

9 public class MyStudent : Person public MyStudent() : base() public MyStudent(char gender) : base(gender) public MyStudent(int age): base(age) public MyStudent(double height) // overloading str += height + " feet\n"; MyStudent obj1 = new MyStudent(); MyStudent obj2 = new MyStudent('F'); MyStudent obj3 = new MyStudent(21); MyStudent obj4 = new MyStudent(5.6); MessageBox.Show(obj1.str + obj2.str + obj3.str + obj4.str); The output looks: Polymorphism Polymorphism is a biology term that literally means multiple forms. It describes the phenomena that two or more different phenotypes often exist in the same population of a species. In terms of object-oriented programming, polymorphism is the ability for the same code to be used with several different types of objects and for the code to behave differently depending on the actual type of object used. In C#, polymorphism can be implemented by two different ways: overloading and overriding. In a given class, when multiple methods have the same name but different in behaviors (forms), these methods are overloaded methods. For example, in the myadd class there are two methods. However both methods have exactly the same name add. One accepts only integer type; the other accepts only double type. The overloading happens inside the myadd class. public class myadd // original form int add(int x, int y) return (x + y); double add(double x, double y) //form2 Visual C# - Dr. Penn P. Wu 225

10 return (x + y); public static void Main(String[] args) myadd obj = new myadd(); String str = obj.add(3, 5) + "\n"; str += obj.add(9.2, 4.5); MessageBox.Show(str); The output looks: More than two forms of methods can coexist in a given class. In the following example, the mytype class contains five definitions of a showit() method. public class mytype public String str; public mytype() str = ""; public void showit(int x) // form 1 str += "int type: " + x + "\n"; public int showit(int x, int y) // form 2 return (x * y); public void showit(double x, double y) // form 3 str += "Tow double types: " + (x / y) + "\n"; public void showit(char x) // form 4 str += "char type: " + x + "\n"; public void showit(string x) // form 5 str += "String type: " + x + "\n"; Visual C# - Dr. Penn P. Wu 226

11 After instantiating an object of the mylab class, the C# runtime will use the so-called latebinding technique to decide which of the many forms of a given method should be used. For example, public class mylab public static void main() mytype mt = new mytype(); mt.showit(5); mt.showit(3.72); mt.showit('a'); mt.showit("hello!"); Notice that overloading can happen in exactly the same class. It can also happen between a subclass and its superclass. For example, let the mychildtype class inherits from the mytype class, but override the showit() method in the mychildtype class. public class mychildtype : mytype // subclass public void showit(double x) // form 6 str += "double type: " + x*x + "\n"; The following code can demonstrate how the overriding works between a subclass and its superclass. class mylab public static void main(string[] args) mychildtype mct = new mychildtype(); mct.showit(7); // no overriding mct.showit(7.1); // overriding The following is a class named Coffee with a brew() method in it. The brew() method takes one String type of parameter. public class Coffee public String str; public Coffee() str = ""; public void brew(string flavor) // original form str += "The taste is " + flavor + ".\n"; You can instantiate an object (e.g. cup1 ) of the Coffee class and use it to call the brew() method with a string literal (e.g. Maxell Roast ) in it. class mypolymorphism Visual C# - Dr. Penn P. Wu 227

12 Coffee cup1 = new Coffee(); cup1.brew("maxwell Roast"); // using original form MessageBox.Show(cup1.str); The output looks: Let the following FrenchVanilla class be a subclass to Coffee so it can inherit members from the Coffee class. However, this FrenchVanilla class redefines the brew() method to override its original form (the one defined in Coffee). Notice that the second form of brew() does not require the parameter. public class FrenchVanilla : Coffee public void brew() // second form str += "The taste is French Vanilla.\n"; The instantiation of a FrenschVanilla object (e.g. cup2 ) can use the forms of brew() method as illustrated in the following example. Notice that the original form is inherited from Coffee). class mypolymorphism public static void main() FrenchVanilla cup2 = new FrenchVanilla(); cup2.brew(); // using 2nd form cup2.brew("nest"); // using original form MessageBox.Show(cup2.str); Objects of the FrenschVanilla class can react differently to the same method. The ability that allows a subclass to redefine a method it inherits from a superclass is called overriding in C#. By the same token, you can create another subclass named Latte with another form of brew() method in it, as shown below. This form of brew requires a char type of parameter. Inside the brew() method, it uses an if..else..if statement to evaluate the expression and respond accordingly. This form is the most complicated among these forms. public class Latte : Coffee public void brew(char option) // third form str += "The taste is "; Visual C# - Dr. Penn P. Wu 228

13 if (option=='b') str += "Blue mountain.\n"; else if (option=='m') str += "Mocca.\n"; else if (option=='u') str += "Japanese UCC.\n"; else str += "Unknown taste.\n"; The object of Latte can also enjoy two forms of brew(), as illustrated below. class mypolymorphism Latte cup3 = new Latte(); cup3.brew('m'); // using 3rd form cup3.brew("folgers"); // using original form MessageBox.Show(cup3.str); The output looks: It is necessary to understand the difference between method overloading and method overriding. Operation overloading overriding Description Creating multiple methods in a class with the same name but different parameters and types is called method overloading. Creating the method in a derived class with the same name, the same parameters and the same return type as in a base class is called method overriding. The following illustrates how overloading works. In the Car class, there are three forms of Method1(), each takes a parameter of different type. Every form of the Method1() also return a data of different type. public class Car private int Method1(int x) return x * x; private double Method1(double x) //overloading return x * x; Visual C# - Dr. Penn P. Wu 229

14 private String Method1(String x) //overloading return x + x; static void Main(string[] args) String str = ""; Car obj = new Car(); str += obj.method1(4) + "\n"; str += obj.method1(4.3) + "\n"; str += obj.method1("four"); MessageBox.Show(str); The following illustrates how overriding works across three classes: Car is the base class (superclass), SUV is the derived class that inherits Car. Pathfinder is a derived class that inherits SUV. Method overriding happens when SUV inherits Car, and, when Pathfinder inherits car through SUV. public class Car public int Method1(int x) return x * x; public class SUV : Car public double Method1(double x) //overriding return x * x; public class Pathfinder: SUV public String Method1(String x) //overriding return x + x; public class Program static void Main(string[] args) String str = ""; Pathfinder obj = new Pathfinder(); str += obj.method1(4) + "\n"; str += obj.method1(4.3) + "\n"; str += obj.method1("four"); MessageBox.Show(str); Visual C# - Dr. Penn P. Wu 230

15 Review Questions 1. According to the following code segment, which is an invalid instantiation? public class Cat : Animal A. Cat c1 = new Cat(); B. Animal c1 = new Animal(); C. Animal c1 = new Cat(); D. Cat c1 = new Animal(); 2. Given the following code segment, which is the base class? A. A B. B C. A and B D. not specified public class B : A Which declare an object called child to represent the Derived construct? A. Derived() child; B. Derived child : base; C. Derived child = new Derived(); D. child = new Derived(); 4. Which associates the show() method to an object called apple? A. apple.show(); B. apple::show(); C. apple += show(); D. apple -> show(); 5. Which statement is correct? A. A derived class inherits everything from the base class except constructors and destructors. B. The public members of the Base class become the public members of the Derived class also. C. Even the private members of the base class are inherited to the derived class, even though derived class can't access them. D. All of the above 6. Which is the correct way for a subclass (named "Apple") to inherit the default constructor from a superclass (named "Fruit") in C#? A. public Apple() : base() B. public Apple() : Fruit() C. public Apple() base(); D. public Fruit.Apple() 7. Given the following code, which statement is correct? public class B : A public B() A. B is the base class. A is the derived class. B. A is the base class. B is the derived class. C. B is the base class. A is the superclass. D. A is the derived class. B is the subclass. Visual C# - Dr. Penn P. Wu 231

16 8. Given the following code, which can override w by changing its type to "int" in a subclass in C#? A. int w; B. int new w; C. new int w; D. (int) w; public class Shape public double w, h; 9. Given the following code, which can override the default constructor "myadd()"? public class myadd public myadd() A. public myadd(string str) B. public myadd(int i) C. public myadd(double x, double y) D. All of the above. 10. Which is the wrong way to override the add() method of the following code? public class myadd void add(string s) A. int add(int x) return x; B. double add(double x) return x; C. char add(char c) return c; D. void add(string s) return s; Visual C# - Dr. Penn P. Wu 232

17 Lab #8 Inheritance and Polymorphism Learning Activity #1: 1. Create a new directory called C:\CIS218 if it does not exist. 2. Launch the Developer Command Prompt. 3. In the prompt, type cd c:\cis218 and press [Enter] to change to the C:\CIS218 directory. 4. In the prompt, type notepad lab8_1.cs and press [Enter] to use Notepad to create a new source file called lab8_1.cs with the following contents: public class Shape public int cortex = 4; public double w, h; public void area() String str = "The area is " + w*h; MessageBox.Show(str); public class Square : Shape // inheritance public Square(double x) // default constructor w = h = x; area(); Square obj1 = new Square(2.5); // create an instance of Square 5. Compile and test the program. A sample output looks: 6. Download the assignment template, and rename it to lab8.doc if necessary. Capture a screen shot similar to the above and paste it to the Word document named lab8.doc (or.docx). Learning Activity #2: demonstration of inheritance 1. Under the C:\cis218 directory, use Notepad to create a new source file called lab8_2.cs with the following contents: Visual C# - Dr. Penn P. Wu 233

18 public class Parent public String parentstring; public Parent() parentstring = "5. Message of the Parent Constructor.\n"; public Parent(string mystring) parentstring += mystring; public void display() parentstring += "3. The display() method of the Parent Class.\n"; public class Child : Parent public Child() : base("1. Inherited from the Parent class\n") parentstring += "2. Message of the Child Constructor.\n"; public new void display() base.display(); parentstring += "4. The display() method of the Child Class.\n"; Child child = new Child(); child.display(); ((Parent)child).display(); MessageBox.Show(child.parentString); 2. Compile and test the program. A sample output looks: 3. Capture a screen shot similar to the above and paste it to the Word document named lab8.doc (or.docx). Learning Activity #3: demonstration of inheritance Visual C# - Dr. Penn P. Wu 234

19 1. Under the C:\cis218 directory, use Notepad to create a new source file called lab8_3.cs with the following contents: class Shape public class Square public double x; public Square(double x) // Constructor this.x = x; public virtual double Area() return x*x; class Cube : Square public Cube(double x): base(x) // Constructor this.x = x; public override double Area() // Calling the Area base method: return (x * (base.area())); double x = 3.47; Square s = new Square(x); Square c = new Cube(x); String str = "Area of Square = " + s.area() + "\n"; str += "Volume of Cube = " + c.area() + "\n"; MessageBox.Show(str); 2. Compile and test the program. A sample output looks: 3. Capture a screen shot similar to the above and paste it to the Word document named lab8.doc (or.docx). Visual C# - Dr. Penn P. Wu 235

20 Learning Activity #4: base() method 1. Under the C:\cis218 directory, use Notepad to create a new source file called lab8_4.cs with the following contents: public class Person public String str; public Person() // superclass constructor form 1 str += "human\n"; public Person(char gender) // superclass constructor form 2 switch (gender) case 'F' : str += "woman\n"; break; case 'M' : str += "man\n"; break; default : str += "No such gender\n"; break; public Person(int age) // superclass constructor form 3 if (age >= 21) str += "adult\n"; else str += "Not adult\n"; public class MyStudent : Person public MyStudent() : base() public MyStudent(char gender) : base(gender) public MyStudent(int age): base(age) public MyStudent(double height) // overloading str += height + " feet\n"; MyStudent obj1 = new MyStudent(); MyStudent obj2 = new MyStudent('F'); MyStudent obj3 = new MyStudent(23); MyStudent obj4 = new MyStudent(5.6); MessageBox.Show(obj1.str + obj2.str + obj3.str + obj4.str); 2. Compile and test the program. A sample output looks: Visual C# - Dr. Penn P. Wu 236

21 3. Capture a screen shot similar to the above and paste it to the Word document named lab8.doc (or.docx). Learning Activity #5: Polymorphism 1. Under the C:\cis218 directory, use Notepad to create a new source file called lab8_4.cs with the following contents: public class mytype // superclass public String str; public mytype() str = ""; public void showit(int x) // form 1 str += "int type: " + x + "\n"; public int showit(int x, int y) // form 2 return (x * y); public void showit(double x, double y) // form 3 str += "Tow double types: " + (x / y) + "\n"; public void showit(char x) // form 4 str += "char type: " + x + "\n"; public void showit(string x) // form 5 str += "String type: " + x + "\n"; public class mychildtype : mytype // subclass public void showit(double x) // form 6 str += "double type: " + x*x + "\n"; Visual C# - Dr. Penn P. Wu 237

22 class mypolymorphism // in-class overloading mytype mt = new mytype(); mt.showit(7); mt.showit(4.5, 3.17); mt.showit('m'); mt.showit("hello!"); mt.str += "Two int types: " + mt.showit(5, 7) + "\n"; // subclass overloading mychildtype mct = new mychildtype(); mct.showit(7.1); MessageBox.Show(mt.str + mct.str); 2. Compile and test the program. A sample output looks: 3. Capture a screen shot similar to the above and paste it to the Word document named lab8.doc (or.docx). Programming Exercise: 1. Use Notepad to create a new file named ex08.cs with the following heading lines (be sure to replace YourFullNameHere with the correct one): //File Name: ex08.cs //Programmer: YourFullNameHere 2. Under the above two heading lines, write C# codes to create a superclass (or base class) and a subclass (or derived class) based on the following specifications: Superclass (Parent, Base) Class Name: computer Class Members: o One public string field named model o One public double field named weight o One void method named ShowResult that displays the model and weight in a message box, as shown below. Subclass (Child, Derived) Class Name: laptop Visual C# - Dr. Penn P. Wu 238

23 3. In the laptop subclass, create a Main() method. In the Main() method, create an object named comp1 of the laptop class. Assign the following values of the fields of computer class. Field Name Value Model ASUS101 Weight Download the programming exercise template, and rename it to ex08.doc. Capture a screen shot similar to the above figure and then paste it to the Word document named ex08.doc (or.docx). 5. Compress the source code (ex08.cs), the executable (ex08.exe), and the Word document (ex08.doc or.docx) to a.zip file named ex08.zip. You may be given zero point if any of the required file is missing. Grading Criteria: You must be the sole author of the codes. You must meet all the requirements in order to earn credits. You will receive zero if you simply display the message. No partial credit is given. Submittal 1. Complete all the 5 learning activities and the Programming Exercise in this lab. 2. Create a.zip file named lab8.zip containing ONLY the following self-executable files. Lab8_1.exe Lab8_2.exe Lab8_3.exe Lab8_4.exe Lab8_5.exe Lab8.doc (or.docx) [You may be given zero point if this Word document is missing] 3. Log in to Blackboard and enter the course site. 4. Upload the zipped file as response to question Upload the ex08.zip file to Question 12 as response. Visual C# - Dr. Penn P. Wu 239