We have been using simple class hierarchies that consist of only a superclass and a subclass. However, you can build hierarchies that contain as many layers of inheritance as you like. As mentioned, it is perfectly acceptable to use a subclass as a superclass of another. Method Overriding<\/strong> You may also like the Inheritance<\/a><\/p>\n
\nFor example, given three classes called A, B, and C, C can be a subclass of B, which is a subclass of A. When this type of situation occurs, each subclass inherits all of the traits found in all of its superclasses. In this case, C inherits all aspects of B and A. To see how a multilevel hierarchy can be useful, consider the following program. In it, the subclass BoxWeight is used as a superclass to create the subclass called Shipment. Shipment inherits all of the traits of BoxWeight and Box and adds a field called cost, which holds the cost of shipping such a parcel.
\n\/\/ Extend BoxWeight to include shipping costs.
\n\/\/ Start with Box.
\nclass Box {
\nprivate double width;
\nprivate double-height;
\nprivate double depth;
\n\/\/ construct clone of an object
\nBox(Box ob) { \/\/ pass object to constructor
\nwidth = ob.width;
\nheight = ob.height;
\ndepth = ob.depth;
\n}
\n\/\/ constructor used when all dimensions specified
\nBox(double w, double h, double d) {
\nwidth = w;
\nheight = h;
\ndepth = d;
\n}
\n\/\/ constructor used when no dimensions specified
\nBox() {
\nwidth = -1; \/\/ use -1 to indicate
\nheight = -1; \/\/ an uninitialized
\ndepth = -1; \/\/ box
\n}
\n\/\/ constructor used when cube is created
\nBox(double len) {
\nwidth = height = depth = len;
\n}
\n\/\/ compute and return volume
\ndouble volume() {
\nreturn width * height * depth;
\n}
\n}
\n\/\/ Add weight.
\nclass BoxWeight extends Box {
\ndouble weight; \/\/ weight of box
\n\/\/ construct clone of an object
\nBoxWeight(BoxWeight ob) { \/\/ pass object to constructor
\nsuper(ob);
\nweight = ob.weight;
\n}
\n\/\/ constructor when all parameters are specified
\nBoxWeight(double w, double h, double d, double m) {
\nsuper(w, h, d); \/\/ call superclass constructor
\nweight = m;
\n}
\n\/\/ default constructor
\nBoxWeight() {
\nsuper();
\nweight = -1;
\n}
\n\/\/ constructor used when cube is created
\nBoxWeight(double len, double m) {
\nsuper(len);
\nweight = m;
\n}
\n}
\n\/\/ Add shipping costs.
\nclass Shipment extends BoxWeight {
\ndouble cost;
\n\/\/ construct clone of an object
\nShipment(Shipment ob) { \/\/ pass object to constructor
\nsuper(ob);
\ncost = ob.cost;
\n}
\n\/\/ constructor when all parameters are specified
\nShipment(double w, double h, double d,
\ndouble m, double c) {
\nsuper(w, h, d, m); \/\/ call superclass constructor
\ncost = c;
\n}
\n\/\/ default constructor
\nShipment() {
\nsuper();
\ncost = -1;
\n}
\n\/\/ constructor used when cube is created
\nShipment(double len, double m, double c) {
\nsuper(len, m);
\ncost = c;
\n}
\n}
\nclass DemoShipment {
\npublic static void main(String args[]) {
\nShipment shipment1 =
\nnew Shipment(10, 20, 15, 10, 3.41);
\nShipment shipment2 =
\nnew Shipment(2, 3, 4, 0.76, 1.28);
\ndouble vol;
\nvol = shipment1.volume();
\nSystem.out.println(“Volume of shipment1 is ” + vol);
\nSystem.out.println(“Weight of shipment1 is ”
\n+ shipment1.weight);
\nSystem.out.println(“Shipping cost: $” + shipment1.cost);
\nSystem.out.println();
\nvol = shipment2.volume();
\nSystem.out.println(“Volume of shipment2 is ” + vol);
\nSystem.out.println(“Weight of shipment2 is ”
\n+ shipment2.weight);
\nSystem.out.println(“Shipping cost: $” + shipment2.cost);
\n}
\n}
\nThe output of this program is shown here:<\/strong>
\nVolume of shipment1 is 3000.0
\nWeight of shipment1 is 10.0
\nShipping cost: $3.41
\nVolume of shipment2 is 24.0
\nWeight of shipment2 is 0.76
\nShipping cost: $1.28
\nBecause of inheritance, Shipment can make use of the previously defined classes of Box and BoxWeight, adding only the extra information it needs for its own, specific application. This is part of the value of inheritance; it allows the reuse of code. This example illustrates one other important point: super( ) always refers to the constructor in the closest superclass. The super( ) in Shipment calls the constructor in BoxWeight. The super( ) in BoxWeight calls the constructor in Box. In a class hierarchy, if a superclass constructor requires parameters, then all subclasses must pass those parameters \u201cup the line.\u201d This is true whether or not a subclass needs parameters of its own.<\/p>\n
\nIn a class hierarchy, when a method in a subclass has the same name and type signature as a method in its superclass, then the method in the subclass is said to override the method in the superclass. When an overridden method is called from within a subclass, it will always
\nrefer to the version of that method defined by the subclass.<\/p>\n