Java多态和实现接口的类的对象赋值给接口引用的方法(推荐)

接口的灵活性就在于“规定一个类必须做什么，而不管你如何做”。

我们可以定义一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时，它会根据实际引用的类的实例来判断具体调用哪个方法，这和上述的超类对象引用访问子类对象的机制相似。

//定义接口intera
interface intera
{
　void fun();
}
//实现接口intera的类b
class b implements intera
{
　public void fun()
　{
　　system.out.println(“this is b”);
　}
}

//实现接口intera的类c
class c implements intera
{
　public void fun()
　{
　　system.out.println(“this is c”);
　}
}

class test
{
　public static void main(string[] args)
　{
　　intera a;
　　a= new b();
　　a.fun();
　　a = new c();
　　a.fun();
　}
}

输出结果为：

this is b
this is c

上例中类b和类c是实现接口intera的两个类，分别实现了接口的方法fun()，通过将类b和类c的实例赋给接口引用a，实现了方法在运行时的动态绑定，充分利用了“一个接口，多个方法”，展示了java的动态多态性。

需要注意的一点是：java在利用接口变量调用其实现类的对象的方法时，该方法必须已经在接口中被声明，而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配。

--------------------------------------------------------------------------------

扩展

java运行时多态性：继承和接口的实现

java是面向对象的语言，而运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制，下面就继承和接口实现两方面谈谈java运行时多态性的实现。

一、通过继承中超类对象引用变量引用子类对象来实现

举例说明：

//定义超类supera 
class supera {
  int i = 100;

  void fun() {
    system.out.println(“this is supera”);
  }
}

//定义supera的子类subb 
class subb extends supera {
  int m = 1;

  void fun() {
    system.out.println(“this is subb”);
  }
}

//定义supera的子类subc 
class subc extends supera {
  int n = 1;

  void fun() {
    system.out.println(“this is subc”);
  }
}

class test {
  public static void main(string[] args) {
    supera a;
    subb b = new subb();
    subc c = new subc();
    a = b;
    a.fun();
    (1)
    a = c;
    a.fun();
    (2)
  }
}  

运行结果为：

this is subb

this is subc

上述代码中subb和subc是超类supera的子类，我们在类test中声明了3个引用变量a, b, c，通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：“为什么(1)和(2)不输出：this is supera”。java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

所以，不要被上例中(1)和(2)所迷惑，虽然写成a.fun()，但是由于(1)中的a被b赋值，指向了子类subb的一个实例，因而(1)所调用的fun()实际上是子类subb的成员方法fun()，它覆盖了超类supera的成员方法fun()；同样(2)调用的是子类subc的成员方法fun()。

另外，如果子类继承的超类是一个抽象类，虽然抽象类不能通过new操作符实例化，但是可以创建抽象类的对象引用指向子类对象，以实现运行时多态性。具体的实现方法同上例。

不过，抽象类的子类必须覆盖实现超类中的所有的抽象方法，否则子类必须被abstract修饰符修饰，当然也就不能被实例化了。

二、通过接口类型变量引用实现接口的类的对象来实现

接口的灵活性就在于“规定一个类必须做什么，而不管你如何做”。我们可以定义一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时，它会根据实际引用的类的实例来判断具体调用哪个方法，这和上述的超类对象引用访问子类对象的机制相似。

举例说明：

//定义接口intera 
interface intera
{
  void fun();
}
//实现接口intera的类b 
class b implements intera
{
  public void fun()
  {
    system.out.println(“this is b”);
  }
}
//实现接口intera的类c 
class c implements intera
{
  public void fun()
  {
    system.out.println(“this is c”);
  }
}
class test
{
  public static void main(string[] args)
  {
    intera a;
    a= new b();
    a.fun();
    a = new c();
    a.fun();
  }
} 

输出结果为：

this is b

this is c

上例中类b和类c是实现接口intera的两个类，分别实现了接口的方法fun()，通过将类b和类c的实例赋给接口引用a而实现了方法在运行时的动态绑定，充分利用了“一个接口，多个方法”展示了java的动态多态性。

需要注意的一点是：java在利用接口变量调用其实现类的对象的方法时，该方法必须已经在接口中被声明，而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配。

结束语：以上就是java运行时多态性的实现方法，大家在编程过程中可以灵活运用，但是在性能要求较高的代码中不提倡运用运行时多态，毕竟java的运行时动态方法调用较之普通的方法调用的系统开销是比较大的。

--------------------------------------------------

java静态方法不具有多态性详解

动态绑定机制使得基类的引用能够指向正确的子类对象，从而使得面向基类编程成为可能。

然而动态绑定在以下两种情况会失效。

1、基类方法是private或final修饰的

这个很好理解，因为private说明该方法对子类是不可见的，子类再写一个同名的方法并不是对父类方法进行复写(override)，而是重新生成一个新的方法，也就不存在多态的问题了。同理也可以解释final，因为方法同样是不可覆盖的。

2、方法是static修饰的

代码如下所示.

class base {
 public static void staticmethod() {
  system.out.println("base staticmehtod");
 }

 public void dynamicmehtod() {
  system.out.println("base dynamicmehtod");
 }
}

class sub extends base {
 public static void staticmethod() {
  system.out.println("sub staticmehtod");
 }

 public void dynamicmehtod() {
  system.out.println("sub dynamicmehtod");
 }
}

public class tj4 {
 public static void main(string args[]) {
  base c = new sub();
  c.staticmethod();
  c.dynamicmehtod();
 }
}

输出结果如下：

 base staticmehtod
 sub dynamicmehtod

输出结果并不像设想的那样，输出 “sub staticmehtod”。因为静态方法是与类而不是与某个对象相关联，c.staticmethod();等同于car.staticmethod(); 所以尽量不要使用实例变量去调用静态方法，避免混淆。

以上这篇java多态和实现接口的类的对象赋值给接口引用的方法(推荐)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。