Chapter 3: Inheritance and Polymorphism

Transcription

1 Chapter 3: Inheritance and Polymorphism Overview Inheritance is when a child class, or a subclass, inherits, or gets, all the data (properties) and methods from the parent class, or superclass. Just like in human biology, where a child will inherit features and actions (or properties and methods) from the parent, such as eye color and the ability to roll one s tongue in a U-shape, inheritance in Java works the same way. The child class, which is known as a subclass in Java terminology, will get the methods and the properties (instance variables) from its parent class, which is known as the superclass in Java terminology. The purpose of inheritance in Java is to reduce development and maintenance time, as well as conserve resources. It conserves resources by preventing programmers from writing repetitive code. It reduces maintenance time by modularizing the methods. In other words, the programmer would have to change only one program rather than fifty programs if business rules require a coding change. It reduces development and maintenance time by allowing programmers to create a subclass to implement new functionality, rather than change the superclass and possibly cause disruption with other programs that use the superclass. The concept of inheritance in Java is similar to the concept of inheritance in human biology. The child will inherit features and actions from the parent, but the child can also inherit features and actions from the grandparent, the great-grandparent, and so forth. In Java, if the parent (superclass) is a subclass (child) of another class, the subclass (child) of the parent will also inherit from the parent of the parent. For example, if Class C inherits from Class B, and Class B inherits from Class A, Class C will also inherit from Class A. Polymorphism is the ability to have many different forms. Just like in human biology, a child will speak the same language as the parent, but the child may not sound like the parent. The child may have a higher or lower pitched voice, or the child s inflections may be different from the parent. In Java, the subclass (child) may have the same methods has its superclass (parent), but the subclass can rewrite, or override, the functionality of a method or a few methods. The process of rewriting a superclass s method is called method overriding. Polymorphism is flexible if you want to add more functionality to a particular method for a subclass. For example, you may want to perform the same functionality as the superclass, but you want to add more functionality to the method in the subclass. For the C++ Programmers: Single Inheritance versus Multiple Inheritance Unlike C++, Java follows the principle of single inheritance. Single inheritance means that a class can directly inherit from only one class. In other words, a subclass, or child, can only have one superclass, or parent. Multiple inheritance means that a class can directly inherit from many classes. In other words, a subclass, or child, can have many superclasses, or parents. Object: The Ultimate Superclass The Java programming language is class based. Everything written in Java must live within a class. All classes inherit from a class called the Object class. The Object class is the ultimate superclass, or parent. The library is java.lang.object. Even though all classes inherit from the object class, programmers may not explicitly extend the Object class. The relationship is already assumed. The built-in methods of the Object class that can be overwritten are:

2 The built-in methods that are protected are: How to Inherit in Java When creating subclasses in Java, you can inherit from any existing class. You can inherit from a class in Java, or you can inherit from a custom, reusable class. To inherit from a class, you need to add the key phrase extends ClassName, where ClassName is the name of the superclass. For example, when you were creating applets, you were actually creating subclasses of the Applet class. This lesson is going to focus on inheritance from custom, reusable classes. Let s first take a look at a custom class called Circle. import java.awt.*; public class Circle /* the instance variables */ private int x, y, diameter; private boolean filled; private Color c; /* the constructor - the default constructor */ public Circle() x = 10; y = 10; diameter = 50; c = Color.BLACK; filled = false; /* the other constructor */ public Circle(int posx, int posy, int d, Color newcolor, boolean fill) x = posx; y = posy; diameter = d; c = newcolor; filled = fill; /* the methods */

