Java接口中的所有方法都是抽象的吗？

在Java中，接口被称为类的蓝图，在Java中用于实现抽象。通过只使用接口，我们可以在Java中实现多重继承。

• 让我们通过一个例子来理解蓝图的概念，比如建筑物的蓝图将包含建筑物的属性和行为，但对于每个建筑物，它可能是不同的，类似于这些接口具有抽象方法，当由类实现时，它们将有自己的独特的行为。
• 当实现一个接口时，我们强制该类实现它的方法，如果它没有实现它，那么我们需要声明该类抽象。我们可以在接口中使用默认方法和静态方法。
• Java 8 引入了默认方法的概念，将它们添加到Java 8 中的原因是针对某个界面使用起来不舒服的场景。例如，如果我们有一个由许多类实现的方法，并且每种情况的功能都相同，那么对于相同的功能，我们需要在每个类中一次又一次地编写此函数，以消除Java 8 默认方法中的这个困难被给予。
• 默认情况下，所有方法都是公共和抽象的，直到我们不将其声明为默认值并且属性是静态和最终的。

Java接口中的所有方法都是抽象的！

抽象方法没有主体，它们只有声明而没有定义。定义是通过实现类来定义的。因此，我们查看所有示例，其中方法可以在接口内与其行为（主体）一起存在。现在我们将尝试为接口内不同场景的方法提供主体。

示例 1：

• 在这个例子中，我们将有一个由类 GFG 实现的抽象方法 heighDisplay()（没有主体）。
• 所以 GFG 类需要实现 heighDisplay() 方法并调用这个方法我们将创建 GFG 类的对象。
• 所以我们的第一个例子告诉我们接口中可以有抽象方法，我们这样做只是为了证明接口只包含抽象方法。

以下是仅在接口内具有一个抽象方法的示例：

Java

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
}
  
class GFG implements Building {
    // implementing the abstract method 
    // of building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

输出

height is 5

示例 2：

• 在这个例子中，我们将有一个实例方法 widthDisplay() ，它也有它的主体。在正文中，我们将打印一个语句。
• 现在我们知道接口只包含抽象方法，所以当我们运行它时我们会得到错误。将有 3 个错误，但第一个将在第 6 行错误名称：接口抽象方法不能有主体。
• 所以我们通过这个例子证明了我们不能在接口内部有实例方法。简单来说，实例方法是非静态的方法。实例方法将为不同的方法产生不同的输出，因为不同的对象具有不同的实例属性，适用于哪个实例方法。
• 所以这个例子也支持接口只能由抽象方法组成的说法。

下面是在接口中有一个实例方法和一个抽象方法的例子：

Java

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
  
    // instance method with body
    void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
  
class GFG implements Building {
    // implementing the abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
  
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
        gfg.widthDisplay();
    }
}

输出

prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
prog.java:27: error: cannot find symbol
        gfg.widthDisplay();
           ^
  symbol:   method widthDisplay()
  location: variable gfg of type GFG
3 errors

示例 3：

• 在这个例子中，我们将有最后一个方法 widthDisplay() 在它的主体中打印宽度。因此，我们用它的主体定义了一个最终方法。
• 这违反了具有抽象方法的接口规则，因为它有一个方法体。
• 需要注意的一件事是，我们不能将 final 关键字与抽象方法一起使用，因此这也会给我们错误的关键字非法组合。但是我们没有使用abstract关键字，怎么会出现非法组合的错误。因为默认情况下，接口内的所有方法都是抽象的。
• 所以这个例子说明我们不能在接口中使用 final 方法。因此，这个例子也表明我们只能在接口内部有抽象方法。

下面是在接口中有一个最终方法和一个抽象方法的示例。

Java

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
  
    // final methods
    final void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
  
class GFG implements Building {
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

输出

prog.java:9: error: modifier final not allowed here
    final void widthDisplay()
               ^
prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
3 error

示例 4：

• 在这个例子中，我们将有一个抽象方法 widthDisplay() ，它的主体在界面内。如您所知，抽象方法不能有主体，所以它也会给我们错误，其中一个错误是抽象方法不能有主体。
• 所以在这个例子中，我们试图给抽象方法赋予主体，即使知道抽象方法不能有主体，只是为了证明我们只能在接口内部有抽象方法。
• 所以这个例子也支持我们的说法，即接口只能由抽象方法组成。

下面是在接口内有一个抽象方法的例子：

Java

import java.io.*;
interface Building {
    // abstract method
    void heightDisplay();
  
    // giving body to abstract method
    abstract void widthDisplay()
    {
        System.out.pritnln("width is 1");
    }
}
  
class GFG implements Building {
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
    }
}

输出

prog.java:10: error: interface abstract methods cannot have body
    {
    ^
prog.java:15: error: GFG is not abstract and does not override abstract method widthDisplay() in Building
class GFG implements Building {
^
2 errors

注意：在Java 8 之前，我们在接口中没有静态方法，但现在我们可以在接口中使用静态方法。

示例 5：

• 在Java 8 之前，我们在接口中没有静态方法，但是从Java 8 开始，我们可以在接口中拥有抽象方法。
• 但是在这个例子中，不会有错误。因此，我们可以拥有可以在接口中拥有自己主体的方法，其中之一是静态方法。
• 所以从Java 8 开始，说接口只能有抽象方法并不是 100% 正确的。

下面是在接口中有一个静态方法的例子：

Java

import java.io.*;
interface Building {
    // abstract method
    void heightDisplay();
  
    // static method
    static void widthDisplay()
    {
        System.out.println("width is 1");
    }
}
  
class GFG implements Building {
    // implementing tha abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
  
        GFG gfg = new GFG();
        gfg.heightDisplay();
        // accessing the static method
        // by using of interface name
        Building.widthDisplay();
    }
}

输出

height is 5
width is 1

示例 6：

• 从Java 8 开始，我们也可以在其中使用默认方法。默认方法允许接口具有不需要由实现该接口的类来实现的方法。
• 一个最适合默认方法的示例，假设您有一个被许多类使用的接口方法，并且所有类的功能都相同，在这种情况下，您需要在每个类中实现，即使每个类的主体都相同。因此Java 8 引入了默认方法的概念来克服这种情况。
• 因此，我们可以说我们可以在接口中拥有静态和默认方法，除此之外我们将只有抽象方法。

下面是在界面中使用默认方法的示例：

Java

import java.io.*;
interface Building {
    // abstract methods
    void heightDisplay();
  
    // default method
    default void widthDisplay()
    {
        System.out.println("width is 1");
    }
}
  
class GFG implements Building {
    // implementing abstract method
    // of Building interface
    public void heightDisplay()
    {
        System.out.println("height is 5");
    }
    public static void main(String[] args)
    {
        GFG gfg = new GFG();
        gfg.heightDisplay();
  
        // calling default method
        gfg.widthDisplay();
    }
}

输出

height is 5
width is 1