java中一个多态的实例 java多态经典例子

当面临一个问题，有多种实现算途径的时候，要想到java中的核心：多态。

多态的思想：

概括地讲，在运用父类引用指向子类对象的情况下，基本上就用到了多态了。

最简单的多态应该是继承：

public class Tank {
public void move() {
System.out.println("I am father");
}
 } 
 public class Tank2 extends Tank{
@Override
public void move(){
System.out.println("I am child a");
 } 
 
 
 public class Client { 

 
public static void main(String[] args) { 

 
Tank t2 = new Tank2(); ///父类引用指向了子类对象 

 
t2.move(); ///父类中的move方法，但实际具体的实现是tank2对象对move的实现。 

 }
}

接口和抽象类的例子：

对于抽象类和接口，有许多类实现这个接口(或者继承这个抽象类)。
在调用的时候，用父类引用指向子类对象的方法。然后，调用对象的方法，编译器就会自动根据这个对象实际属于哪个实现类，
来调出这个类对于接口或者抽象类的具体实现。

例：

public class Address {
private String name;
public Address(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
 }

 定义基类(抽象类)：
 public abstract class Vehicle {
abstract void go(Address address);
 }

 Car对于基类的实现：
 public class Car extends Vehicle{
@Override
public void go(Address address){
System.out.println("Car to " + address.getName());
}
 }

 Plane对于基类的实现：
 public class Plane extends Vehicle{
@Override
void go(Address address) {
System.out.println("Plane to " + address.getName());
}
 }


 Driver中多态：
public void drive(Vehicle v){ ///多态，父类引用指向子类对象，实际传过来的是抽象类Vehicle的子类，或者实现类，然后编译器会根据具体实现类，来找实现方法。
v.go(new Address("杭州(abstract)")); ///此方法在具体的实现中被重写
}

 Test:
 public static void main(String[] args) {
Driver d = new Driver();
d.drive(new Plane()); //实际是Plane对象，则编译器就会找到Plane中，对go的实现
d.drive(new Car()); //实际是Car对象，则编译器就会找到Plane中，对go的实现
}

 输出结果：
 Plane to 杭州(abstract)
 Car to 杭州(abstract)

 事实上，这就是多态所起的作用，可以实现控制反转这在大量的J2EE轻量级框架中被用到，比如Spring的依赖注射机制。
 （通过注入不同的bean，来得到不同的实现类）

 接口与抽象类的区别：

 有个概念，但还没有想到具体实现。
 对于一些共用的，已经有实现了，可以设计成接口。

 上面是抽象类，下面把它转化为接口：

 IVehicle.java
 public interface IVehicle {
public void go(Address address);
 }

 CarImpl.java
 public class CarImpl implements IVehicle{
public void go(Address address) {
System.out.println("CarImpl to " +address.getName());
}
 }

 PlameImpl.java
 public class PlaneImpl implements IVehicle{
public void go(Address address) {
System.out.println("PlaneImpl to " + address.getName());
}
 }

 Driver.java
多态之接口
public void driveI(IVehicle v){
v.go(new Address("杭州(interface)"));
}

 Test.java
 用接口实现
d.driveI(new PlaneImpl());
d.driveI(new PlaneImpl());

 打印结果：
 PlaneImpl to 杭州(interface)
 PlaneImpl to 杭州(interface)

多态的三要素：1.继承 2.重写 3.父类引用指向子类对象

以上就是我目前学习中的总结，如有不足之处，还望多多赐教。