{"id":6551,"date":"2024-04-21T23:54:04","date_gmt":"2024-04-22T06:54:04","guid":{"rendered":"https:\/\/zentut.com\/java-tutorial\/java-inheritance\/"},"modified":"2024-04-21T23:54:32","modified_gmt":"2024-04-22T06:54:32","slug":"java-inheritance","status":"publish","type":"page","link":"https:\/\/www.zentut.com\/java-tutorial\/java-inheritance\/","title":{"rendered":"Java Inheritance"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn about Java inheritance and how to utilize it to create a class that inherits the fields and methods from an existing class.<\/p>\n\n\n\n

Introduction to Java inheritance<\/h2>\n\n\n\n

Inheritance allows you to define a new class<\/a> based on an existing class. The new class will inherit the fields and methods of the existing class. <\/p>\n\n\n\n

To define a class that inherits from an existing class, you use the extends<\/code> keyword:<\/p>\n\n\n

class<\/span> Superclass<\/span><\/span>{\n   \/\/ ...<\/span>\n}\nclass<\/span> Subclass<\/span> extends<\/span> Superclass<\/span> <\/span>{\n  \/\/ ...<\/span>\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, the subclass inherits the fields and method of the superclass. The subclass may also have its own fields and methods.<\/p>\n\n\n\n
The subclass and superclass are also known as the derived class and base class respectively.<\/p>\n\n\n\n
The relationship between the subclass and superclass is an “is-a” relationship.<\/p>\n\n\n\n
Java allows a class to inherit from a single class, which is referenced to as a single inheritance<\/strong>. It doesn’t support multiple inheritance<\/strong>, where a class can inherit from multiple classes.<\/p>\n\n\n\n
Java inheritance example<\/h2>\n\n\n\n
Suppose you have an existing class called Person<\/code> as follows:<\/p>\n\n\n
\/\/ Person.java<\/span>\nclass<\/span> Person<\/span> <\/span>{\n    public<\/span> String name;\n\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\"Hi, I'm %s. \"<\/span>, name);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows how to define an Employee<\/code> class that extends the Person<\/code> class:<\/p>\n\n\n
\/\/ Employee.java<\/span>\nclass<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Because the Employee<\/code> class inherits from the Person<\/code> class, it is a Person<\/code> class. It means that you can use the Employee<\/code> class like a Person<\/code> class. <\/p>\n\n\n\n
For example, you can create a new Employee<\/code> object, set the name, and call the sayHi<\/code> method:<\/p>\n\n\n
\/\/ App.java<\/span>\npublic<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        var<\/span> e = new<\/span> Employee();\n        e.name = \"John\"<\/span>;\n        System.out.println(e.sayHi());\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi, I'm John.<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the Employee<\/code> class doesn’t contain any specific code. But it can reuse the code from the Person<\/code> class. <\/p>\n\n\n\n
protected access modifier<\/h2>\n\n\n\n
In the Person<\/code> class, the name field is a public field that can be accessible from any part of the application including the Employee<\/code> class.<\/p>\n\n\n\n
The following changes the access modifier of the name<\/code> field from public<\/code> to private<\/code>:<\/p>\n\n\n
class<\/span> Person<\/span> <\/span>{\n    private<\/span> String name;\n\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\"Hi, I'm %s. \"<\/span>, name);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Because of the private<\/code> access modifier, the name<\/code> field is not accessible outside of the Person<\/code> class anymore. Therefore, the following code will not compile:<\/p>\n\n\n
public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        var<\/span> e = new<\/span> Employee();\n        e.name = \"John\"<\/span>; \/\/ error<\/span>\n        System.out.println(e.sayHi());\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
To allow a subclass to access the fields and methods of the superclass, you need to use the protected<\/code> access modifier.<\/p>\n\n\n\n
For example, the following changes the access modifier of the name<\/code> field in the Person<\/code> class to protected<\/code>:<\/p>\n\n\n
class<\/span> Person<\/span> <\/span>{\n    protected<\/span> String name;\n\n    public<\/span> void<\/span> sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\"Hi, I'm %s. \"<\/span>, name);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, the Employee<\/code> class can access the name<\/code> field.<\/p>\n\n\n\n
Adding fields to subclass<\/h2>\n\n\n\n
Besides fields and methods inherited from the Person<\/code> class, the Employee<\/code> class can have its own fields and methods.<\/p>\n\n\n\n
For example, the following add the job title field to the Employee<\/code> class:<\/p>\n\n\n
class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    public<\/span> String jobTitle;\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
The Employee<\/code> class now has two fields: <\/p>\n\n\n\n
    \n
  • name<\/code>: This field is inherited from the Person<\/code> class.<\/li>\n\n\n\n
  • jobTitle<\/code>: This is its own field.<\/li>\n<\/ul>\n\n\n\n
    The following shows how to create an instance of the Employee<\/code> class, assign values to the name<\/code> and jobTitle<\/code> fields, and call the sayHi()<\/code> method:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        var<\/span> e = new<\/span> Employee();\n        e.name = \"John\"<\/span>;\n        e.jobTitle = \"Java Developer\"<\/span>;\n        System.out.println(e.sayHi());\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Hi, I'm John.<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The sayHi()<\/code> method shows only the name. What if we want to display the job title? To do that we can override the sayHi()<\/code> method in the Employee<\/code> class.<\/p>\n\n\n\n
    Overriding methods<\/h2>\n\n\n\n
    Method overriding allows a subclass to provide a specific implementation for a method defined in its superclass. <\/p>\n\n\n\n
    To override a method, you use the same method signature of the method in the superclass.<\/p>\n\n\n\n
    For example, the following illustrates how to define the sayHi()<\/code> method in the Employee<\/code> class that overrides the sayHi()<\/code> method in the Person<\/code> class:<\/p>\n\n\n
    class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    public<\/span> String jobTitle;\n\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\"Hi, I'm %s. I'm a %s.\"<\/span>,\n                name,\n                jobTitle\n        );\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    If you call the sayHi()<\/code> method using the Employee<\/code> object, the sayHi()<\/code> method in the Employee<\/code> class will execute instead of the one defined in the Person<\/code> class:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        var<\/span> e = new<\/span> Employee();\n        e.name = \"John\"<\/span>;\n        e.jobTitle = \"Java Developer\"<\/span>;\n\n        System.out.println(e.sayHi());\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Hi, I'm John. I'<\/span>m a Java Developer.<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    When overriding a method, you use the @Override<\/code> annotation to explicitly tell the Java compiler your intent:<\/p>\n\n\n
    class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    public<\/span> String jobTitle;\n\n    @Override<\/span>\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\n                \"%sI'm a %s.\"<\/span>,\n                super<\/span>.sayHi(),\n                jobTitle\n        );\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The Java compiler will issue an error if you use @Override<\/code> but use a different method signature from the parent class.<\/p>\n\n\n\n
    For example, if you add a parameter to the sayHi()<\/code> method and attempt to build it, you’ll get an error:<\/p>\n\n\n
    class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    public<\/span> String jobTitle;\n\n    @Override<\/span>\n    public<\/span> String sayHi<\/span>(int<\/span> volume)<\/span> <\/span>{\n        return<\/span> String.format(\n                \"%sI'm a %s.\"<\/span>,\n                super<\/span>.sayHi(),\n                jobTitle\n        );\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Error:<\/p>\n\n\n
    java: method does not override or implement a method from a supertype<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Java super keyword<\/h2>\n\n\n\n
    The super<\/code> keyword allows you to access the members of the superclass within the subclass.<\/p>\n\n\n\n
    You can use the super<\/code> keyword to access superclass fields, call the superclass methods, or invoke the superclass constructors.<\/p>\n\n\n\n
    Calling superclass method<\/h3>\n\n\n\n
    For example, the following shows how to use the super keyword to call the sayHi()<\/code> method of the Person<\/code> class in the sayHi()<\/code> method of the Employee<\/code> class:<\/p>\n\n\n
    class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    private<\/span> String jobTitle;\n\n    @Override<\/span>\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\n                \"%sI'm a %s.\"<\/span>,\n                super<\/span>.sayHi(),\n                jobTitle\n        );\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    The program shows the same output as before. But the sayHi()<\/code> method in the Employee<\/code> can reuse the logic implemented by the sayHi()<\/code> method of the Person<\/code> class.<\/p>\n\n\n\n
    Invoking the superclass constructor<\/h3>\n\n\n\n
    When you define a subclass, it automatically inherits all the constructors of the superclass. To call a constructor of a superclass, you use the super()<\/code> keyword. For example:<\/p>\n\n\n\n
    First, add a constructor that accepts a parameter name to the Person<\/code> class:<\/p>\n\n\n
    class<\/span> Person<\/span> <\/span>{\n    protected<\/span> String name;\n\n    public<\/span> Person<\/span>(String name)<\/span><\/span>{\n        this<\/span>.name = name;\n    }\n    \n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\"Hi, I'm %s. \"<\/span>, name);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Second, change the jobTitle<\/code> field in the Employee<\/code> class to private and add a constructor to the Employee<\/code> class that accepts two parameters name<\/code> and jobTitle<\/code>:<\/p>\n\n\n
    class<\/span> Employee<\/span> extends<\/span> Person<\/span> <\/span>{\n    private<\/span> String jobTitle;\n\n    public<\/span> Employee<\/span>(String name, String jobTitle)<\/span> <\/span>{\n        super<\/span>(name);\n        this<\/span>.jobTitle = jobTitle;\n    }\n\n    @Override<\/span>\n    public<\/span> String sayHi<\/span>()<\/span> <\/span>{\n        return<\/span> String.format(\n                \"%sI'm a %s.\"<\/span>,\n                super<\/span>.sayHi(),\n                jobTitle\n        );\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the Employee<\/code> constructor, we use the super<\/code> to call the Person<\/code> constructor and assign the jobTitle<\/code> argument to the jobTitle<\/code> field.<\/p>\n\n\n\n
    Third, modify the program to create a new instance of Employee<\/code> using the name<\/code> and jobTitle<\/code> arguments:<\/p>\n\n\n
    public<\/span> class<\/span> App<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        var<\/span> e = new<\/span> Employee(\"John\"<\/span>, \"Java Developer\"<\/span>);\n        System.out.println(e.sayHi());\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Hi, I'm John. I'<\/span>m a Java Developer<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • Java inheritance allows a subclass to inherit the properties and behaviors of a superclass.<\/li>\n\n\n\n
    • Use the extends<\/code> keyword to define a subclass.<\/li>\n\n\n\n
    • Use the protected<\/code> access modifier to allow the subclass to access fields and methods of the superclass.<\/li>\n\n\n\n
    • A subclass can override a method in the superclass by providing a specific implementation.<\/li>\n\n\n\n
    • Use the super<\/code> keyword to access superclass fields, call superclass methods, or invoke superclass constructors in the subclass.<\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"
      Summary: in this tutorial, you will learn about Java inheritance and how to utilize it to create a class that inherits the fields and methods from an existing class. Introduction to Java inheritance Inheritance allows you to define a new class based on an existing class. The new class will inherit the fields and methods […]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":2190,"menu_order":36,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-6551","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6551","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/comments?post=6551"}],"version-history":[{"count":2,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6551\/revisions"}],"predecessor-version":[{"id":6553,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/6551\/revisions\/6553"}],"up":[{"embeddable":true,"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/pages\/2190"}],"wp:attachment":[{"href":"https:\/\/www.zentut.com\/wp-json\/wp\/v2\/media?parent=6551"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
The Person class has a public<\/a> field name<\/code> and a method sayHi()<\/code>. <\/p>\n\n\n\n