{"id":88586,"date":"2023-10-13T19:00:35","date_gmt":"2023-10-13T13:30:35","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=88586"},"modified":"2023-10-13T19:00:35","modified_gmt":"2023-10-13T13:30:35","slug":"java-super-keyword","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/","title":{"rendered":"Java Super Keyword"},"content":{"rendered":"

The super keyword provides a way to access members and methods of the superclass from within the subclass, allowing you to create and manage inheritance relationships effectively. The super keyword plays a crucial role in object-oriented programming, where classes are organized in a hierarchy to promote code reuse and specialization.<\/p>\n

Super keyword<\/h2>\n

The super keyword is used to refer to the superclass (parent class) of a subclass (child class). It allows you to access or invoke members (variables, methods, and constructors) of the superclass from within the subclass. The super keyword is essential for maintaining the inheritance hierarchy, overriding methods, and managing the relationship between classes. It helps in avoiding naming conflicts, extending behaviour, and promoting code reuse.<\/p>\n

Characteristics of super Keyword:<\/h3>\n

Constructors Invocation:<\/strong> When creating a subclass, its constructor must invoke the constructor of its parent class using “super()”. This ensures proper initialization of the superclass’s state.<\/p>\n

Method Invocation:<\/strong> A subclass can use “super” to call a method defined in its parent class. This is helpful when the subclass desires to include the parent class’s method implementation along with its own.<\/p>\n

Field Access:<\/strong> Access to a parent class’s field is feasible via “super”. This enables the subclass to access the parent class’s version of a field.<\/p>\n

Constructor Order:<\/strong> In a constructor of the subclass, the “super()” statement must be the foremost one when invoking a superclass constructor.<\/p>\n

Static Context Limitation:<\/strong> The use of “super” is disallowed within a static context, like a static method or a static variable initializer.<\/p>\n

Optional for Method Invocation:<\/strong> While “super” can be employed to call a parent class method, it is not obligatory. When a method is not overridden in the subclass, invoking it without “super” will engage the parent class’s implementation.<\/p>\n

Key advantages of using the super keyword:<\/h3>\n

Method Overriding:<\/strong> The super keyword enables precise control over method overriding. It allows a subclass to invoke the overridden method of the superclass, facilitating the extension of behaviour while preserving the original functionality.<\/p>\n

Avoiding Naming Conflicts:<\/strong> When a subclass and superclass have members (variables or methods) with the same name, the super keyword allows you to explicitly refer to the superclass version, avoiding ambiguity and ensuring proper access to intended members.<\/p>\n

Initialization Sequence:<\/strong> In the constructor chaining process, the super keyword allows the subclass constructor to invoke a specific constructor of the superclass, ensuring proper initialization of superclass-specific properties before subclass properties are initialized.<\/p>\n

Accessing Superclass Resources:<\/strong> By using the super keyword, you can access and leverage resources (variables, methods, or constructors) of the superclass, promoting code reuse and reducing redundancy.<\/p>\n

Managing Inheritance Hierarchies:<\/strong> The super keyword maintains the relationship between subclasses and superclasses, contributing to the coherent organization of class hierarchies and enhancing code clarity.<\/p>\n

Explicit Invocation:<\/strong> The super keyword provides explicitness when invoking superclass members, making code more self-explanatory and reducing the chance of unintended behaviour.<\/p>\n

Polymorphism and Dynamic Dispatch:<\/strong> In polymorphic scenarios, the super keyword contributes to dynamic method dispatch, allowing the appropriate version of a method to be executed based on the runtime object type.<\/p>\n

Enforcing Design Patterns:<\/strong> The super keyword supports design patterns such as the Template Method and Factory Method, where subclasses need to interact with or override specific parts of the superclass behaviour.<\/p>\n

Code Maintenance and Readability:<\/strong> Proper use of the super keyword enhances the maintainability and readability of code by providing clear indications of superclass interactions and intentions.<\/p>\n

1. Accessing Superclass Members:<\/h4>\n

This is especially useful when a subclass has members with the same name as those in the superclass. By using super, you can explicitly refer to the superclass version of the member.<\/p>\n

\"Accessing<\/a><\/p>\n

Example Program:<\/strong><\/p>\n

class Vehicle {\n    String type = \"Generic Vehicle\";\n    void displayType() {\n        System.out.println(\"Type: \" + type);\n    }\n}\nclass Car extends Vehicle {\n    String type = \"Car\";\n    void displayType() {\n        System.out.println(\"Subclass Type: \" + type);         \/\/ Accessing subclass variable\n        System.out.println(\"Superclass Type: \" + super.type); \/\/ Accessing superclass variable\n    }\n    void showTypes() {\n        displayType();  \/\/ Calls the overridden method in Car class\n        super.displayType();  \/\/ Calls the method from the superclass\n    }\n}\nclass  TechVidvan{\n    public static void main(String[] args) {\n        Car car = new Car();\n        car.displayType();\n        System.out.println(\"\\nUsing showTypes:\");\n        car.showTypes();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Subclass Type:<\/strong> Car
\nSuperclass Type:<\/strong> Generic Vehicle<\/p>\n
Using show types:
\nSubclass Type:<\/strong> Car
\nSuperclass Type:<\/strong> Generic Vehicle
\nType:<\/strong> Generic Vehicle<\/p>\n
Explanation:<\/strong><\/p>\n
This code defines a Vehicle class with a type and a method to display it, and a Car subclass that overrides the method to differentiate between the subclass and superclass types.<\/p>\n
The main method demonstrates accessing and displaying these types using the super keyword.<\/p>\n
2. Method Overriding with super keyword:<\/h4>\n
In an overridden method of the subclass, you can use the super keyword to call the superclass version of the method. This allows you to extend the behaviour of the superclass method while still utilizing its original implementation.<\/p>\n
\"Method<\/a><\/p>\n
Example Program:<\/strong><\/p>\n
class Parent {\n    String message = \"Hello from Parent\";\n    void display() {\n        System.out.println(message);\n    }\n}\nclass Child extends Parent {\n    String message = \"Hello from Child\";\n    void display() {\n        super.display();  \/\/ Invoking the parent class method\n        System.out.println(message);\n    }\n}\nclass TechVidvan{\n    public static void main(String[] args) {\n        Child child = new Child();\n        child.display();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Hello from Parent
\nHello from Child<\/p>\n
Explanation:<\/strong><\/p>\n
The Parent class has a member variable message and a method display that prints the message.The Child class extends the Parent and overrides the display method.<\/p>\n
It uses the super.display() call to invoke the display method from the parent class before adding its own message.In the TechVidvan class, an object of the Child class is created, and its display method is called.<\/p>\n
3. Accessing super class Attributes:<\/h4>\n
class Animal {\n    String name;\n    Animal(String name) {\n        this.name = name;\n    }\n    void makeSound() {\n        System.out.println(name + \" makes a sound\");\n    }\n}\nclass Dog extends Animal {\n    String name;\n    Dog(String name) {\n        super(name);  \/\/ Invoking superclass constructor\n        this.name = \"Dog: \" + name;\n    }\n    @Override\n    void makeSound() {\n        super.makeSound();  \/\/ Call superclass method\n        System.out.println(name + \" barks\");\n    }\n}\nclass TechVidvan{\n    public static void main(String[] args) {\n        Dog dog = new Dog(\"Buddy\");\n        dog.makeSound();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Buddy makes a sound
\nDog:<\/strong> Buddy barks<\/p>\n
Explanation:<\/strong><\/p>\n
The Animal class has a member variable name, a constructor to set the name, and a method makeSound to display the sound of the animal. The Dog class extends Animal and overrides the makeSound method.<\/p>\n
It also defines its own version of the name variable and constructor that utilizes the super keyword to call the superclass constructor.<\/p>\n
In the TechVidvan class, an object of the Dog class is created with the name “Buddy,” and the makeSound method is called.<\/p>\n
4. Invoking Superclass No-argument Constructor:<\/h4>\n
When creating an object of a subclass, the constructor of the superclass is implicitly called. You can use the super keyword to invoke a specific constructor of the superclass, particularly if the superclass constructor requires arguments.<\/p>\n
Example Code:<\/strong><\/p>\n
class Animal {\n    String species;\n    Animal() {\n        species = \"Unknown\";\n        System.out.println(\"Animal no-arg constructor invoked\");\n    }\n    void display() {\n        System.out.println(\"Species: \" + species);\n    }\n}\nclass Dog extends Animal {\n    String breed;\n    Dog(String breed) {\n        super(); \/\/ Calling the no-arg constructor of the superclass\n        this.breed = breed;\n        System.out.println(\"Dog constructor invoked\");\n    }\n    void displayBreed() {\n        System.out.println(\"Breed: \" + breed);\n    }\n}\nclass TechVidvan{\n    public static void main(String[] args) {\n        Dog dog = new Dog(\"Golden Retriever\");\n        dog.display();\n        dog.displayBreed();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Animal no-arg constructor invoked
\nDog constructor invoked
\nSpecies:<\/strong> Unknown
\nBreed:<\/strong> Golden Retriever<\/p>\n
Explanation:<\/strong><\/p>\n
The Animal class has a no-argument constructor that initializes the species to “Unknown” and prints a message when the constructor is invoked.<\/p>\n
The Dog class extends Animal and has its own constructor that takes a breed parameter. It uses the super() call to invoke the no-argument constructor of the Animal superclass.<\/p>\n
The display method in the Animal class prints the species, and the displayBreed method in the Dog class prints the breed.<\/p>\n
In the TechVidvan class, an object of the Dog class is created with the breed “Golden Retriever,” and then the display and displayBreed methods are called.<\/p>\n
5. Invoking Superclass Parametarized Constructor:<\/h4>\n
class Person {\n    String name;\n    Person(String name) {\n        this.name = name;\n        System.out.println(\"Person constructor invoked\");\n    }\n}\nclass Student extends Person {\n    int rollNumber;\n    Student(String name, int rollNumber) {\n        super(name);  \/\/ Invoking superclass constructor\n        this.rollNumber = rollNumber;\n        System.out.println(\"Student constructor invoked\");\n    }\n    void display() {\n        System.out.println(\"Name: \" + name);\n        System.out.println(\"Roll Number: \" + rollNumber);\n    }\n}\nclass TechVidvan{\n    public static void main(String[] args) {\n        Student student = new Student(\"Alice\", 123);\n        student.display();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Person constructor invoked
\nStudent constructor invoked
\nName:<\/strong> Alice
\nRoll Number:<\/strong> 123<\/p>\n
Explanation:<\/strong><\/p>\n
The Person class has a constructor that takes a name parameter. It initializes the name and prints a message when the constructor is invoked.<\/p>\n
The Student class extends Person and has its own constructor that takes both name and rollNumber parameters. It uses the super keyword to invoke the Person constructor to set the name.<\/p>\n
The display method in the Student class prints the name and rollNumber of the student.<\/p>\n
In TechVidvan, an object of the Student class is created with the name “Alice” and roll number 123, and then the display method is called.<\/p>\n
Automatic super() provided by compiler:<\/h3>\n
If you don’t provide any constructors in your class, the compiler will automatically generate a default constructor which has a super().<\/p>\n
This ensures that the superclass is properly initialized before the subclass. This behavior is especially important when you consider that every class implicitly extends the Object class.<\/p>\n
If a constructor in a subclass does not have a super(…) or this(…) call, it is assumed to contain an implicit super() call at the beginning.<\/p>\n
\"Automatic<\/a><\/p>\n
Example Code:<\/strong><\/p>\n
class Animal {\n    Animal() {\n        System.out.println(\"Animal constructor\");\n    }\n}\nclass Dog extends Animal {\n    Dog(){\n    \/\/ Compiler will insert an implicit super() call here\n        System.out.println(\"Dog constructor\");\n    }\n}\nclass TechVidvan{\n    public static void main(String[] args) {\n        Dog dog = new Dog();\n    }\n}<\/pre>\n
Output:<\/strong><\/p>\n
Animal constructor
\nDog constructor<\/p>\n
Summary<\/h3>\n
In summary, the super keyword promotes proper encapsulation, code organization, and extensibility in object-oriented programming by enabling seamless integration between subclasses and their superclasses in Java.<\/p>\n","protected":false},"excerpt":{"rendered":"
The super keyword provides a way to access members and methods of the superclass from within the subclass, allowing you to create and manage inheritance relationships effectively. The super keyword plays a crucial role...<\/p>\n","protected":false},"author":1,"featured_media":88678,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[183],"tags":[296,5211,5212,5213],"class_list":["post-88586","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java","tag-java-super-keyword","tag-super-keyword","tag-super-keyword-in-java"],"yoast_head":"\nJava Super Keyword - TechVidvan<\/title>\n<meta name=\"description\" content=\"The Java Super Keyword is essential for maintaining the inheritance hierarchy and managing the relationship between classes.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java Super Keyword - TechVidvan\" \/>\n<meta property=\"og:description\" content=\"The Java Super Keyword is essential for maintaining the inheritance hierarchy and managing the relationship between classes.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/\" \/>\n<meta property=\"og:site_name\" content=\"TechVidvan\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/TechVidvan\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-10-13T13:30:35+00:00\" \/>\n<meta name=\"author\" content=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:site\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Java Super Keyword - TechVidvan","description":"The Java Super Keyword is essential for maintaining the inheritance hierarchy and managing the relationship between classes.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/","og_locale":"en_US","og_type":"article","og_title":"Java Super Keyword - TechVidvan","og_description":"The Java Super Keyword is essential for maintaining the inheritance hierarchy and managing the relationship between classes.","og_url":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/","og_site_name":"TechVidvan","article_publisher":"https:\/\/www.facebook.com\/TechVidvan\/","article_published_time":"2023-10-13T13:30:35+00:00","author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@vidvantech","twitter_site":"@vidvantech","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#article","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22"},"headline":"Java Super Keyword","datePublished":"2023-10-13T13:30:35+00:00","mainEntityOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/"},"wordCount":1260,"commentCount":0,"publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#primaryimage"},"thumbnailUrl":"","keywords":["java","java super keyword","super keyword","super keyword in java"],"articleSection":["Java Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/","url":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/","name":"Java Super Keyword - TechVidvan","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/#website"},"primaryImageOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#primaryimage"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#primaryimage"},"thumbnailUrl":"","datePublished":"2023-10-13T13:30:35+00:00","description":"The Java Super Keyword is essential for maintaining the inheritance hierarchy and managing the relationship between classes.","breadcrumb":{"@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#primaryimage","url":"","contentUrl":""},{"@type":"BreadcrumbList","@id":"https:\/\/techvidvan.com\/tutorials\/java-super-keyword\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/techvidvan.com\/tutorials\/"},{"@type":"ListItem","position":2,"name":"Java Super Keyword"}]},{"@type":"WebSite","@id":"https:\/\/techvidvan.com\/tutorials\/#website","url":"https:\/\/techvidvan.com\/tutorials\/","name":"TechVidvan Blogs","description":"","publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/techvidvan.com\/tutorials\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/techvidvan.com\/tutorials\/#organization","name":"TechVidvan","url":"https:\/\/techvidvan.com\/tutorials\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","width":200,"height":50,"caption":"TechVidvan"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/TechVidvan\/","https:\/\/x.com\/vidvantech"]},{"@type":"Person","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22","name":"TechVidvan Team","description":"The TechVidvan Team delivers practical, beginner-friendly tutorials on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our experts are here to help you upskill and excel in today\u2019s tech industry."}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/88586","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/comments?post=88586"}],"version-history":[{"count":0,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/88586\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/"}],"wp:attachment":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media?parent=88586"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/categories?post=88586"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/tags?post=88586"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}