Java Tutorials

Java - Interfaces

Interfaces in Java

An interface is a reference type in Java that can only include constants, method signatures, default methods, static methods, and nested types. It is also possible for an interface to have nested types. Instance fields and constructors are not allowed to be included inside interfaces. They provide a means of accomplishing abstraction as well as different inheritance possibilities.

// Interface
interface Animal {
    // Abstract method
    void sound();

    // Default method
    default void sleep() {
        System.out.println("Animal is sleeping");
    }
}

// Class implementing the interface
class Dog implements Animal {
    // Implementing the abstract method
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

// Class implementing the interface
class Cat implements Animal {
    // Implementing the abstract method
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // Output: Dog barks
        myDog.sleep(); // Output: Animal is sleeping

        Animal myCat = new Cat();
        myCat.sound(); // Output: Cat meows
        myCat.sleep(); // Output: Animal is sleeping
    }
}

An abstract method called sound and a default method called sleep are both being defined by the Animal interface.

In addition to providing implementations for the sound function, the Dog and Cat classes are responsible for implementing the Animal interface.

The main method is where the objects of Dog and Cat are built, and it is also where their respective methods are invoked.

logo

Java

Beginner 5 Hours

Interfaces in Java

An interface is a reference type in Java that can only include constants, method signatures, default methods, static methods, and nested types. It is also possible for an interface to have nested types. Instance fields and constructors are not allowed to be included inside interfaces. They provide a means of accomplishing abstraction as well as different inheritance possibilities.

// Interface
interface Animal {
    // Abstract method
    void sound();

    // Default method
    default void sleep() {
        System.out.println("Animal is sleeping");
    }
}

// Class implementing the interface
class Dog implements Animal {
    // Implementing the abstract method
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

// Class implementing the interface
class Cat implements Animal {
    // Implementing the abstract method
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // Output: Dog barks
        myDog.sleep(); // Output: Animal is sleeping

        Animal myCat = new Cat();
        myCat.sound(); // Output: Cat meows
        myCat.sleep(); // Output: Animal is sleeping
    }
}

An abstract method called sound and a default method called sleep are both being defined by the Animal interface.

In addition to providing implementations for the sound function, the Dog and Cat classes are responsible for implementing the Animal interface.

The main method is where the objects of Dog and Cat are built, and it is also where their respective methods are invoked.

Related Tutorials

Frequently Asked Questions for Java

Java is known for its key features such as object-oriented programming, platform independence, robust exception handling, multithreading capabilities, and automatic garbage collection.

The Java Development Kit (JDK) is a software development kit used to develop Java applications. The Java Runtime Environment (JRE) provides libraries and other resources to run Java applications, while the Java Virtual Machine (JVM) executes Java bytecode.

Java is a high-level, object-oriented programming language known for its platform independence. This means that Java programs can run on any device that has a Java Virtual Machine (JVM) installed, making it versatile across different operating systems.

Deadlock is a situation in multithreading where two or more threads are blocked forever, waiting for each other to release resources.

Functional programming in Java involves writing code using functions, immutability, and higher-order functions, often utilizing features introduced in Java 8.

A process is an independent program in execution, while a thread is a lightweight subprocess that shares resources with other threads within the same process.

The Comparable interface defines a natural ordering for objects, while the Comparator interface defines an external ordering.

The List interface allows duplicate elements and maintains the order of insertion, while the Set interface does not allow duplicates and does not guarantee any specific order.

String is immutable, meaning its value cannot be changed after creation. StringBuffer and StringBuilder are mutable, allowing modifications to their contents. The main difference between them is that StringBuffer is synchronized, making it thread-safe, while StringBuilder is not.

Checked exceptions are exceptions that must be either caught or declared in the method signature, while unchecked exceptions do not require explicit handling.

ArrayList is backed by a dynamic array, providing fast random access but slower insertions and deletions. LinkedList is backed by a doubly-linked list, offering faster insertions and deletions but slower random access.

Autoboxing is the automatic conversion between primitive types and their corresponding wrapper classes. For example, converting an int to Integer.

The 'synchronized' keyword in Java is used to control access to a method or block of code by multiple threads, ensuring that only one thread can execute it at a time.

Multithreading in Java allows concurrent execution of two or more threads, enabling efficient CPU utilization and improved application performance.

A HashMap is a collection class that implements the Map interface, storing key-value pairs. It allows null values and keys and provides constant-time performance for basic operations.

Java achieves platform independence by compiling source code into bytecode, which is executed by the JVM. This allows Java programs to run on any platform that has a compatible JVM.

The Serializable interface provides a default mechanism for serialization, while the Externalizable interface allows for custom serialization behavior.

The 'volatile' keyword in Java indicates that a variable's value will be modified by multiple threads, ensuring that the most up-to-date value is always visible.

Serialization is the process of converting an object into a byte stream, enabling it to be saved to a file or transmitted over a network.

The finalize() method is called by the garbage collector before an object is destroyed, allowing for cleanup operations.

The 'final' keyword in Java is used to define constants, prevent method overriding, and prevent inheritance of classes, ensuring that certain elements remain unchanged.

Garbage collection is the process by which the JVM automatically deletes objects that are no longer reachable, freeing up memory resources.

'throw' is used to explicitly throw an exception, while 'throws' is used in method declarations to specify that a method can throw one or more exceptions.

The 'super' keyword in Java refers to the immediate parent class and is used to access parent class methods, constructors, and variables.

The JVM is responsible for loading, verifying, and executing Java bytecode. It provides an abstraction between the compiled Java program and the underlying hardware, enabling platform independence.

line

Mail us :

Address :

India
  • Facebook_logo
  • Instagram_logo
  • Linkedin_logo
  • X-twitter_logo
  • Youtube_logo
  • Pinterest_logo

Sub Categories

Copyrights © 2024 letsupdateskills All rights reserved