在Java中作为类型的接口？

发件人：

在Java中，一个类只能从一个类继承，但它可以实现 不止一个接口。因此，对象可以有多种类型： 它们自己的类的类型以及所创建的所有接口的类型 他们实施。这意味着如果变量被声明为 接口的类型，其值可以引用 从实现接口的任何类实例化

有人能为我提供一个基本的伪类型吗。我不理解粗体的线条。

您引用的语句（从何处？）是正确的，但有误导性——对象已经有多个没有接口的类型

例如，

“bimmelim”

有类型

字符串

，但它也有类型

对象

。接口不会改变这一点，除了

“bimmelim”

还具有类型

可序列化

、

字符序列

等

实际上，我们是否应该说

“bimmelim”

“具有”类型

对象

，可能存在争议，但对它的引用肯定会适合

对象

变量

如果变量被声明为接口的类型。。。比如说

CharSequence x ;

---

。。。然后它的值可以引用

字符串

对象，例如

“bimmelim”

，或者它可能是

字符串缓冲区

，这是另一种实现

字符序列

的类型，以下是正确的赋值：

class AClass implements AInterface {
}


AInterface var = new AClass();

---

考虑以下示例：

Serializable s = new ArrayList();

在Java中，这是有效的代码，即使

Serializable

是一个接口，因为

ArrayList

实现了

Serializable

。因此，在本例中，我们将

s

视为类型为

Serializable

的变量

现在，假设我们按照上述代码执行以下操作：

s = "String object";

---

这也是有效的，因为

String

还实现了

Serializable

。由于我们将

s

声明为类型

Serializable

，因此它可以指向实现该接口的任何对象

考虑以下类和接口定义：

class Ball extends Rubber implements Jumping, Rolling, Squeezing {
   public void jump(){}
   public void roll(){}
   public void squeeze(){}
}

Ball b = new Ball();
Jumping j = new Ball();
j.jump();

//j.roll();         //CTE: Cannot resolve method roll()
((Ball) j).roll();  //but it still can be called if explicit cast to type Ball is used

public class A { }

public class B extends A implements I { }

public interface I { }

以下声明均为合法声明：

A first = new A();
B second = new B();
A third = new B();
I fourth = new B();

---

因为B实现了I并扩展了A，所以它可以在任何需要“I”或“A”的地方用作值。

让我们声明两个接口和一个实现了这两个接口的类：

interface I1 { }

interface I2 { }

class C implements I1, I2 { }

对象可以有多种类型

在下面的代码中，可以看到

C

实例的类型为

C

，以及

I1

和

I2

：

C c = new C();

boolean isC = (c instanceof C);   //true
boolean isI1 = (c instanceof I1); //true
boolean isI2 = (c instanceof I2); //true

现在，让我们声明一个类

B

，它也实现了

I1

：

class B implements I1 { }

如果变量被声明为接口的类型，则其值可以引用从实现该接口的任何类实例化的任何对象

如果我们声明类型为

I1

的变量，我们可以将其设置为

C

的实例，然后将其重新分配给

B

的实例：

I1 i1 = new C();
i1 = new B();

我们还可以将其重新分配给

D

的实例，其中

D

扩展了

C

：

i1 = new D();

...

class D extends C { }

---

对象可以有多种类型

考虑以下代码段：

public class MyClass extends ParentClass implements Interface1, Interface2 {    
    //some code    
}

该类可在以下不同位置使用：

MyClass m1 = new MyClass();
ParentClass p = new MyClass();
Interface1 i1 = new MyClass();
Interface2 i2 = new MyClass();

变量被声明为接口的类型，其值可以引用从实现该接口的任何类实例化的任何对象。

考虑前面代码段中的最后两行，Interface1类型的变量可以引用实现该接口的任何对象，因此如果我们有另一个类实现Interface1，比如MyClass2，那么

Interface1 i1 = new MyClass();
Interface1 i2 = new MyClasss2();
i1 = i2;
i1 = new MyClass2();

---

前面的所有赋值都是有效的，因为MyClass和MyClass2实现了Interface1

字符串

实现了多个接口，所以它有多种类型：

String s = "A String";
Comparable<String> comp = s;
CharSequece cs = s;
Serializable ser = s;

以标准Java库中的接口为例。然后，可以为声明为

集合

类型的任何变量分配一个实现

集合

接口的类的对象，例如

数组列表

，

堆栈

。。。有关更多示例，请参见链接文档

对象可以有多种类型

例如：

public class Foo implements Runnable, Callable<Integer> {
  public void run() {}
  public Integer call() {return 1;}
}

Foo foo = new Foo();
Runnable r = foo;
Callable<Integer> c = foo;

非常基本的例子-

List list1=new ArrayList（）；

由于，

ArrayList

实现了List，因此我们可以使用List接口变量，即list1来引用由

ArrayList

创建的对象

public class Foo implements Runnable, Callable<Integer> {
  public void run() {}
  public Integer call() {return 1;}
}

Foo foo = new Foo();
Runnable r = foo;
Callable<Integer> c = foo;

Runnable r = new Foo();
r = Thread.currentThread();   //Thread implements Runnable