在 Java 中实例化接口

Question

我有这个界面：

public interface Animal {
    void Eat(String name);
}

而这里的代码实现了接口：

public class Dog implements Animal {
    public void Eat(String food_name) {
        System.out.printf(food_name);
    }
    
    public static void main(String args[]) {
        Animal baby2 = new Dog(); // <- this line
        baby2.Eat("Meat");
    }
}

我的问题是，为什么代码有效？无法实例化接口。然而在这种情况下，接口被实例化（用注释标记）。

这里发生了什么？

Answer 1

不，不是 - 您正在实例化 Dog，但由于 Dog 是 Animal，您可以将变量声明为 Animal。如果您尝试实例化接口Animal，它将是：

Animal baby2 = new Animal();

尝试一下，然后看着编译器惊恐地尖叫 :)

Answer 2

Dog 不是一个接口：Dog 是一个类，它实现Animal 接口。

这里没有发生任何不愉快的事情。

---

请注意，您可以实例化接口的匿名实现，如下所示：

Animal animal = new Animal() {
    public void Eat(String food_name) {
        System.out.printf("Someone ate " + food_name);
    }
};

Answer 3

让我们考虑下面的代码：

interface Cookable {
    public void cook();
}

class Food {
    Cookable c = new Cookable() {
     public void cook() {
         System.out.println("anonymous cookable implementer");
        }
      };
 }

前面的代码创建了一个匿名内部类的实例，但在这里，新的即时类是Cookable接口的实现者。请注意，这是您唯一一次看到语法：

new Cookable()

Cookable 是一个接口而不是一个非抽象类类型。想一想： 您不能实例化接口，但这就是代码看起来正在做的事情。但是，当然，它不是实例化Cookable object——它是创建一个新的anonymous implementer of Cookable 的实例。

你可以读到这一行：

   Cookable c = new Cookable(){}

as “声明一个 Cookable 类型的引用变量，很明显，它将引用一个类中的一个对象 实现 Cookable 接口。但是，哦，是的，我们还没有 一个实现 Cookable 的类，所以我们要做一个正确的 在这里，现在。我们不需要这个类的名字，但它会是一个 实现 Cookable 的类，这个花括号开始 新实现类的定义。”

匿名接口实现者需要记住的重要一点——他们只能实现一个接口。根本没有任何机制可以说您的匿名内部类将实现多个接口。事实上，一个匿名内部类甚至不能同时扩展一个类和实现一个接口。 innve 类必须选择作为命名类的子类并且根本不直接实现任何接口或实现单个接口。

所以不要被任何实例化接口的尝试所迷惑，除非是匿名内部类。 以下内容不合法：

Runnable r = new Runnable(); // can't instantiate interface 

而以下是合法的，因为它正在实例化 Runnable 接口的实现者（匿名实现类）：

Runnable r = new Runnable() { 
   public void run(){ }
};

你可以阅读我的文章here。

Answer 4

您在这里观察到的是SOLID 的Dependency inversion 方面。

您的代码依赖于Animal 合约的抽象，通过实例化它的具体实现。您只是在声明，“我正在实例化 some 对象，但无论该对象实际上是什么，它都将绑定到 Animal 接口的合同。”

以这些声明为例：

List<String> wordList = new LinkedList<>();
Map<Integer, String> mapping = new HashMap<>();

在这两种情况下，列表和地图的主要方面是它们遵循List 和Map 的通用合同。

Answer 5

Animal baby2 = new Dog(); //HERE!!!!!!!!!!!!!!!!!!!!!!

你肯定没有实例化 Animal。您只是将 Dog 实例引用给它。 在java中我们可以获取超类引用。

Answer 6

这是一个多态的例子，看起来你正在创建“动物”对象，但事实并非如此。您正在创建在运行时计算的“狗”对象。“动物”充当合同。接口不能直接实例化，但可以通过向上转换其子类来用作类型。您还可以使用匿名类将对象实例化为“动物”类型。

   Animal baby2 = new Dog(); //upcasting polymorphically
   Animal baby3=new Animal(){
      public void Eat(String food){System.out.println("fdkfdfk"); }
   }
    //You can instantiate directly as anonymous class by implementing all the method of interface

Answer 7

接口Animal不是实例化的，而是由Dog实现的。而Dog是实例化的

Answer 8

当你说：

Animal baby2 = new Dog();

引用类型是Animal（接口），它指向一个具体的实现（Dog）。对象类型 Dog 是具体的并且可以被实例化。在这种情况下，只要 Dog hasanimal 指向 Dog。接口中所有方法的具体实现，可以做一个引用类型的

如果你做了类似的事情，

Animal baby2 = new Animal(); // here you are actually instantiating

这将是无效的，因为现在您正试图从抽象实现创建具体对象。

Answer 9

接口 Animal 充当 Dog 类的数据类型。您实际上是在实例化 Dog 类而不是接口或其数据类型。

Answer 10

拥有更广阔的视野：

Animal [] Zoo = new Animal[10] ; // is also correct

但是为什么？

整个想法是，在上面的表格中，您可以放置​​ 10 种不同类型的动物。唯一的条件是所有进入动物园的动物都必须实现接口 Animal 。

public interface Animal {
 void Eat();
}
class Wolf implements Animal {  void Eat (){ 
System.out.println("Wolf eats meat ") ;}}

Class Zebra implements Animal{ void Eat (){
System.out.println("Zebra eats the grass ") ;}}

class test {
public static void main (String args []) {

Animal [] Zoo = new Animal[2] ;

Zoo[0] =  new Wolf() ;
Zoo[1] = new Zebra() ;

 //so you can feed your animals in Zoo like this

 for (int i=0 ; i<Zoo.lenght;i++) {Zoo[i].Eat();}
}
}

Answer 11

您不能实例化接口。可以认为该功能类似于抽象类的功能。您可以引用接口，但不能创建接口对象。如果你做这样的事情......

动物 a = new Animal(); 编译器将显示错误-“无法实例化类型 Animal”。

Answer 12

其实你可以实例化接口。这是您可以尝试的代码

public static void main(String args[]) {
    System.out.println(new Animal() {
        public String toString() {
            return "test";
        }
    });
}

这个程序运行成功并打印出test 试试看。

Answer 13

这里只是引用接口，但实例化仅由类完成。 例如

Animanl a = 新狗 Animal a - 变量被引用 new Dog - 现在已分配内存

Answer 14

Java 8 让你使用，功能接口，

@FunctionalInterface // this is not mandatory 
interface A{
    void m1(); // only one abstract method allowed for functional interface
}

class Main{
   public static void main(String a[]){

      // old usage
      A a1 = new A(){
        @Override
        public void m1(){
           System.out.println("Call Me normally");
        }
      };

      a1.m1();

      // new in java 8, functional interface
      A a2 = ()-> System.out.println("Call Me as functional interface");
      a2.m1();
 
   }
}

Answer 15

你所做的是类型转换。你已经创建了一个 dog 类的实例，并将它的类型转换为接口 animal。它是运行时多态的一个例子。但是是的，可以实现一个接口，我在搜索这个时已经到达这里。 即

public class demo16{
interface cardio{
    void run();
}

static void foo(){
    cardio c = new cardio(){ //HENCE instance of "interface cardio" is being created inside a method foo
        public void run(){
            System.out.println("How you doing  ! ");
        }; //HENCE observe the ";" beside }
    };     //HENCE observe the ";" beside }
    c.run();
}

public static void main(String [] args){
    foo();
}

}