{"id":3446,"date":"2019-06-20T11:43:07","date_gmt":"2019-06-20T11:43:07","guid":{"rendered":"http:\/\/softlect.in\/?p=3446"},"modified":"2019-06-20T12:01:20","modified_gmt":"2019-06-20T12:01:20","slug":"java-inheritance","status":"publish","type":"post","link":"http:\/\/softlect.com\/index.php\/java-inheritance\/","title":{"rendered":"Java Inheritance"},"content":{"rendered":"

<\/a>Inheritance<\/strong><\/h1>\n

 <\/p>\n

Inheritance is one of the foundations of object-oriented programming because it allows the creation of hierarchical classifications. Using inheritance, you can create a general class that defines behavior common to a set of related items. This class can then be inherited by other, more specific classes, each adding those things that are unique to it. In the terminology of Java, a class that is inherited is called a superclass. <\/em>The class that does the inheriting is called a subclass. <\/em><\/p>\n

 <\/p>\n

<\/a>Inheritance Basics<\/strong><\/h2>\n

To inherit a class, you simply incorporate the definition of one class into another by using the extends <\/strong>keyword. To see how, let\u2019s begin with a short example. The following program creates a superclass called A <\/strong>and a subclass called B<\/strong>. Notice how the keyword extends <\/strong>is used to create a subclass of A<\/strong>.<\/p>\n

 <\/p>\n

\/\/ A simple example of inheritance.<\/p>\n

\/\/ Create a superclass.<\/p>\n

class A {<\/p>\n

int i, j;<\/p>\n

void showij() {<\/p>\n

System.out.println(“i and j: ” + i + ” ” + j);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Create a subclass by extending class A.<\/p>\n

class B extends A {<\/p>\n

int k;<\/p>\n

void showk() {<\/p>\n

System.out.println(“k: ” + k);<\/p>\n

}<\/p>\n

void sum() {<\/p>\n

System.out.println(“i+j+k: ” + (i+j+k));<\/p>\n

}<\/p>\n

}<\/p>\n

class SimpleInheritance {<\/p>\n

public static void main(String args[]) {<\/p>\n

A superOb = new A();<\/p>\n

B subOb = new B();<\/p>\n

\/\/ The superclass may be used by itself.<\/p>\n

superOb.i = 10;<\/p>\n

superOb.j = 20;<\/p>\n

System.out.println(“Contents of superOb: “);<\/p>\n

superOb.showij();<\/p>\n

System.out.println();<\/p>\n

\/* The subclass has access to all public members of<\/p>\n

its superclass. *\/<\/p>\n

subOb.i = 7;<\/p>\n

subOb.j = 8;<\/p>\n

subOb.k = 9;<\/p>\n

System.out.println(“Contents of subOb: “);<\/p>\n

subOb.showij();<\/p>\n

subOb.showk();<\/p>\n

System.out.println();<\/p>\n

System.out.println(“Sum of i, j and k in subOb:”);<\/p>\n

subOb.sum();<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

The output from this program is shown here:<\/p>\n

Contents of superOb:<\/p>\n

i and j: 10 20<\/p>\n

Contents of subOb:<\/p>\n

i and j: 7 8<\/p>\n

k: 9<\/p>\n

Sum of i, j and k in subOb:<\/p>\n

i+j+k: 24<\/p>\n

 <\/p>\n

As you can see, the subclass B <\/strong>includes all of the members of its superclass, A<\/strong>. This is why subOb <\/strong>can access i <\/strong>and j <\/strong>and call showij( )<\/strong>. Also, inside sum( )<\/strong>, i <\/strong>and j <\/strong>can be referred to directly, as if they were part of B<\/strong>. Even though A <\/strong>is a superclass for B<\/strong>, it is also a completely independent, stand-alone class. Being a superclass for a subclass does not mean that the superclass cannot be used by itself. Further, a subclass can be a superclass for another subclass. The general form of a class <\/strong>declaration that inherits a superclass is shown here:<\/p>\n

 <\/p>\n

class subclass-name <\/em>extends superclass-name <\/em>{<\/p>\n

\/\/ body of class<\/p>\n

}<\/p>\n

 <\/p>\n

You can only specify one superclass for any subclass that you create. Java does not support the inheritance of multiple superclasses into a single subclass. You can, as stated, create a hierarchy of inheritance in which a subclass becomes a superclass of another subclass. However, no class can be a superclass of itself.<\/p>\n

 <\/p>\n

<\/a>Member Access and Inheritance<\/strong><\/h2>\n

Although a subclass includes all of the members of its superclass, it cannot access those members of the superclass that have been declared as private<\/strong>. For example, consider the following simple class hierarchy:<\/p>\n

 <\/p>\n

\/* In a class hierarchy, private members remain<\/p>\n

private to their class.<\/p>\n

This program contains an error and will not<\/p>\n

compile.<\/p>\n

*\/<\/p>\n

\/\/ Create a superclass.<\/p>\n

class A {<\/p>\n

int i; \/\/ public by default<\/p>\n

private int j; \/\/ private to A<\/p>\n

void setij(int x, int y) {<\/p>\n

i = x;<\/p>\n

j = y;<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ A’s j is not accessible here.<\/p>\n

class B extends A {<\/p>\n

int total;<\/p>\n

void sum() {<\/p>\n

total = i + j; \/\/ ERROR, j is not accessible here<\/p>\n

}<\/p>\n

}<\/p>\n

class Access {<\/p>\n

public static void main(String args[]) {<\/p>\n

B subOb = new B();<\/p>\n

subOb.setij(10, 12);<\/p>\n

subOb.sum();<\/p>\n

System.out.println(“Total is ” + subOb.total);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

This program will not compile because the reference to j <\/strong>inside the sum( ) <\/strong>method of B <\/strong>causes an access violation. Since j <\/strong>is declared as private<\/strong>, it is only accessible by other members of its own class. Subclasses have no access to it. Here, the final version of the Box <\/strong>class developed in the preceding chapter will be extended to include a fourth component called weight<\/strong>. Thus, the new class will contain a box\u2019s width, height, depth, and weight.<\/p>\n

 <\/p>\n

 <\/p>\n

\/\/ This program uses inheritance to extend Box.<\/p>\n

class Box {<\/p>\n

double width;<\/p>\n

double height;<\/p>\n

double depth;<\/p>\n

\/\/ construct clone of an object<\/p>\n

Box(Box ob) { \/\/ pass object to constructor<\/p>\n

width = ob.width;<\/p>\n

height = ob.height;<\/p>\n

depth = ob.depth;<\/p>\n

}<\/p>\n

\/\/ constructor used when all dimensions specified<\/p>\n

Box(double w, double h, double d) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

}<\/p>\n

\/\/ constructor used when no dimensions specified<\/p>\n

Box() {<\/p>\n

width = -1; \/\/ use -1 to indicate<\/p>\n

height = -1; \/\/ an uninitialized<\/p>\n

depth = -1; \/\/ box<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

Box(double len) {<\/p>\n

width = height = depth = len;<\/p>\n

}<\/p>\n

\/\/ compute and return volume<\/p>\n

double volume() {<\/p>\n

return width * height * depth;<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Here, Box is extended to include weight.<\/p>\n

class BoxWeight extends Box {<\/p>\n

double weight; \/\/ weight of box<\/p>\n

\/\/ constructor for BoxWeight<\/p>\n

BoxWeight(double w, double h, double d, double m) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

}<\/p>\n

class DemoBoxWeight {<\/p>\n

public static void main(String args[]) {<\/p>\n

BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);<\/p>\n

BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);<\/p>\n

double vol;<\/p>\n

vol = mybox1.volume();<\/p>\n

System.out.println(“Volume of mybox1 is ” + vol);<\/p>\n

System.out.println(“Weight of mybox1 is ” + mybox1.weight);<\/p>\n

System.out.println();<\/p>\n

vol = mybox2.volume();<\/p>\n

System.out.println(“Volume of mybox2 is ” + vol);<\/p>\n

System.out.println(“Weight of mybox2 is ” + mybox2.weight);<\/p>\n

}<\/p>\n

}<\/p>\n

The output from this program is shown here:<\/p>\n

Volume of mybox1 is 3000.0<\/p>\n

Weight of mybox1 is 34.3<\/p>\n

Volume of mybox2 is 24.0<\/p>\n

Weight of mybox2 is 0.076<\/p>\n

\u00a0<\/strong><\/p>\n

BoxWeight <\/strong>inherits all of the characteristics of Box <\/strong>and adds to them the weight <\/strong>component. It is not necessary for BoxWeight <\/strong>to re-create all of the features found in Box<\/strong>. It can simply extend Box <\/strong>to meet its own purposes. A major advantage of inheritance is that once you have created a superclass that defines the attributes common to a set of objects, it can be used to create any number of more specific subclasses. For example, the following class inherits Box <\/strong>and adds a color attribute:<\/p>\n

 <\/p>\n

\/\/ Here, Box is extended to include color.<\/p>\n

class ColorBox extends Box {<\/p>\n

int color; \/\/ color of box<\/p>\n

ColorBox(double w, double h, double d, int c) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

color = c;<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

Remember, once you have created a superclass that defines the general aspects of an object, that superclass can be inherited to form specialized classes. Each subclass simply adds its own, unique attributes.<\/p>\n

 <\/p>\n

<\/a>A Superclass Variable Can Reference a Subclass Object<\/strong><\/h2>\n

A reference variable of a superclass can be assigned a reference to any subclass derived from that superclass. For example, consider the following:<\/p>\n

 <\/p>\n

class RefDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);<\/p>\n

Box plainbox = new Box();<\/p>\n

double vol;<\/p>\n

vol = weightbox.volume();<\/p>\n

System.out.println(“Volume of weightbox is ” + vol);<\/p>\n

System.out.println(“Weight of weightbox is ” +<\/p>\n

weightbox.weight);<\/p>\n

System.out.println();<\/p>\n

\/\/ assign BoxWeight reference to Box reference<\/p>\n

plainbox = weightbox;<\/p>\n

vol = plainbox.volume(); \/\/ OK, volume() defined in Box<\/p>\n

System.out.println(“Volume of plainbox is ” + vol);<\/p>\n

\/* The following statement is invalid because plainbox<\/p>\n

does not define a weight member. *\/<\/p>\n

\/\/ System.out.println(“Weight of plainbox is ” + plainbox.weight);<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

Here, weightbox <\/strong>is a reference to BoxWeight <\/strong>objects, and plainbox <\/strong>is a reference to Box <\/strong>objects. Since BoxWeight <\/strong>is a subclass of Box<\/strong>, it is permissible to assign plainbox <\/strong>a reference to the weightbox <\/strong>object.<\/p>\n

It is important to understand that it is the type of the reference variable not the type of the object that it refers to that determines what members can be accessed. That is, when a reference to a subclass object is assigned to a superclass reference variable, you will have access only to those parts of the object defined by the superclass. This is why plainbox <\/strong>can\u2019t access weight <\/strong>even when it refers to a BoxWeight <\/strong>object. This is why the last line of code in the preceding fragment is commented out. It is not possible for a Box <\/strong>reference to access the weight <\/strong>field, because it does not define one.<\/p>\n

 <\/p>\n

<\/a>Using super<\/strong><\/h2>\n

For example, the constructor for BoxWeight <\/strong>explicitly initializes the width<\/strong>, height<\/strong>, and depth <\/strong>fields of Box( )<\/strong>. Not only does this duplicate code found in its superclass, which is inefficient, but it implies that a subclass must be granted access to these members. However, there will be times when you will want to create a superclass that keeps the details of its implementation to itself that is, that keeps its data members private. In this case, there would be no way for a subclass to directly access or initialize these variables on its own. Whenever a subclass needs to refer to its immediate superclass, it can do so by use of the keyword super<\/strong>. super <\/strong>has two general forms. The first calls the superclass\u2019 constructor. The second is used to access a member of the superclass that has been hidden by a member of a subclass. Each use is examined here.<\/p>\n

 <\/p>\n

<\/a>Using super to Call Superclass Constructors<\/strong><\/h2>\n

A subclass can call a constructor method defined by its superclass by use of the following form of super<\/strong>:<\/p>\n

super(parameter<\/em>–list<\/em>);<\/p>\n

 <\/p>\n

Here, parameter<\/em>–list <\/em>specifies any parameters needed by the constructor in the superclass. super( ) <\/strong>must always be the first statement executed inside a subclass\u2019 constructor. To see how super( ) <\/strong>is used, consider this improved version of the BoxWeight( ) <\/strong>class:<\/p>\n

 <\/p>\n

\/\/ BoxWeight now uses super to initialize its Box attributes.<\/p>\n

class BoxWeight extends Box {<\/p>\n

double weight; \/\/ weight of box<\/p>\n

\/\/ initialize width, height, and depth using super()<\/p>\n

BoxWeight(double w, double h, double d, double m) {<\/p>\n

super(w, h, d); \/\/ call superclass constructor<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

Here, BoxWeight( ) <\/strong>calls super( ) <\/strong>with the parameters w<\/strong>, h<\/strong>, and d<\/strong>. This causes the Box( ) <\/strong>constructor to be called, which initializes width<\/strong>, height<\/strong>, and depth <\/strong>using these\u00a0 values. BoxWeight <\/strong>no longer initializes these values itself. It only needs to initialize the value unique to it: weight<\/strong>. This leaves Box <\/strong>free to make these values private <\/strong>if desired. In the preceding example, super( ) <\/strong>was called with three arguments. Since constructors can be overloaded, super( ) <\/strong>can be called using any form defined by the superclass. The constructor executed will be the one that matches the arguments. For example, here is a complete implementation of BoxWeight <\/strong>that provides constructors for the various ways that a box can be constructed. In each case, super( ) <\/strong>is called using the appropriate arguments. Notice that width<\/strong>, height<\/strong>, and depth <\/strong>have been made private within Box<\/strong>.<\/p>\n

 <\/p>\n

\/\/ A complete implementation of BoxWeight.<\/p>\n

class Box {<\/p>\n

private double width;<\/p>\n

private double height;<\/p>\n

private double depth;<\/p>\n

\/\/ construct clone of an object<\/p>\n

Box(Box ob) { \/\/ pass object to constructor<\/p>\n

width = ob.width;<\/p>\n

height = ob.height;<\/p>\n

depth = ob.depth;<\/p>\n

}<\/p>\n

\/\/ constructor used when all dimensions specified<\/p>\n

Box(double w, double h, double d) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

}<\/p>\n

\/\/ constructor used when no dimensions specified<\/p>\n

Box() {<\/p>\n

width = -1; \/\/ use -1 to indicate<\/p>\n

height = -1; \/\/ an uninitialized<\/p>\n

depth = -1; \/\/ box<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

Box(double len) {<\/p>\n

width = height = depth = len;<\/p>\n

}<\/p>\n

\/\/ compute and return volume<\/p>\n

double volume() {<\/p>\n

return width * height * depth;<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ BoxWeight now fully implements all constructors.<\/p>\n

class BoxWeight extends Box {<\/p>\n

double weight; \/\/ weight of box<\/p>\n

\/\/ construct clone of an object<\/p>\n

BoxWeight(BoxWeight ob) { \/\/ pass object to constructor<\/p>\n

super(ob);<\/p>\n

weight = ob.weight;<\/p>\n

}<\/p>\n

\/\/ constructor when all parameters are specified<\/p>\n

BoxWeight(double w, double h, double d, double m) {<\/p>\n

super(w, h, d); \/\/ call superclass constructor<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

\/\/ default constructor<\/p>\n

BoxWeight() {<\/p>\n

super();<\/p>\n

weight = -1;<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

BoxWeight(double len, double m) {<\/p>\n

super(len);<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

}<\/p>\n

class DemoSuper {<\/p>\n

public static void main(String args[]) {<\/p>\n

BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);<\/p>\n

BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);<\/p>\n

BoxWeight mybox3 = new BoxWeight(); \/\/ default<\/p>\n

BoxWeight mycube = new BoxWeight(3, 2);<\/p>\n

BoxWeight myclone = new BoxWeight(mybox1);<\/p>\n

double vol;<\/p>\n

vol = mybox1.volume();<\/p>\n

System.out.println(“Volume of mybox1 is ” + vol);<\/p>\n

System.out.println(“Weight of mybox1 is ” + mybox1.weight);<\/p>\n

System.out.println();<\/p>\n

vol = mybox2.volume();<\/p>\n

System.out.println(“Volume of mybox2 is ” + vol);<\/p>\n

System.out.println(“Weight of mybox2 is ” + mybox2.weight);<\/p>\n

System.out.println();<\/p>\n

vol = mybox3.volume();<\/p>\n

System.out.println(“Volume of mybox3 is ” + vol);<\/p>\n

System.out.println(“Weight of mybox3 is ” + mybox3.weight);<\/p>\n

System.out.println();<\/p>\n

vol = myclone.volume();<\/p>\n

System.out.println(“Volume of myclone is ” + vol);<\/p>\n

System.out.println(“Weight of myclone is ” + myclone.weight);<\/p>\n

System.out.println();<\/p>\n

vol = mycube.volume();<\/p>\n

System.out.println(“Volume of mycube is ” + vol);<\/p>\n

System.out.println(“Weight of mycube is ” + mycube.weight);<\/p>\n

System.out.println();<\/p>\n

}<\/p>\n

}<\/p>\n

This program generates the following output:<\/p>\n

Volume of mybox1 is 3000.0<\/p>\n

Weight of mybox1 is 34.3<\/p>\n

Volume of mybox2 is 24.0<\/p>\n

Weight of mybox2 is 0.076<\/p>\n

Volume of mybox3 is -1.0<\/p>\n

Weight of mybox3 is -1.0<\/p>\n

Volume of myclone is 3000.0<\/p>\n

Weight of myclone is 34.3<\/p>\n

Volume of mycube is 27.0<\/p>\n

Weight of mycube is 2.0<\/p>\n

Pay special attention to this constructor in BoxWeight( )<\/strong>:<\/p>\n

\/\/ construct clone of an object<\/p>\n

BoxWeight(BoxWeight ob) { \/\/ pass object to constructor<\/p>\n

super(ob);<\/p>\n

weight = ob.weight;<\/p>\n

}<\/p>\n

 <\/p>\n

Notice that super( ) <\/strong>is called with an object of type BoxWeight <\/strong>not of type Box<\/strong>. This still invokes the constructor Box(Box ob)<\/strong>. As mentioned earlier, a superclass variable can be used to reference any object derived from that class. Thus, we are able to pass a BoxWeight <\/strong>object to the Box <\/strong>constructor. Of course, Box <\/strong>only has knowledge of its own members. Let\u2019s review the key concepts behind super( )<\/strong>. When a subclass calls super( )<\/strong>, it is calling the constructor of its immediate superclass. Thus, super( ) <\/strong>always refers to the superclass immediately above the calling class. This is true even in a multileveled hierarchy. Also, super( ) <\/strong>must always be the first statement executed inside a subclass constructor.<\/p>\n

 <\/p>\n

<\/a>A Second Use for super<\/strong><\/h2>\n

The second form of super <\/strong>acts somewhat like this<\/strong>, except that it always refers to the superclass of the subclass in which it is used. This usage has the following general form:<\/p>\n

 <\/p>\n

super.member<\/em><\/p>\n

 <\/p>\n

Here, member <\/em>can be either a method or an instance variable. This second form of super <\/strong>is most applicable to situations in which member names of a subclass hide members by the same name in the superclass. Consider this simple class hierarchy:<\/p>\n

 <\/p>\n

\/\/ Using super to overcome name hiding.<\/p>\n

class A {<\/p>\n

int i;<\/p>\n

}<\/p>\n

\/\/ Create a subclass by extending class A.<\/p>\n

class B extends A {<\/p>\n

int i; \/\/ this i hides the i in A<\/p>\n

B(int a, int b) {<\/p>\n

super.i = a; \/\/ i in A<\/p>\n

i = b; \/\/ i in B<\/p>\n

}<\/p>\n

void show() {<\/p>\n

System.out.println(“i in superclass: ” + super.i);<\/p>\n

System.out.println(“i in subclass: ” + i);<\/p>\n

}<\/p>\n

}<\/p>\n

class UseSuper {<\/p>\n

public static void main(String args[]) {<\/p>\n

B subOb = new B(1, 2);<\/p>\n

subOb.show();<\/p>\n

}<\/p>\n

}<\/p>\n

This program displays the following:<\/p>\n

i in superclass: 1<\/p>\n

i in subclass: 2<\/p>\n

 <\/p>\n

Although the instance variable i <\/strong>in B <\/strong>hides the i <\/strong>in A<\/strong>, super <\/strong>allows access to the I <\/strong>defined in the superclass. As you will see, super <\/strong>can also be used to call methods that are hidden by a subclass.<\/p>\n

 <\/p>\n

<\/a>Creating a Multilevel Hierarchy<\/strong><\/h2>\n

Up to this point, 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. For example, given three classes called A<\/strong>, B<\/strong>, and C<\/strong>, C <\/strong>can be a subclass of B<\/strong>, which is a subclass of A<\/strong>. When this type of situation occurs, each subclass inherits all of the traits found in all of its superclasses. In this case, C <\/strong>inherits all aspects of B <\/strong>and A<\/strong>. To see how a multilevel hierarchy can be useful, consider the following program. In it, the subclass BoxWeight <\/strong>is used as a superclass to create the subclass called Shipment<\/strong>. Shipment <\/strong>inherits all of the traits of BoxWeight <\/strong>and Box<\/strong>, and adds a field called cost<\/strong>, which holds the cost of shipping such a parcel.<\/p>\n

 <\/p>\n

\/\/ Extend BoxWeight to include shipping costs.<\/p>\n

\/\/ Start with Box.<\/p>\n

class Box {<\/p>\n

private double width;<\/p>\n

private double height;<\/p>\n

private double depth;<\/p>\n

\/\/ construct clone of an object<\/p>\n

Box(Box ob) { \/\/ pass object to constructor<\/p>\n

width = ob.width;<\/p>\n

height = ob.height;<\/p>\n

depth = ob.depth;<\/p>\n

}<\/p>\n

\/\/ constructor used when all dimensions specified<\/p>\n

Box(double w, double h, double d) {<\/p>\n

width = w;<\/p>\n

height = h;<\/p>\n

depth = d;<\/p>\n

}<\/p>\n

\/\/ constructor used when no dimensions specified<\/p>\n

Box() {<\/p>\n

width = -1; \/\/ use -1 to indicate<\/p>\n

height = -1; \/\/ an uninitialized<\/p>\n

depth = -1; \/\/ box<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

Box(double len) {<\/p>\n

width = height = depth = len;<\/p>\n

}<\/p>\n

\/\/ compute and return volume<\/p>\n

double volume() {<\/p>\n

return width * height * depth;<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Add weight.<\/p>\n

class BoxWeight extends Box {<\/p>\n

double weight; \/\/ weight of box<\/p>\n

\/\/ construct clone of an object<\/p>\n

BoxWeight(BoxWeight ob) { \/\/ pass object to constructor<\/p>\n

super(ob);<\/p>\n

weight = ob.weight;<\/p>\n

}<\/p>\n

\/\/ constructor when all parameters are specified<\/p>\n

BoxWeight(double w, double h, double d, double m) {<\/p>\n

super(w, h, d); \/\/ call superclass constructor<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

\/\/ default constructor<\/p>\n

BoxWeight() {<\/p>\n

super();<\/p>\n

weight = -1;<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

BoxWeight(double len, double m) {<\/p>\n

super(len);<\/p>\n

weight = m;<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Add shipping costs<\/p>\n

class Shipment extends BoxWeight {<\/p>\n

double cost;<\/p>\n

\/\/ construct clone of an object<\/p>\n

Shipment(Shipment ob) { \/\/ pass object to constructor<\/p>\n

super(ob);<\/p>\n

cost = ob.cost;<\/p>\n

}<\/p>\n

\/\/ constructor when all parameters are specified<\/p>\n

Shipment(double w, double h, double d,<\/p>\n

double m, double c) {<\/p>\n

super(w, h, d, m); \/\/ call superclass constructor<\/p>\n

cost = c;<\/p>\n

}<\/p>\n

\/\/ default constructor<\/p>\n

Shipment() {<\/p>\n

super();<\/p>\n

cost = -1;<\/p>\n

}<\/p>\n

\/\/ constructor used when cube is created<\/p>\n

Shipment(double len, double m, double c) {<\/p>\n

super(len, m);<\/p>\n

cost = c;<\/p>\n

}<\/p>\n

}<\/p>\n

class DemoShipment {<\/p>\n

public static void main(String args[]) {<\/p>\n

Shipment shipment1 =<\/p>\n

new Shipment(10, 20, 15, 10, 3.41);<\/p>\n

Shipment shipment2 =<\/p>\n

new Shipment(2, 3, 4, 0.76, 1.28);<\/p>\n

double vol;<\/p>\n

vol = shipment1.volume();<\/p>\n

System.out.println(“Volume of shipment1 is ” + vol);<\/p>\n

System.out.println(“Weight of shipment1 is ”<\/p>\n

+ shipment1.weight);<\/p>\n

System.out.println(“Shipping cost: $” + shipment1.cost);<\/p>\n

System.out.println();<\/p>\n

vol = shipment2.volume();<\/p>\n

System.out.println(“Volume of shipment2 is ” + vol);<\/p>\n

System.out.println(“Weight of shipment2 is ”<\/p>\n

+ shipment2.weight);<\/p>\n

System.out.println(“Shipping cost: $” + shipment2.cost);<\/p>\n

}<\/p>\n

}<\/p>\n

The output of this program is shown here:<\/p>\n

Volume of shipment1 is 3000.0<\/p>\n

Weight of shipment1 is 10.0<\/p>\n

Shipping cost: $3.41<\/p>\n

Volume of shipment2 is 24.0<\/p>\n

Weight of shipment2 is 0.76<\/p>\n

Shipping cost: $1.28<\/p>\n

 <\/p>\n

Because of inheritance, Shipment <\/strong>can make use of the previously defined classes of Box <\/strong>and BoxWeight<\/strong>, 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( ) <\/strong>always refers to the constructor in the closest superclass. The super( ) <\/strong>in Shipment <\/strong>calls the constructor in BoxWeight<\/strong>. The super( ) <\/strong>in BoxWeight <\/strong>calls the constructor in Box<\/strong>. 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

\u00a0<\/em><\/p>\n

<\/a>When Constructors Are Called<\/strong><\/h2>\n

When a class hierarchy is created, in what order are the constructors for the classes that make up the hierarchy called? The answer is that in a class hierarchy, constructors are called in order of derivation, from superclass to subclass. Further, since super( ) <\/strong>must be the first statement executed in a subclass\u2019 constructor, this order is the same whether or not super( ) <\/strong>is used. If super( ) <\/strong>is not used, then the default or parameterless constructor of each superclass will be executed. The following program illustrates when constructors are executed:<\/p>\n

 <\/p>\n

\/\/ Demonstrate when constructors are called.<\/p>\n

\/\/ Create a super class.<\/p>\n

class A {<\/p>\n

A() {<\/p>\n

System.out.println(“Inside A’s constructor.”);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Create a subclass by extending class A.<\/p>\n

class B extends A {<\/p>\n

B() {<\/p>\n

System.out.println(“Inside B’s constructor.”);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Create another subclass by extending B.<\/p>\n

class C extends B {<\/p>\n

C() {<\/p>\n

System.out.println(“Inside C’s constructor.”);<\/p>\n

}<\/p>\n

}<\/p>\n

class CallingCons {<\/p>\n

public static void main(String args[]) {<\/p>\n

C c = new C();<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

The output from this program is shown here:<\/p>\n

Inside A\u2019s constructor<\/p>\n

Inside B\u2019s constructor<\/p>\n

Inside C\u2019s constructor<\/p>\n

 <\/p>\n

As you can see, the constructors are called in order of derivation.<\/p>\n

 <\/p>\n

<\/a>Method Overriding<\/strong><\/h2>\n

In a class hierarchy, when a method in a subclass has the same name and type signature or prototype as a method in its superclass, then the method in the subclass is said to override <\/em>the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass. The version of the method defined by the superclass will be hidden. Consider the following:<\/p>\n

 <\/p>\n

\/\/ Method overriding.<\/p>\n

class A {<\/p>\n

int i, j;<\/p>\n

A(int a, int b) {<\/p>\n

i = a;<\/p>\n

j = b;<\/p>\n

}<\/p>\n

\/\/ display i and j<\/p>\n

void show() {<\/p>\n

System.out.println(“i and j: ” + i + ” ” + j);<\/p>\n

}<\/p>\n

}<\/p>\n

class B extends A {<\/p>\n

int k;<\/p>\n

B(int a, int b, int c) {<\/p>\n

super(a, b);<\/p>\n

k = c;<\/p>\n

}<\/p>\n

\/\/ display k \u2013 this overrides show() in A<\/p>\n

void show() {<\/p>\n

System.out.println(“k: ” + k);<\/p>\n

}<\/p>\n

}<\/p>\n

class Override {<\/p>\n

public static void main(String args[]) {<\/p>\n

B subOb = new B(1, 2, 3);<\/p>\n

subOb.show(); \/\/ this calls show() in B<\/p>\n

}<\/p>\n

}<\/p>\n

The output produced by this program is shown here:<\/p>\n

k: 3<\/p>\n

 <\/p>\n

When show( ) <\/strong>is invoked on an object of type B<\/strong>, the version of show( ) <\/strong>defined\u00a0 within B <\/strong>is used. That is, the version of show( ) <\/strong>inside B <\/strong>overrides the version declared in A<\/strong>. If you wish to access the superclass version of an overridden function, you can do so by using super<\/strong>. For example, in this version of B<\/strong>, the superclass version of show( ) <\/strong>is invoked within the subclass\u2019 version. This allows all instance variables to be displayed.<\/p>\n

 <\/p>\n

class B extends A {<\/p>\n

int k;<\/p>\n

B(int a, int b, int c) {<\/p>\n

super(a, b);<\/p>\n

k = c;<\/p>\n

}<\/p>\n

void show() {<\/p>\n

super.show(); \/\/ this calls A’s show()<\/p>\n

System.out.println(“k: ” + k);<\/p>\n

}<\/p>\n

}<\/p>\n

If you substitute this version of A <\/strong>into the previous program, you will see the following output:<\/p>\n

i and j: 1 2<\/p>\n

k: 3<\/p>\n

 <\/p>\n

Here, super.show( ) <\/strong>calls the superclass version of show( )<\/strong>. Method overriding occurs only <\/em>when the names and the type signatures of the two methods are identical. For example, consider this modified version of the preceding example:<\/p>\n

 <\/p>\n

\/\/ Methods with differing type signatures are overloaded \u2013 not<\/p>\n

\/\/ overridden.<\/p>\n

class A {<\/p>\n

int i, j;<\/p>\n

A(int a, int b) {<\/p>\n

i = a;<\/p>\n

j = b;<\/p>\n

}<\/p>\n

\/\/ display i and j<\/p>\n

void show() {<\/p>\n

System.out.println(“i and j: ” + i + ” ” + j);<\/p>\n

}<\/p>\n

}<\/p>\n

\/\/ Create a subclass by extending class A.<\/p>\n

class B extends A {<\/p>\n

int k;<\/p>\n

B(int a, int b, int c) {<\/p>\n

super(a, b);<\/p>\n

k = c;<\/p>\n

}<\/p>\n

\/\/ overload show()<\/p>\n

void show(String msg) {<\/p>\n

System.out.println(msg + k);<\/p>\n

}<\/p>\n

}<\/p>\n

class Override {<\/p>\n

public static void main(String args[]) {<\/p>\n

B subOb = new B(1, 2, 3);<\/p>\n

subOb.show(“This is k: “); \/\/ this calls show() in B<\/p>\n

subOb.show(); \/\/ this calls show() in A<\/p>\n

}<\/p>\n

}<\/p>\n

The output produced by this program is shown here:<\/p>\n

This is k: 3<\/p>\n

i and j: 1 2<\/p>\n

 <\/p>\n

The version of show( ) <\/strong>in B <\/strong>takes a string parameter. This makes its type signature different from the one in A<\/strong>, which takes no parameters. Therefore, no overriding (or name hiding) takes place.<\/p>\n

 <\/p>\n

<\/a>Dynamic Method Dispatch<\/strong><\/h2>\n

Method overriding forms the basis for one of Java\u2019s most powerful concepts: dynamic method dispatch. <\/em>Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run time, rather than compile time. Dynamic method dispatch is important because this is how Java implements run-time polymorphism. a superclass reference variable can refer to a subclass object. Java uses this fact to resolve calls to overridden methods at run time. Here is how. When an overridden method is called through a superclass reference, Java determines which version of that method to execute based upon the type of the object being referred to at the time the call occurs. Thus, this determination is made at run time. When different types of objects are referred to, different versions of an overridden method will be called. if a superclass contains a method that is overridden by a subclass, then when different types of objects are referred to through a superclass reference variable, different versions of the method are executed. Here is an example that illustrates dynamic method dispatch:<\/p>\n

 <\/p>\n

\/\/ Dynamic Method Dispatch<\/p>\n

class A {<\/p>\n

void callme() {<\/p>\n

System.out.println(“Inside A’s callme method”);<\/p>\n

}<\/p>\n

}<\/p>\n

class B extends A {<\/p>\n

\/\/ override callme()<\/p>\n

void callme() {<\/p>\n

System.out.println(“Inside B’s callme method”);<\/p>\n

}<\/p>\n

}<\/p>\n

class C extends A {<\/p>\n

\/\/ override callme()<\/p>\n

void callme() {<\/p>\n

System.out.println(“Inside C’s callme method”);<\/p>\n

}<\/p>\n

}<\/p>\n

class Dispatch {<\/p>\n

public static void main(String args[]) {<\/p>\n

A a = new A(); \/\/ object of type A<\/p>\n

B b = new B(); \/\/ object of type B<\/p>\n

C c = new C(); \/\/ object of type C<\/p>\n

A r; \/\/ obtain a reference of type A<\/p>\n

r = a; \/\/ r refers to an A object<\/p>\n

r.callme(); \/\/ calls A’s version of callme<\/p>\n

r = b; \/\/ r refers to a B object<\/p>\n

r.callme(); \/\/ calls B’s version of callme<\/p>\n

THE JAVA LANGUAGE<\/p>\n

r = c; \/\/ r refers to a C object<\/p>\n

r.callme(); \/\/ calls C’s version of callme<\/p>\n

}<\/p>\n

}<\/p>\n

The output from the program is shown here:<\/p>\n

Inside A\u2019s callme method<\/p>\n

Inside B\u2019s callme method<\/p>\n

Inside C\u2019s callme method<\/p>\n

 <\/p>\n

This program creates one superclass called A <\/strong>and two subclasses of it, called B <\/strong>and C<\/strong>. Subclasses B <\/strong>and C <\/strong>override callme( ) <\/strong>declared in A<\/strong>. Inside the main( ) <\/strong>method, objects of type A<\/strong>, B<\/strong>, and C <\/strong>are declared. Also, a reference of type A<\/strong>, called r<\/strong>, is declared. The program then assigns a reference to each type of object to r <\/strong>and uses that reference to invoke callme( )<\/strong>. As the output shows, the version of callme( ) <\/strong>executed is determined by the type of object being referred to at the time of the call. Had it been determined by the type of the reference variable, r<\/strong>, you would see three calls to A<\/strong>\u2019s callme( ) <\/strong>method.<\/p>\n

 <\/p>\n

Let\u2019s look at a more practical example that uses method overriding. The following program creates a superclass called Figure <\/strong>that stores the dimensions of various two-dimensional objects. It also defines a method called area( ) <\/strong>that computes the area of an object. The program derives two subclasses from Figure<\/strong>. The first is Rectangle <\/strong>and the second is Triangle<\/strong>. Each of these subclasses overrides area( ) <\/strong>so that it returns the area of a rectangle and a triangle, respectively.<\/p>\n

 <\/p>\n

\/\/ Using run-time polymorphism.<\/p>\n

class Figure {<\/p>\n

double dim1;<\/p>\n

double dim2;<\/p>\n

Figure(double a, double b) {<\/p>\n

dim1 = a;<\/p>\n

dim2 = b;<\/p>\n

}<\/p>\n

double area() {<\/p>\n

System.out.println(“Area for Figure is undefined.”);<\/p>\n

return 0;<\/p>\n

}<\/p>\n

}<\/p>\n

class Rectangle extends Figure {<\/p>\n

Rectangle(double a, double b) {<\/p>\n

super(a, b);<\/p>\n

}<\/p>\n

\/\/ override area for rectangle<\/p>\n

double area() {<\/p>\n

System.out.println(“Inside Area for Rectangle.”);<\/p>\n

return dim1 * dim2;<\/p>\n

}<\/p>\n

}<\/p>\n

class Triangle extends Figure {<\/p>\n

Triangle(double a, double b) {<\/p>\n

super(a, b);<\/p>\n

}<\/p>\n

\/\/ override area for right triangle<\/p>\n

double area() {<\/p>\n

System.out.println(“Inside Area for Triangle.”);<\/p>\n

return dim1 * dim2 \/ 2;<\/p>\n

}<\/p>\n

}<\/p>\n

class FindAreas {<\/p>\n

public static void main(String args[]) {<\/p>\n

Figure f = new Figure(10, 10);<\/p>\n

Rectangle r = new Rectangle(9, 5);<\/p>\n

Triangle t = new Triangle(10, 8);<\/p>\n

Figure figref;<\/p>\n

figref = r;<\/p>\n

System.out.println(“Area is ” + figref.area());<\/p>\n

figref = t;<\/p>\n

System.out.println(“Area is ” + figref.area());<\/p>\n

figref = f;<\/p>\n

System.out.println(“Area is ” + figref.area());<\/p>\n

}<\/p>\n

}<\/p>\n

The output from the program is shown here:<\/p>\n

Inside Area for Rectangle.<\/p>\n

Area is 45<\/p>\n

Inside Area for Triangle.<\/p>\n

Area is 40<\/p>\n

Area for Figure is undefined.<\/p>\n

Area is 0<\/p>\n

 <\/p>\n

<\/a>Using Abstract Classes<\/strong><\/h2>\n

There are situations in which you will want to define a superclass that declares the structure of a given abstraction without providing a complete implementation of every method. That is, sometimes you will want to create a superclass that only defines a generalized form that will be shared by all of its subclasses, leaving it to each subclass to fill in the details. Such a class determines the nature of the methods that the subclasses must implement. One way this situation can occur is when a superclass is unable to create a meaningful implementation for a method. This is the case with the class Figure <\/strong>used in the preceding example. The definition of area( ) <\/strong>is simply a placeholder. It will not compute and display the area of any type of object. You may have methods which must be overridden by the subclass in order for the subclass to have any meaning. Consider the class Triangle<\/strong>. It has no meaning if area( ) <\/strong>is not defined. In this case, you want some way to ensure that a subclass does, indeed, override all necessary methods. Java\u2019s solution to this problem is the abstract method. <\/em>You can require that certain methods be overridden by subclasses by specifying the abstract <\/strong>type modifier. Thus, a subclass must override them it cannot simply use the version defined in the superclass. To declare an abstract method, use this general form:<\/p>\n

 <\/p>\n

abstract type name(parameter-list)<\/em>;<\/p>\n

 <\/p>\n

As you can see, no method body is present. Any class that contains one or more abstract methods must also be declared abstract. To declare a class abstract, you simply use the abstract <\/strong>keyword in front of the class <\/strong>keyword at the beginning of the class declaration. There can be no objects of an abstract class. That is, an abstract class cannot be directly instantiated with the new operator<\/strong>. Such objects would be useless, because an abstract class is not fully defined. Also, you cannot declare abstract constructors, or abstract static methods. Any subclass of an abstract class must either implement all of the abstract methods in the superclass, or be itself declared abstract<\/strong>. Here is a simple example of a class with an abstract method, followed by a class which implements that method:<\/p>\n

 <\/p>\n

\/\/ A Simple demonstration of abstract.<\/p>\n

abstract class A {<\/p>\n

abstract void callme();<\/p>\n

\/\/ concrete methods are still allowed in abstract classes<\/p>\n

void callmetoo() {<\/p>\n

System.out.println(“This is a concrete method.”);<\/p>\n

}<\/p>\n

}<\/p>\n

class B extends A {<\/p>\n

void callme() {<\/p>\n

System.out.println(“B’s implementation of callme.”);<\/p>\n

}<\/p>\n

}<\/p>\n

class AbstractDemo {<\/p>\n

public static void main(String args[]) {<\/p>\n

B b = new B();<\/p>\n

b.callme();<\/p>\n

b.callmetoo();<\/p>\n

}<\/p>\n

}<\/p>\n

Notice that no objects of class A <\/strong>are declared in the program. As mentioned, it is not possible to instantiate an abstract class. One other point: class A <\/strong>implements a concrete method called callmetoo( )<\/strong>. This is perfectly acceptable. Abstract classes can include as much implementation as they see fit. Although abstract classes cannot be used to instantiate objects, they can be used to create object references, because Java\u2019s approach to run-time polymorphism is implemented through the use of superclass references. Thus, it must be possible to create a reference to an abstract class so that it can be used to point to a subclass object. For example:<\/p>\n

 <\/p>\n

\/\/ Using abstract methods and classes.<\/p>\n

abstract class Figure {<\/p>\n

double dim1;<\/p>\n

double dim2;<\/p>\n

Figure(double a, double b) {<\/p>\n

dim1 = a;<\/p>\n

dim2 = b;<\/p>\n

}<\/p>\n

\/\/ area is now an abstract method<\/p>\n

abstract double area();<\/p>\n

}<\/p>\n

class Rectangle extends Figure {<\/p>\n

Rectangle(double a, double b) {<\/p>\n

super(a, b);<\/p>\n

}<\/p>\n

\/\/ override area for rectangle<\/p>\n

double area() {<\/p>\n

System.out.println(“Inside Area for Rectangle.”);<\/p>\n

return dim1 * dim2;<\/p>\n

}<\/p>\n

}<\/p>\n

class Triangle extends Figure {<\/p>\n

Triangle(double a, double b) {<\/p>\n

super(a, b);<\/p>\n

}<\/p>\n

\/\/ override area for right triangle<\/p>\n

double area() {<\/p>\n

System.out.println(“Inside Area for Triangle.”);<\/p>\n

return dim1 * dim2 \/ 2;<\/p>\n

}<\/p>\n

}<\/p>\n

class AbstractAreas {<\/p>\n

public static void main(String args[]) {<\/p>\n

\/\/ Figure f = new Figure(10, 10); \/\/ illegal now<\/p>\n

Rectangle r = new Rectangle(9, 5);<\/p>\n

Triangle t = new Triangle(10, 8);<\/p>\n

THE JAVA LANGUAGE<\/p>\n

Figure figref; \/\/ this is OK, no object is created<\/p>\n

figref = r;<\/p>\n

System.out.println(“Area is ” + figref.area());<\/p>\n

figref = t;<\/p>\n

System.out.println(“Area is ” + figref.area());<\/p>\n

}<\/p>\n

}<\/p>\n

 <\/p>\n

As the comment inside main( ) <\/strong>indicates, it is no longer possible to declare objects of type Figure<\/strong>, since it is now abstract. And, all subclasses of Figure <\/strong>must override area( )<\/strong>. Although it is not possible to create an object of type Figure<\/strong>, you can create a reference variable of type Figure<\/strong>. The variable figref <\/strong>is declared as a reference to Figure<\/strong>, which means that it can be used to refer to an object of any class derived from Figure<\/strong>.<\/p>\n

 <\/p>\n

<\/a>Using final to Prevent Overriding<\/strong><\/h2>\n

While method overriding is one of Java\u2019s most powerful features, there will be times when you will want to prevent it from occurring. To disallow a method from being overridden, specify final <\/strong>as a modifier at the start of its declaration. Methods declared as final <\/strong>cannot be overridden. The following fragment illustrates final<\/strong>:<\/p>\n

 <\/p>\n

class A {<\/p>\n

final void meth() {<\/p>\n

System.out.println(“This is a final method.”);<\/p>\n

}<\/p>\n

}<\/p>\n

class B extends A {<\/p>\n

void meth() { \/\/ ERROR! Can’t override.<\/p>\n

System.out.println(“Illegal!”);<\/p>\n

}<\/p>\n

}<\/p>\n

Because meth( ) <\/strong>is declared as final<\/strong>, it cannot be overridden in B<\/strong>. If you attempt to do so, a compile-time error will result. Normally, Java resolves calls to methods dynamically, at run time. This is called late binding. <\/em>However, since final <\/strong>methods cannot be overridden, a call to one can be resolved at compile time. This is called early binding.<\/em><\/p>\n

 <\/p>\n

<\/a>Using final to Prevent Inheritance<\/strong><\/h2>\n

Sometimes you will want to prevent a class from being inherited. To do this, precede the class declaration with final<\/strong>. Declaring a class as final <\/strong>implicitly declares all of its methods as final<\/strong>. As you might expect, it is illegal to declare a class as both abstract <\/strong>and final <\/strong>since an abstract class is incomplete by itself and relies upon its subclasses to provide complete implementations. Here is an example of a final <\/strong>class:<\/p>\n

 <\/p>\n

final class A {<\/p>\n

\/\/ …<\/p>\n

}<\/p>\n

\/\/ The following class is illegal.<\/p>\n

class B extends A { \/\/ ERROR! Can’t subclass A<\/p>\n

\/\/ …<\/p>\n

}<\/p>\n

 <\/p>\n

As the comments imply, it is illegal for B <\/strong>to inherit A <\/strong>since A <\/strong>is declared as final<\/strong>.<\/p>\n

 <\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

Inheritance   Inheritance is one of the foundations of object-oriented programming because it allows the creation of hierarchical classifications. Using inheritance, you can create a general class that defines behavior… <\/p>\n","protected":false},"author":1,"featured_media":3468,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[83],"tags":[],"aioseo_notices":[],"amp_enabled":true,"_links":{"self":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3446"}],"collection":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/comments?post=3446"}],"version-history":[{"count":2,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3446\/revisions"}],"predecessor-version":[{"id":3485,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/posts\/3446\/revisions\/3485"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media\/3468"}],"wp:attachment":[{"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/media?parent=3446"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/categories?post=3446"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/softlect.com\/index.php\/wp-json\/wp\/v2\/tags?post=3446"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}