java - java中的接口

Question

代码 1：

public class User1 implements MyInterface
{
    @Override
    public void doCalculation() { }
}

public class User2 implements MyInterface
{
    @Override
    public void doCalculation() { }
}

interface MyInterface
{
    public void doCalculation();
}

代码 2：

public class User1
{
    public void doCalculation() { }
}

public class User2
{
    public void doCalculation() { }
}

在我的代码 1中，我有MyInterface一个空方法doCalculation()。user1 和user2doCalculation()通过实现MyInterface.

在我的代码 2中，我有两个具有定义doCalculation()方法的不同类。

在 code1 和 code2 这两种情况下，我自己都必须编写实现。我的方法doCalculation()只是一个空方法。

那么MyInterface这里有什么用呢？

它只为我提供方法名称或骨架（这是接口的唯一优点）？
否则我会在使用时节省任何内存MyInterface吗？
就是这样，它只为实现它的类提供了空方法，那么为什么不像我在code2中所做的那样自己定义它。
不仅如此，使用界面还有更多优势。

score 3 · Accepted Answer

接口被大量使用，因为它们基本上是你的类应该能够做什么的蓝图。

例如，如果您正在编写一个包含角色的视频游戏，您可以拥有一个包含角色应该拥有的所有方法的界面。

例如

public interface Character {
    public void doAction();
}

你有 2 个角色，例如一个盟友和一个敌人。

public class Ally implements Character {
    public void doAction() {
        System.out.println("Defend");
    }
}

public class Enemy implements Character {
    public void doAction() {
        System.out.println("Attack");
    }
}

如您所见，两个类都实现了接口，但它们有不同的操作。现在你可以创建一个角色来实现你的界面并让它执行它的动作。根据它是敌人还是盟友，它会执行不同的动作。

public Character ally = new Ally();
public Character enemy = new Enemy();

在你的主程序中，你可以创建一个方法来接受任何实现你的接口的对象，并让它执行它的动作，而不知道它是什么类型的字符。

void characterDoAction(Character char) {
    char.doAction();
}

如果您愿意为此方法提供盟友，则输出将是：

Defend

如果您将此方法赋予敌人，则输出将是：

Attack

我希望这是一个足够好的例子来帮助你理解使用接口的好处。

score 2 · Accepted Answer

There are a lot of advantages of interface driven programming.

What does "program to interfaces, not implementations" mean?

Basically you are defining a contract in an interface and all the classes which implement the interface have to abide by the contract.

Answers to your queries:

1.It only provides me the method name or skeleton (is that the only advantage of interface)?

--> Its not just about providing the method name but also defining what the class implementing the interface can do.

2.Or else would I save any memory while using MyInterface?

--> Nothing to do with the memory

Is that, it only provides the empty method for an class which implements it, then why not I define it by myself as I have done in my code2. --> see the advantages of interface driven programming.

4.More than that is there any more advantage on using an interface. --> Plenty,specially dependency injection , mocking , unit testing etc.

score 1 · Accepted Answer

许多类使用接口来执行某些功能，依赖于其他程序员来实现该接口，尊重接口管理的契约。例如，这些类是KeyListeners、MouseListeners、Runnable等。

例如：JVM 知道如何处理 a Thread，如何启动它、停止它、操作它，但它不知道你Thread应该做什么，所以你必须实现Runnable接口。

接口为您提供了可以在其他类中使用的抽象级别。例如，如果您有一个名为的接口GemetricFigure，则在打印a周长的类中，GeometricFigure您可以遍历所有GeometricFigures的列表，例如：

public class Canvas {

   private List<GeometricFigure> figures;

   public void print() {
       for (GeometricFigure figure : figure) {
           System.out.println(figure.getGirth());
       }
   }

}

如果GeometricFigure只有那个方法：

public interface GeometricFigure {

    public Double getGirth();

}

您不会关心如何Square或Circle实现该接口。否则，如果没有接口，您就不能在中拥有 GeometricFigures 列表，而是Canvas每个图形类型的列表。

score 1 · Accepted Answer

一个很好的解释可以在这里找到when-best-to-use-an-interface-in-java。这实际上取决于您正在构建的内容以及您想要/不想拥有的可扩展性、代码重复等。

score 0 · Accepted Answer

接口就像你的实现类应该满足的契约。通常，您将编写一个接口并让所有其他类的实现都使用它们自己的实现。

例子：

interface IExporter {
    public void export();
}

public class PDFExport implements IExporter {
    public void export(){
    //code for PDF Exporting
    }
}

public class XLSExport implements IExporter {
    public void export(){
    //code for XLS Exporting
    }
}

public class DOCExport implements IExporter {
    public void export(){
    //code for DOC Exporting
    }
}

score 0 · Accepted Answer

使用接口方法，您可以执行以下操作：

List<MyInterface> list = new ArrayList<MyInterface();

list.add(new User1());
list.add(new User2());

for(MyInterface myInterface : list) {
    myInterface.doClaculation()
}

这不适用于第二种方法。接口适用于使用你的类的代码——而不是你的类本身。

score 0 · Accepted Answer

这就是面向对象编程的全部意义所在。Interfaces are used to perform polymorphism. 你说，你可以在 code2 中为这两个类实现，如果将来有 user3 需要doCalculation. calculation您可以只实现该接口并以您自己的形式编写您的接口。

当您想为所有用户提供基本功能时abstract classes，您可以在其中声明一个抽象方法do calculation并提供该基本功能的实现，然后每个用户都可以扩展并doCalculation以自己的方式进行扩展。

score 0 · Accepted Answer

您可以在许多情况下使用接口。还有你描述的情况：你不需要知道你有哪个实现。

例如，您的代码中的任何地方都有一个方法，即使您不知道它是 User1 还是 User2 实现，它也会返回当前在用户中签名的方法，但是它们都可以通过方法 doCalculation 计算某些东西。我添加了一个关于这种情况的非常愚蠢的例子：

public void dummyExampleCalculation() {

   getCurrentUser().doCalculation();

}

public MyInterface getCurrentUser() {

   if(...) {
      return new User1();
   } else {
      return new User2();
   }

}

score 0 · Accepted Answer

Java中的接口用于对类强加实现规则。这意味着您可以在接口中声明函数的签名，然后完全按照函数签名在各种类中实现这些函数。

您可以在以下网页上看到一个清晰而现实的示例

http://www.csnotes32.com/2014/10/interface-in-java.html

java - java中的接口

9 回答 9

Related

Reference