3 public void drawcircle(graphics g) // set the color g.setcolor(c); // draw the circle if (filled == true) g.filloval(x, y, diameter, diameter); else g.drawoval(x, y, diameter, diameter); public void changecolor(color cl) c = cl; public void changeposition(int newx, int newy) x = newx; y = newy; public void fillcircle(boolean fill) filled = fill; public int getdiameter() return diameter; What happens if we want to add more functionality to the Circle class, or we want to change some of the ways the methods work in the Circle class? Well, you could change the Circle class, but the problem is you could adversely affect the way the programs that are using the Circle class works. A solution is to create a child of the Circle class. Let s take a look at the simplest example of inheritance. This program is called CircleEnhanced. The lines are numbered for reference only. 1. public class CircleEnhanced extends Circle public CircleEnhanced() Breaking It Down In line 1, we are performing inheritance by using the keyword extends. Once we say extends Circle, it means that CircleEnhanced inherits the methods, classes and variables from Circle. There is no need to redefine the methods, classes and variables in CircleEnhanced. Even though that we are inheriting from Circle, we are still required to define a constructor. Note that this code is demonstrating the simplest example of inheritance, and it is not a realistic use of inheritance. Let s do a more realistic example of this. What we are going to do is expand the constructor and add two more methods specific to CircleEnhanced. The lines are numbered for reference only. 1. import java.awt.*; 2. public class CircleEnhanced extends Circle

4 3. 4. /** 5. * Predetermines the look of the circle as an open circle in black starting at 10, */ 7. public CircleEnhanced() super(); /** 13. * Draws a face on the graphic area 14. */ 15. public void drawface(graphics g) // this is the face 18. g.drawoval(50, 50, 100, 100); // these are the eyes. Rather than using the drawoval to draw the eyes, 21. // we'll use the fillarc. We are drawing "positive arcs", which means that 22. // you are drawing COUNTERCLOCKWISE g.fillarc(75, 75, 10, 10, 0, 360); 25. g.fillarc(120, 75, 10, 10, 0, 360); // this is the smiley face. We are going to use a drawarc. We are going to draw 28. // a "negative arc", which means that you are drawing CLOCKWISE. 29. g.drawarc(75, 75, 50, 50, 0, -180); /** 33. * Calculate the area of the circle on the screen in pixels and return the area 34. */ 35. public double getarea() // radius is diameter / int radius = super.getdiameter() / 2; // calculate the area and return the area 41. double area = (Math.pow(radius, 2)) * Math.PI; 42. return area; Breaking It Down Notice that in line 1, we are importing the java.awt library. You can import libraries in your reusable classes and subclasses In line 9, we are calling a method called super(). The super() method calls the constructor of the superclass. So, when the user makes an instance of the class CircleEnhanced, the constructor of the CircleEnhanced will make a call to the Circle constructor. In lines 12 through 14 and lines 32 through 34, we are making a Javadoc style comment. This is the comment style that the javadoc utility looks for in the code to write descriptions of the methods. Lines 15 through 30 is a method that is a part of CircleEnhanced. So is lines 35 through 43. In line 38, we are referencing super. The object reference of super means reference the superclass. So, if we want to use a method in the superclass getdiameter, we use the object reference super. NOTE: When you use the super() method or when you call a method in the superclass using the super keyword, that must be the first line in your method. Let s take a look at this in use. The lines are numbered for reference purposes. 1. import java.awt.*;

5 2. import java.applet.*; 3. 4.public class TestCircle extends Applet public void paint(graphics g) // In this example, we are using the Circle class 10. // These are all methods in the Circle Class 11. Circle c = new Circle(); 12. c.fillcircle(true); 13. c.changecolor(color.green); 14. c.drawcircle(g); /* In this example, we are using the CircleEnhanced class 17. * We are going to use methods in the CircleEnhanced class, 18. * and we are going to use methods that actually exist in the 19. * parent class Circle to demonstrate inheritance. 20. */ 21. CircleEnhanced ce = new CircleEnhanced(); 22. ce.fillcircle(true); // in parent - superclass 23. double area = ce.getarea(); // in child - subclass 24. ce.changeposition(50, 50); // in parent - superclass 25. ce.drawcircle(g); // in parent - superclass // now, we are going to write the area of our CircleEnhanced 28. g.drawstring("the area of our custom circle in black is: " + area, 5, 150); Breaking It Down In line 21, we are making an instance of CircleEnhanced. Remember that when we make an instance of the CircleEnhanced class, it is calling the constructor of CircleEnhanced. Remember also that in the CircleEnhanced class, the CircleEnhanced constructor is calling the super() method, which calls the constructor of the parent. In lines 22, 24, and 25, we are calling methods that actually exist in the parent. How Java works is it is going to first look in the class for the methods being called. If the methods do not exist, it will then look in the parent class for the methods. In this case, these methods exist in the parent (super) class of Circle, so it will execute, or run, the code in the methods in the superclass. In line 23, this method exists in the class. Here are the results of this program:

