Super Keyword in Java

 

🔹 super Keyword in Java

The super keyword is used in a subclass to refer to members (variables or methods) of its immediate superclass.

✅ Uses of super:

  1. Access superclass constructor

  2. Access superclass methods

  3. Access superclass variables

1. Using super() to Call Superclass Constructor

By default, when a subclass constructor is called, it implicitly calls the no-argument constructor of the superclass using super().


class Animal {
    Animal() {
        System.out.println("Animal constructor called");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // optional here, Java adds it automatically
        System.out.println("Dog constructor called");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
    }
}

Output:


Animal constructor called
Dog constructor called

2. Using super to Access Superclass Method


class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        super.sound(); // calling superclass method
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound();
    }
}

3. Using super to Access Superclass Variable


class Animal {
    String name = "Animal";
}

class Dog extends Animal {
    String name = "Dog";

    void printNames() {
        System.out.println(name);         // Dog
        System.out.println(super.name);   // Animal
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.printNames();
    }
}

🔹 Order of Constructor Calls in Inheritance

In Java, when a subclass object is created:

  1. Superclass constructor is called first

  2. Then the subclass constructor is called

This ensures that the parent part of the object is initialized before the child part.

📌 Example:


class A {
    A() {
        System.out.println("Constructor of A");
    }
}

class B extends A {
    B() {
        System.out.println("Constructor of B");
    }
}

class C extends B {
    C() {
        System.out.println("Constructor of C");
    }
}

public class Main {
    public static void main(String[] args) {
        C obj = new C();
    }
}

Output:


Constructor of A
Constructor of B
Constructor of C

✅ Even though we only created an object of class C, constructors of B and A are called first, in that order.

📌 Summary

ConceptDescription
super()Calls the immediate superclass constructor. Must be the first statement in subclass constructor.
super.method()Calls a method from the superclass.
super.variableAccesses a variable from the superclass (if hidden by subclass variable).
Constructor Call OrderParent constructor → Child constructor

Comments

Post a Comment

Popular posts from this blog

Object Oriented Programming PBCST304 KTU BTech CS Semester 3 2024 Scheme - Dr Binu V P

 About Me Course Details and Syllabus This course is a Project Based Learning  ( PBL) Course - know more PBCST304 Object Oriented Programming Model Question Paper and Answers Programs to Try Module-1  Introduction to Java Introduction - basic Java Program Java Compiler and Java Virtual Machine Java Command line and IDE Primitive data types and wrapper classes-autoboxing and unboxing Type casting Operators in Java Operator Precedence Control Statements in Java Example Programs using control statements Arrays in Java Strings in Java Vectors in Java ArrayList in Java Functions in Java Recursive Functions in Java Command Line arguments and Variable length arguments OOPs concept Procedural and Object Oriented Programming Paradigms Classes , objects and constructor in Java Access Modifiers in Java this keyword in Java Data Abstraction and Encapsulation Inheritance and Polymorphism Module-2 Method overloading in Java Object as parameters and Returning Objects Static members Fina...
Read more

Introduction to Java Programming

  🔰 Introduction to Java Programming Java is a high-level, object-oriented programming language developed by Sun Microsystems (now owned by Oracle Corporation ). It is widely used for building applications across platforms — from desktop to mobile to enterprise systems. ✨ Key Features of Java: Platform Independent : "Write once, run anywhere" — Java code runs on any device with the Java Virtual Machine (JVM). Object-Oriented : Everything in Java is an object; this promotes reusability and modularity. Simple and Familiar : Syntax is similar to C/C++, making it easier for students with prior programming exposure. Secure : Java includes built-in security features like bytecode verification. Robust : Strong memory management and exception handling. Multithreaded : Supports concurrent execution of two or more threads. ✅ Structure of a Java Program public class HelloWorld { public static void main (String[] args) { System.out.println( ...
Read more

Inheritance and Polymorphism

Let's dive deep into Inheritance and Polymorphism , two fundamental pillars of Object-Oriented Programming (OOP) in Java. 🔷 INHERITANCE in Java 📌 Definition: Inheritance is the mechanism in Java by which one class acquires the properties and behaviors (fields and methods) of another class. The class that inherits is called the subclass (or child class). The class from which it inherits is the superclass (or parent class). ✅ Syntax: class SuperClass { // fields and methods } class SubClass extends SuperClass { // additional fields and methods }  Example: class Animal { void eat () { System.out.println( "This animal eats food." ); } } class Dog extends Animal { void bark () { System.out.println( "The dog barks." ); } } public class Main { public static void main (String[] args) { Dog d = new Dog (); d.eat(); // Inherited method d.bark(); ...
Read more