Interface in Java | Concept, Declaration, Implementation | Abstraction | Relationship with Classes
Channel: PsychoTech Institute™
Date: 2023-12-02

In Java, an interface is a programming construct that defines a contract or a set of abstract methods that a class implementing the interface must provide concrete implementations for. Interfaces are a fundamental part of Java's support for object-oriented programming and are used to achieve abstraction and achieve a form of multiple inheritance. Here are the key aspects of interfaces in Java:

1. Interface Declaration:
   - An interface is declared using the `interface` keyword, followed by the interface's name and a block of abstract method declarations.
  
 - Example:
     
     interface MyInterface {
         void method1();
         int method2(int x, int y);
     }
     

2. Abstract Methods:
   - Interface methods are implicitly abstract and do not contain method bodies (implementations). These methods represent a contract that implementing classes must adhere to.
   - All methods in an interface are `public` and `abstract` by default (even if you don't explicitly specify these modifiers).

3. Implementing an Interface:
   - To use an interface, a class implements it using the `implements` keyword, and the implementing class must provide concrete implementations for all the abstract methods declared in the interface.
   
- Example:
     
     class MyClass implements MyInterface {
         @Override
         public void method1() {
             // Implementation of method1
         }
         
         @Override
         public int method2(int x, int y) {
             // Implementation of method2
             return x + y;
         }
     }
     

4. Multiple Interface Implementation:
   - A class can implement multiple interfaces, which allows it to inherit the abstract methods and contracts of all the interfaces it implements.
  
 - Example:
     
     class MyOtherClass implements MyInterface, AnotherInterface {
         // This class must provide implementations for methods from both interfaces.
     }
     

5. Default and Static Methods (Java 8+):
   - Starting with Java 8, interfaces can contain default and static methods that provide method implementations. These methods can be used by implementing classes but can also be overridden.
   - Default methods are defined using the `default` keyword, while static methods are declared using the `static` keyword.
 
  - Example:
    
     interface MyInterface {
         void method1();
         
         default void defaultMethod() {
             // Default method implementation
         }
         
         static void staticMethod() {
             // Static method implementation
         }
     }
     

6. Functional Interfaces (Java 8+):
   - A functional interface is an interface with a single abstract method. Java 8 introduced the `@FunctionalInterface` annotation to explicitly declare functional interfaces.
   - Functional interfaces are often used with lambda expressions and the Java 8 stream API.
  
 - Example:
     
     @FunctionalInterface
     interface MyFunctionalInterface {
         int performOperation(int x, int y);
     }
     

7. Marker Interfaces:
   - Some interfaces do not declare any methods and are used as marker interfaces. They indicate that a class has a certain property or should be treated in a specific way.
 
 - Example:
     
     interface Serializable {
         // This interface is a marker interface indicating that an object is serializable.
     }
     

Interfaces in Java are a powerful tool for defining contracts and ensuring that classes adhere to these contracts. They play a central role in achieving abstraction, decoupling code, and promoting code reusability in object-oriented programming.



Best reference books for Object Oriented Programming: https://amzn.to/47dYoZp 
Books for IGNOU BCS-031 C++ Programming: https://amzn.to/3FGbCT3
Books for MCS-024 IGNOU Java Programming: https://amzn.to/3u1pIfq 

Thank you for watching!


polymorphism overloading and overriding, polymorphism overloading and overriding in java, polymorphism method overriding in java, method overloading and overriding in java in hindi, method overloading and overriding in java, introduction to java programming, java programming full course, java fundamentals, classes and methods, object as a parameter in java, types of java applications, types of exception handling in java, advantages of method overriding in java, java programs for practice, explain method overloading with example in java, object-oriented system design, introduction to object-oriented programming in c, introduction to object-oriented programming, what is object-oriented programming, object-oriented thinking, object-oriented programming java in hindi, object-oriented programming java playlist, getter and setter method in java, java methods explained, how to write a method in java, methods in java for beginners, java functions and methods, static method in java

#psychotech #PsychoTechInstitute #java #programming #objectorientedprogramming  #interface #java_interface