Kit Library / Computer Science / Object-Oriented Programming
⚡ Topic Learning KitShared by a Veda teacher · Generated with Veda AI
Veda Bites are swipeable micro-lessons — each one teaches exactly one idea. The bites below come from this kit — swipe through them in the app.
One points inward, one points upward.
`this` refers to the current object; `super` refers to the immediate parent class of the current object.
↳ `this` = me; `super` = my parent. Both are implicit references available inside instance context.
Not objects — reference variables.
Both are implicitly available inside non-static methods and constructors — you never declare them.
↳ They are predefined reference variables, not keywords you instantiate.
Same name, two meanings — this breaks the tie.
When a parameter or local variable has the same name as an instance variable, the local one shadows the field. `this.field` explicitly reaches the object's field.
↳ `this.x` always means the instance field, even when a local `x` exists.
Override hides the parent — super brings it back.
When a subclass overrides a method or hides a field, `super.method()` and `super.field` still access the parent version.
↳ `super` gives access to the parent's implementation even after overriding.
One constructor calling another — cleanly.
`this()` invokes another constructor of the same class, reducing duplication.
↳ `this(...)` must be the **first statement** in the constructor.
Parent constructor runs before child.
`super(...)` invokes the parent class constructor and must be the first statement in the subclass constructor. If omitted, Java inserts `super()` automatically.
↳ Parent constructor always executes before the child's body.
Static has no object — so this fails.
↳ No object → no `this`/`super`. Static context is object-free.
Only one can be first.
↳ First-statement rule means `this()` and `super()` are mutually exclusive in one constructor.
Side-by-side, no confusion.
↳ Same syntax shape, different target — memorize the target column.
Inheritance in action with both keywords.
↳ `super` is the standard tool for extending inherited behavior.
Every framework uses these daily.
↳ These keywords are the backbone of OOP-style Java code.
Chain methods like a pro.
↳ `this` as a return value powers builder and fluent APIs.
Examiners love this trap.
↳ Four rules cover most exam questions on this topic.
Two words, one mental image.
this = me (current object). super = my parent (superclass). Whenever you're confused, ask: *am I talking about myself or my parent?*
↳ Anchor `this` to 'me' and `super` to 'parent' — resolves most confusion instantly.
Missing parent constructor = compile error.
↳ Always ensure the parent has a constructor the child can call.
The `this` and `super` keywords are reference variables in Java that let an object access its own members and its parent class members respectively. `this` resolves ambiguity between instance variables and parameters and…
Full explanation, worked examples & memory tricks in the app
All 17 questions, laddered from warm-up to topper-level, each with its answer and the reasoning behind it.
Q1. Inside an instance method, what does the `this` keyword refer to?
BeginnerC · The current object
`this` is a hidden reference to the object on which the method was invoked.
Q2. Which statement about `super` is correct?
BeginnerA · It refers to the parent part of the current object
`super` is a reference to the superclass slice within the current object, not a distinct object.
Q3. What is the purpose of `this.field = field;` in a constructor?
BeginnerB · To assign the parameter to the instance field
`this.field` refers to the instance field, while `field` on the right is the parameter, resolving the name clash.
Q4. Which keyword must be the first statement in a constructor to call another constructor of the same class?
BeginnerB · `this(...)`
`this(...)` invokes another constructor of the same class and must be the first statement.
Q5. What does `super.method()` do?
BeginnerB · Calls the parent's version of the method
`super.method()` explicitly invokes the superclass's implementation of the method.
Q6. `this(...)` and `super(...)` must be the first statement in a constructor, and a constructor cannot contain both.
BeginnerA · True
`this(...)` and `super(...)` must be the first statement in a constructor, and a constructor cannot contain both.
Q7. Why is `this` not allowed in a static method?
IntermediateA · Static methods have no current object
`this` requires an object instance; static methods belong to the class and have no instance.
Q8. Consider the code: ```java class A { void show() { System.out.println("A"); } } class B extends A { void show() { super.show(); System.out.println("B"); } } new B().show(); ``` What is printed?
IntermediateA · A then B
`super.show()` calls the parent's `show()` first, printing "A", then the subclass prints "B".
Q9. What happens if a subclass constructor does not explicitly call `this(...)` or `super(...)`?
IntermediateD · Java inserts a hidden `super()` call
Java automatically inserts `super()` if no explicit constructor call is present, requiring the parent to have a no-argument constructor.
Q10. Which of the following is a valid use of `this`?
IntermediateB · Returning `this` from a method for chaining
Returning `this` is a common pattern for method chaining; the other options are illegal.
Q11. What is the effect of declaring a field in a subclass with the same name as a field in the parent?
IntermediateD · The subclass field shadows the parent field
Field shadowing creates two separate fields; `this.field` accesses the subclass field, `super.field` accesses the parent field.
Q12. In a constructor, which statement is true about `this(...)` and `super(...)`?
IntermediateB · A constructor can contain at most one of them, as the first statement
Only one constructor call is allowed, and it must be the first statement.
Q13. Why does Java require `this(...)` or `super(...)` to be the first statement in a constructor?
AdvancedD · To ensure the object is initialised before other code runs
The first-statement rule guarantees that the object is fully constructed before any other statements execute.
Q14. A class `Child` extends `Parent`. `Parent` has only a constructor `Parent(int x)`. What must `Child`'s constructor do to compile?
AdvancedC · Explicitly call `super(x)` as its first statement
Since `Parent` lacks a no-argument constructor, the hidden `super()` would fail; `Child` must explicitly call `super(x)`.
Q15. What is the result of trying to use `super.super.method()`?
AdvancedC · Compilation error
`super.super` is illegal; you can only access one level up the inheritance hierarchy.
Q16. Which statement best explains why `super` cannot be passed as an argument to a method?
AdvancedA · `super` is a keyword, not an object reference
`super` is a special keyword that refers to the parent slice; it is not a standalone object and cannot be stored or passed.
Q17. Given the following code, what will be the output when `new Dog().sound();` is executed?
AdvancedC · Some sound Bark
The correct output is 'Some sound Bark' because `super.sound()` calls the parent method from `Animal`, which prints 'Some sound', followed by the subclass `Dog` printing 'Bark'.
20 flashcards in this kit — the app reviews them with spaced repetition so the right card returns on the right day.
Every game is built from this kit's own content — scores feed your mastery, so playing counts as studying.
Word Match
Built from this kit's own content
True False
Built from this kit's own content
Memory Match
Built from this kit's own content
Flashcard Battle
Built from this kit's own content
Speed Quiz
Built from this kit's own content
Guess Term
Built from this kit's own content
Sequence Builder
Built from this kit's own content
Categorization
Built from this kit's own content
Revision Battle
Built from this kit's own content
Playable in the app
The full Veda Bites deck, complete notes, spaced-repetition flashcards, leveled MCQs, tests and games for this kit — plus Daily Facts and the Arena, every day.