The document discusses the super keyword, final keyword, and interfaces in Java. - The super keyword is used to refer to the immediate parent class and can be used with variables, methods, and constructors. It allows accessing members of the parent class from the child class. - The final keyword can be used with variables, methods, and classes. It makes variables constant and prevents overriding of methods and inheritance of classes. - Interfaces in Java allow achieving abstraction and multiple inheritance. They can contain only abstract methods and variables declared with default access modifiers. Classes implement interfaces to provide method definitions.

1. Super Keyword in Java

2. • The super keyword in Java is a reference
variable which is used to refer immediate
parent class object.
• Whenever you create the instance of subclass,
an instance of parent class is created implicitly
which is referred by super reference variable.

3. Usage of Java super Keyword
• super can be used to refer immediate parent
class instance variable.
• super can be used to invoke immediate parent
class method.
• super() can be used to invoke immediate
parent class constructor.

4. Use of super with variables
• This scenario occurs when a derived class and
base class has the same data members. In that
case, there is a possibility of ambiguity for
the JVM.

5. • class Vehicle {
• int maxSpeed = 120;
• }
• // sub class Car extending vehicle
• class Car extends Vehicle {
• int maxSpeed = 180;
• void display()
• {
• // print maxSpeed of base class (vehicle)
• System.out.println("Maximum Speed: "
• + super.maxSpeed);
}
• }

6. • // Driver Program
• class Test {
• public static void main(String[] args)
• {
• Car small = new Car();
• small.display();
• }
• }
• OutputMaximum Speed: 120

7. • class Animal{
• String color="white";
• }
• class Dog extends Animal{
• String color="black";
• void printColor(){
• System.out.println(color);//prints color of Dog class
• System.out.println(super.color);//prints color of Animal class
• }
• }
• class TestSuper1{
• public static void main(String args[]){
• Dog d=new Dog();
• d.printColor();
• }}

8. super can be used to invoke parent
class method
• The super keyword can also be used to invoke
parent class method. It should be used if
subclass contains the same method as parent
class. In other words, it is used if method is
overridden.

9. • class Animal{
• void eat(){System.out.println("eating...");}
• }
• class Dog extends Animal{
• void eat(){System.out.println("eating bread...");}
• void bark(){System.out.println("barking...");}
• void work(){
• super.eat();
• bark();
• }
• }
• class TestSuper2{
• public static void main(String args[]){
• Dog d=new Dog();
• d.work();
• }}

10. Use of super with constructors
• The super keyword can also be used to access the
parent class constructor
• class Person {
• Person()
• {
• System.out.println("Person class
Constructor");
• }
• }

11. • class Student extends Person {
• Student()
• {
• // invoke or call parent class constructor
• super();
•
• System.out.println("Student class Constructor");
• }
• }
• class Test {
• public static void main(String[] args)
• {
• Student s = new Student();
• }
• }

12. final Keyword in Java

13. Final Variables
• When a variable is declared with the final
keyword, its value can’t be modified,
essentially, a constant.
• Initializing a final Variable
• We must initialize a final variable, otherwise,
the compiler will throw a compile-time error.
A final variable can only be initialized once.

14. • class Bike9{
• final int speedlimit=90;//final variable
• void run(){
• speedlimit=400;
• }
• }
• Class Demo
• { public static void main(String args[]){
• Bike9 obj=new Bike9();
• obj.run();
• }
• }//end of class
• Output:Compile Time Error

15. final method
• If you make any method as final, you cannot override it.
• class Bike{
• final void run(){System.out.println("running");}
• }
•
• class Honda extends Bike{
• void run(){System.out.println("running safely with 100kmph");}
• class Demo{
• public static void main(String args[]){
• Honda honda= new Honda();
• honda.run();
• }
• } Output:Compile Time Error

16. Final classes
• When a class is declared with final keyword, it is called a
final class. A final class cannot be extended(inherited).
• final class A
• {
• // methods and fields
• }
• // The following class is illegal
• class B extends A
• {
• // COMPILE-ERROR! Can't subclass A
• }

17. Interfaces in Java
• The interface in Java is a mechanism to
achieve abstraction.
• There can be only abstract methods in the Java
interface, not the method body. It is used to
achieve abstraction and multiple inheritance in
Java.
• In other words, you can say that interfaces can
have abstract methods and variables. It cannot
have a method body.
• Java Interface also represents the IS-A
relationship.

18. • Like abstract classes, interfaces cannot be used to
create objects.
• Interface methods do not have a body - the body is
provided by the "implement" class
• On implementation of an interface, you must override
all of its methods
• Interface methods are by default abstract and public
• Interface attributes are by default public, static and
final
• An interface cannot contain a constructor (as it cannot
• be used to create objects)

19. How to declare an interface?
• An interface is declared by using the interface
keyword.
• Syntax:
• interface <interface_name>{
•
• // declare constant fields
• // declare methods that abstract
• // by default.
• }

20. • interface printable{
• void print();
• }
• class A6 implements printable{
• public void print(){System.out.println("Hello");}
•
• public static void main(String args[]){
• A6 obj = new A6();
• obj.print();
• }
• }
•

21. Why And When To Use Interfaces?
• To achieve security - hide certain details and only
• show the important details of an object (interface).
• Java does not support "multiple inheritance" (a
• class can only inherit from one superclass).
• However, it can be achieved with interfaces,
• because the class can implement multiple
• interfaces.
• Note: To implement multiple interfaces , separate
• them with a comma

22. Multiple inheritance is not supported
through class in java, but it is possible
by an interface, why?
• As we have explained in the inheritance
chapter, multiple inheritance is not supported
in the case of class
• because of ambiguity. However, it is supported
in case of an interface because there is no
ambiguity. It is because its implementation is
provided by the implementation class

23. • interface Printable{
• void print();
• }
• interface Showable{
• void print();
• }
•
• class TestInterface3 implements Printable, Showable{
• public void print(){System.out.println("Hello");}
• public static void main(String args[]){
• TestInterface3 obj = new TestInterface3();
• obj.print();
• }
• }

24. • interface Calculator {
• int add(int a,int b);
• int subtract(int a,int b);
• int multiply(int a,int b);
• int divide(int a,int b);
• }

25. • class Normal_Calculator implements Calculator
• {
• public int add(int a,int b){
• return a+b;}
• public int subtract(int a,int b){
• return a-b;}
• public int multiply(int a,int b){
• return a*b;}
• public int divide(int a,int b){
• return a/b;}

26. • public static void main(String args[]){
• Normal_Calculator c=new Normal_Calculator();
• System.out.println(“Value after addition = “+c.add(5,2));
• System.out.println(“Value after Subtraction = “+c.subtract(5,2));
• System.out.println(“Value after Multiplication = “+c.multiply(5,2));
• System.out.println(“Value after division = “+c.divide(5,2)); }}

27. Multiple inheritance
• interface Shape
• {
• void area(double a);
• }
• interface student
• {
• void info(int roll);
• }

28. • class Oper19 implements
• Shape,student
{
public void area(double a){
System.out.println("square area
="+(a*a));
}
public void info(int roll)
{
System.out.println("student roll no
="+roll);
}

29. • public static void main(String args[])
• {
Oper19 ob=new Oper19();
ob.area(3.2);
ob.info(12);
}
}

30. Packages In Java
• Package in Java is a mechanism to encapsulate
a group of classes, sub packages and
interfaces.