6 Polymorphism in Java Remember that the purpose of making subclasses is to reduce development time. What happens if the functionality in a method of the superclass is not robust enough for the subclass? In other words, what if the subclass is supposed to perform the code in a method of the superclass, but more functionality for that method is needed? Method overriding gives that option. Method overriding is when the programmer rewrites the method in the subclass from the superclass. For example, when you were developing applets, you were performing method overriding when you were writing code for the paint method. Let s take a look at method overriding, or polymorphism in action. In this case, we are going to rewrite the drawcircle() method in CircleEnhanced to perform the same functionality as the parent, but it is also going to write the area of the circle. 1. import java.awt.*; 2. public class CircleEnhanced extends Circle /** 5. * Predetermines the look of the circle as an open circle in black starting at 10, */ 7. public CircleEnhanced() super(); /** 13. * Draws a face on the graphic area 14. */ 15. public void drawface(graphics g) // this is the face 18. g.drawoval(50, 50, 100, 100); // these are the eyes. Rather than using the drawoval to draw the eyes, 21. // we'll use the fillarc. We are drawing "positive arcs", which means that 22. // you are drawing COUNTERCLOCKWISE 23.

7 24. g.fillarc(75, 75, 10, 10, 0, 360); 25. g.fillarc(120, 75, 10, 10, 0, 360); // this is the smiley face. We are going to use a drawarc. We are going to draw 28. // a "negative arc", which means that you are drawing CLOCKWISE. 29. g.drawarc(75, 75, 50, 50, 0, -180); /** 33. * Calculate the area of the circle on the screen in pixels and return the area 34. */ 35. public double getarea() // radius is diameter / int radius = super.getdiameter() / 2; // calculate the area and return the area 41. double area = (Math.pow(radius, 2)) * Math.PI; 42. return area; /* 45. * draw a circle on the graphics area 46. */ 47. public void drawcircle(graphics g) super.drawcircle(g); // run the code in drawcircle in the parent class 50. g.drawstring("the area of this circle is: " + getarea(), 2, 175); Breaking It Down In lines 47 through 51, we are overriding the drawcircle method to not only draw the circle, but also write the area in the graphics area. Again, we are making a reference to the superclass with the keyword super, and we are running the code in the drawcircle method of the superclass. We are going to use the TestCircle program that we used earlier to test our results. Note that we did not have to recompile the TestCircle program. The beauty of Java is the program will know to use the latest compiled versions of the class. There is no need to recompile the program that is making an instance of the class. Also, note that in Java, remember that when we are calling a method of a class, it is going to look in the class first. If it exists in the class, it will perform the method that exists in the class. It will not look further into the relationship. Here are the results of the program:

8 Method, Class and Variable Scope When a variable, method or class is public, it means that all classes can access this. For example, all programs that make an instance of a class can call public methods. Think of public as visible by all. Look at a graphic of class MySample and it s relationship to other sample classes to get a better understanding of public access:

9 When a variable, method or class is protected, it means that the class that has the variable, method or class can access the variable or method. It also means that the class s subclasses (children) can also access the variable, and if the class is part of a package, other classes within the package can access the variable. Look at a graphic of class MySample and it s relationship to other sample classes to get a better understanding of protected access: When a variable, method, or class is private, it means that only the class that has the variable, method and/or class can access the variable. Look at a graphic of class MySample and it s relationship to other sample classes to get a better understanding of private access: When a variable, method, or class has no declaration, it is similar to how the variable is accessed when it s declared as protected, but the class s subclasses (children) cannot access the variable.

10 However, if the children are in the package with the parent, then the children can access the variable directly. Look at a graphic of class MySample and it s relationship to other sample classes to get a better understanding of unspecified access: