Inheritance simply defined as the behaviour and character that the subclass or the child class gets itself by default from the parent class which makes the software reusability.
\nUsing inheritance, you can create a general class that defines traits 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. The class that does the inheriting is called a subclass. Therefore, a subclass is a specialized version of a superclass. It inherits all of the instance variables and methods defined by the superclass and adds its own, unique elements.<\/p>\n
Inheritance Basics<\/strong><\/p>\n To inherit a class, you simply incorporate the definition of one class into another by using the extends keyword. To see how to let\u2019s begin with a short example. The following program creates a superclass called A and a subclass called B. \/\/ A simple example of inheritance. Example of the simple inheritance.<\/strong> The output from this program is shown here: As you can see, the subclass B includes all of the members of its superclass, A. This is why subOb can access i and j and call showij( ). Also, inside sum( ), i and j can be referred to directly, as if they were part of B. Even though A is a superclass for B, 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.<\/p>\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. For example, consider the following simple class hierarchy: You may also like garbage collection<\/a><\/p>\n
\nNotice how the keyword extends is used to create a subclass of A.<\/p>\n
\n\/\/ Create a superclass.
\nPublic class A {
\nint i, j;
\nvoid showij() {
\nSystem.out.println(“i and j: ” + i + ” ” + j);
\n}
\n}
\n\/\/ Create a subclass by extending class A.
\nclass B extends A {
\nint k;
\nvoid showk() {
\nSystem.out.println(“k: ” + k);
\n}
\nvoid sum() {
\nSystem.out.println(“i+j+k: ” + (i+j+k));
\n}
\n}<\/p>\n
\nPublic class SimpleInheritance {
\npublic static void main(String args[]) {
\nA superOb = new A();
\nB subOb = new B();
\n\/\/ The superclass may be used by itself.
\nsuperOb.i = 10;
\nsuperOb.j = 20;
\nSystem.out.println(“Contents of superOb: “);
\nsuperOb.showij();
\nSystem.out.println();
\n\/* The subclass has access to all public members of
\nits superclass. *\/
\nsubOb.i = 7;
\nsubOb.j = 8;
\nsubOb.k = 9;
\nSystem.out.println(“Contents of subOb: “);
\nsubOb.showij();
\nsubOb.showk();
\nSystem.out.println();
\nSystem.out.println(“Sum of i, j and k in subOb:”);
\nsubOb.sum();
\n}
\n}<\/p>\n
\nContents of superOb:
\ni and j: 10 20
\nContents of subOb:
\ni and j: 7 8
\nk: 9
\nSum of i, j and k in subOb:
\ni+j+k: 24<\/p>\nMember Access and Inheritance<\/h2>\n
\n\/* In a class hierarchy, private members remain private to their class. This program contains an error and will not compile. *\/
\n\/\/ Create a superclass.
\nclass A {
\nint i; \/\/ public by default
\nprivate int j; \/\/ private to A
\nvoid setij(int x, int y) {
\ni = x;
\nj = y;
\n}
\n}
\n\/\/ A’s j is not accessible here.
\nclass B extends A {
\nint total;
\nvoid sum() {
\ntotal = i + j; \/\/ ERROR, j is not accessible here
\n}
\n}
\nclass Access {
\npublic static void main(String args[]) {
\nB subOb = new B();
\nsubOb.setij(10, 12);
\nsubOb.sum();
\nSystem.out.println(“Total is ” + subOb.total);
\n}
\n}
\nThis program will not compile because the reference to j inside the sum( ) method of B causes an access violation. Since j is declared as private, it is only accessible by other members of its own class. Subclasses have no access to it.<\/p>\n