简单说说java多态

多态有3个条件：
1:继承
2:重写(重写父类继承的方法)
3:父类引用指向子类对象

 

为什么会出现多态？

Java 中的引用变量有两个类型，一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时的类型与运行时的类型不一致就会出现所谓的多态。（Polymorphism)

例题如下：

 

现实生活中也有多态的原型：例如一个父亲F有两个孩子S1和S2，而父亲又可以代表孩子做一些事情，即F即可以代表S1也可以代表S2，因此F具有一定的多态性。在Java中多态大多是指对象变量的多态，即一个F类型的变量既可以指向F类型的对象也可以指向S1、S2类型的对象。（F与S1、S2之间需要存在继承关系）

注意：除了上述多态形式外，一个接口类型变量也可以指向其实现类的实例，这也是多态的一种表现。

 

 

Java多态性探悉

一、基本概念

  多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
  通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

  java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 

  1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。
  2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。


二、Java多态性实现机制

  SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：
  一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；
  另一个指针指向一块从java堆中为分配出来内存空间。

三、总结

  1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

  DerivedC c2=new DerivedC();
  BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类
  a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法

  分析：
  * 为什么子类的类型的对象实例可以覆给超类引用？
  自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
  * a.play()将执行子类还是父类定义的方法？
  子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。

  在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。

  2、不能把父类对象引用赋给子类对象引用变量

  BaseClass a2=new BaseClass();
  DerivedC c1=a2;//出错

  在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
  c1=(DerivedC)a2; 进行强制转化,也就是向下转型. 

  3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
  你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
  其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
  例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()）

  分析：
  当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
  这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。


  4、Java与C++多态性的比较

  jvm关于多态性支持解决方法是和c++中几乎一样的，
  只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。

  Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成：从父类继承的虚拟函数和子类自己的虚拟函数。
  虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。

  Java的所有函数，除了被声明为final的，都是用后期绑定。
  C++实现多态性，使用关键字virtual，为了引起晚捆绑，使用虚函数。若一个函数在基类被声明为virtual，则所有子类中都是virtual的。对虚函数的重定义成为越位。

网摘：

态可以分为变量的多态,方法的多态,类的多态.我这里强调的是类的多态,这是我们在以后的工作中经常回用到的

首先,有这样一个系统:有个学生工作从达内毕业了,作的还不错.买了辆捷达汽车.这个系统应该如何设计呢?
按照OO的思想,我们会抽象出来一个类,表示捷达汽车,其中有个run()方法
public class JD{
public void run(){
       System.out.println("JD在以120迈的速度在run");
}
}
我们还会抽象出一个类,来代表人.其中有个drive()方法,需要一个汽车类型作为参数,我们先传入一个JD类型的参数

// 这是我们的核心业务类
public class Person{
public void drive(JD jd){
       jd.run();
}

public static void main(String args[]){
   Person p =new Person();
   JD jd = new JD();
   p.drive(jd);
}
}

如果你写出这样的代码的话,恭喜你!你中大奖了!---------------------你会被项目经理砍死的!!!!!!!

项目经理为什么会砍你呢?
因为你写的代码偶合性太强了!

如果我们的需求变了,这个学生后来更有钱了,买了一两Benz.那么我们以前的系统怎么办啊.不要指望你作的系统永远不会变化
我们的系统只能修改!这就是项目经理砍你的原因
我们的系统会增加一个Benz类,也有个run()方法

public class Benz{
public void run(){
       System.out.println("Benz在以200迈的速度在run");
}
}

我们的核心业务类也要修改

public class Person{

    /*
public void drive(JD jd){
       jd.run();
}
*/

public void drive(Benz b){
       b.run();
}

public static void main(String args[]){
   Person p =new Person();
   Benz b = new Benz();
   p.drive(b);
}
}

以后的情况,我们可以把车抽象出来:
public abstract class Driver{
   /*属性*/
   public void run();//让子类来运行
}

public Benz extends Driver{
   public void run(){
System.out.println("Benz在以200迈的速度在run");
   }
}
public JD extends Driver{
   public void run(){
System.out.println("JD is running...");
   }
}

public class Person{
private Driver driver;
public Person(){

}
public Person(Driver driver){
   this.driver = driver;
}
public void drive(){
       driver.run();
}
public void setDriver(Driver driver){//运用参数多态,以后不管买什么车都可以
   this.driver = driver;
}

public static void main(String args[]){
   Person p =new Person();
   JD jd = new JD();//刚开始没钱就买辆JD吧
   p.setDriver(jd);
   p.driver();
   Benz benz = new Benz{();//有钱换车了
   p.setDriver(benz);
   p.driver();
}
}

什么是多态? 
简单的说:就是用基类的引用指向子类的对象

提问:多态可以用在什么地方呢?
回答:可以用在方法的参数中和方法的返回类型中

其中方法的参数楼上的兄弟已经给出了代码.我这里给出在方法的返回类型中如何使用多态

上面的例子中,不管是JD还是Benz都是我们自己直接new出来的.我们可以设计一个工厂类,专门生成汽车

/**
*   我们将多态使用在方法的返回类型中
*   Car可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口
*/
public class CarFactory{
public Car factory(String carName){
   if(carName.equals("JD")){
      return new JD();
   }else if(carName.equals("Benz")){
      return new Benz();
   }else{
      System.out.println("对比起,不伺候");
      return null;
   }
}
}

这实际上就是设计模式中的简单工厂模式!

另外,我我们在JDK中可以大量的看到多态的应用,比如在Object类中的equals(Object obj)方法中,参数是个Object

类型的参数.因为Object是Java中所有类的基类.,但是才传入参数的时候,可以传入任何一个类的对象
这就是多态的应用!

使用多态可以解决项目中紧偶合的问题,提高程序的课扩展性.是OCP原则的一个具体的实现