java多态

面向对象的三个基本特征--封装、继承、多态

//汽车接口   
interface Car {   
    // 汽车名称   
    String getName();   
  
    // 获得汽车售价   
    int getPrice();   
}   
  
// 宝马   
class BMW implements Car {   
    public String getName() {   
        return "BMW";   
    }   
  
    public int getPrice() {   
        return 300000;   
    }   
}   
  
// 奇瑞QQ   
class CheryQQ implements Car {   
    public String getName() {   
        return "CheryQQ";   
    }   
  
    public int getPrice() {   
        return 20000;   
    }   
}   
  
// 汽车出售店   
public class CarShop {   
    // 售车收入   
    private int money = 0;   
  
    // 卖出一部车   
    public void sellCar(Car car) {   
        System.out.println("车型：" + car.getName() + "  单价：" + car.getPrice());   
        // 增加卖出车售价的收入   
        money += car.getPrice();   
    }   
  
    // 售车总收入   
    public int getMoney() {   
        return money;   
    }   
  
    public static void main(String[] args) {   
        CarShop aShop = new CarShop();   
        // 卖出一辆宝马   
        aShop.sellCar(new BMW());   
        // 卖出一辆奇瑞QQ   
        aShop.sellCar(new CheryQQ());   
        System.out.println("总收入：" + aShop.getMoney());   
    }   
}  

继承是多态得以实现的基础。从字面上理解，多态就是一种类型（都是Car类型）表现出多种状态。

将一个方法调用同这个方法所属的主体（也就是对象或类）关联起来叫做绑定，分前期绑定和后期绑定两种。
前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和final方法，注意，这里也包括private方法，因为它是隐式final的。
后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

重载(overloading)和重写(overriding) 

实现多态，有二种方式：覆盖，重载

型构就是指方法的组成结构，具体包括方法的名称和参数，涵盖参数的数量、类型以及出现的顺序，但是不包括方法的返回值类型，访问权限修饰符，以及abstract、static、final等修饰符。

比如下面两个就是具有相同型构的方法：

public void method(int i, String s) {   
    // do something   
}   
  
public String method(int i, String s) {   
    // do something   
}  

这两个就是具有不同型构的方法：

public void method(int i, String s) {   
    // do something   
}   
  
public void method(String s, int i) {   
    // do something   
}  

重写，英文名是overriding，是指在继承情况下，子类中定义了与其基类中方法具有相同型构的新方法，就叫做子类把基类的方法重写了。这是实现多态必须的步骤。
重载，英文名是overloading，是指在同一个类中定义了一个以上具有相同名称，但是型构不同的方法。在同一个类中，是不允许定义多于一个的具有相同型构的方法的。