本文目录一览：
- 1、JAVA的多态有什么特点?什么地方适合使用多态？
- 2、谈谈你对Java中的多态的理解.(为什么要使用多态，有什么好处，一般用在什么场合)
- 3、java中的多态 到底怎么使用
- 4、Java中多态的优缺点是什么？
JAVA的多态有什么特点?什么地方适合使用多态？
多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。
如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。
方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。
谈谈你对Java中的多态的理解.(为什么要使用多态，有什么好处，一般用在什么场合)
面向对象编程有三大特性：封装、继承、多态。
封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。
继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。
那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：
所谓多态
就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：
酒 a = 剑南春
酒 b = 五粮液
酒 c = 酒鬼酒
…
这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。
诚然，要理解多态我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。我们定义如下代码：
JNC a = new JNC();
对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？
Wine a = new JNC();
在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。
但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就望尘莫及了。
public class Wine {
public void fun1(){
System.out.println("Wine 的Fun.....");
fun2();
}
public void fun2(){
System.out.println("Wine 的Fun2...");
}
}
public class JNC extends Wine{
/**
* @desc 子类重载父类方法
* 父类中不存在该方法，向上转型后，父类是不能引用该方法的
* @param a
* @return void
*/
public void fun1(String a){
System.out.println("JNC 的 Fun1...");
fun2();
}
/**
* 子类重写父类方法
* 指向子类的父类引用调用fun2时，必定是调用该方法
*/
public void fun2(){
System.out.println("JNC 的Fun2...");
}
}
public class Test {
public static void main(String[] args) {
Wine a = new JNC();
a.fun1();
}
}
-------------------------------------------------
Output:
Wine 的Fun.....
JNC 的Fun2...
从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。
分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。
所以对于多态我们可以总结如下：
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。
对于面向对象而已，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。
多态的实现
2.1实现条件
在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。
Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
2.2实现形式
在Java中有两种形式可以实现多态。继承和接口。
2.2.1、基于继承实现的多态
基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
public class Wine {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Wine(){
}
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return null;
}
}
public class JNC extends Wine{
public JNC(){
setName("JNC");
}
/**
* 重写父类方法，实现多态
*/
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
}
public class JGJ extends Wine{
public JGJ(){
setName("JGJ");
}
/**
* 重写父类方法，实现多态
*/
public String drink(){
return "喝的是 " + getName();
}
/**
* 重写toString()
*/
public String toString(){
return "Wine : " + getName();
}
}
public class Test {
public static void main(String[] args) {
//定义父类数组
Wine[] wines = new Wine[2];
//定义两个子类
JNC jnc = new JNC();
JGJ jgj = new JGJ();
//父类引用子类对象
wines[0] = jnc;
wines[1] = jgj;
for(int i = 0 ; i 2 ; i++){
System.out.println(wines[i].toString() + "--" + wines[i].drink());
}
System.out.println("-------------------------------");
}
}
OUTPUT:
Wine : JNC--喝的是 JNC
Wine : JGJ--喝的是 JGJ
在上面的代码中JNC、JGJ继承Wine，并且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。
我们都知道所有的类都继承自超类Object，toString()方法也是Object中方法，当我们这样写时：
Object o = new JGJ();
System.out.println(o.toString());
输出的结果是Wine : JGJ。
Object、Wine、JGJ三者继承链关系是：JGJ—Wine—Object。所以我们可以这样说：当子类重写父类的方法被调用时，只有对象继承链中的最末端的方法才会被调用。但是注意如果这样写：
Object o = new Wine();
System.out.println(o.toString());
输出的结果应该是Null，因为JGJ并不存在于该对象继承链中。
所以基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。
如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。
2.2.2、基于接口实现的多态
继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。
继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
java中的多态 到底怎么使用
Java中的多态允许父类指针指向子类实例。如：Father obj=new Child();（其中Child是Father的子类）。这样就产生了一个问题——
使用这个父类型的指针访问类的属性或方法时，如果父类和子类都有这个名称的属性或方法，哪一个属性或方法会被调用呢？
最好的办法是实验：
class Father
{
int r;
Father()
{
r=4;
}
void printname()
{
System.out.println("I’m father");
}
}
class Child extends Father
{
int r;
Child()
{
r=5;
}
void printname()
{
System.out.println("I’m Child");
}
}
public class Test
{
public static void main(String[] args)
{
Father obj=new Child();
System.out.println(obj.r);
obj.printname();
}
}
结果输出：
4
I’m Child
实验证明。属性会访问父类的。方法分访问子类的。
这就是多态了。
不要以为Father obj=new Child();这条语句一定会让obj.printname()指向Chlid定义的printname()。实际上，如果你把Father类中的printname()方法删除，这个程序将编译失败。因为Father中的并没有定义printname()这个函数。多态是晚绑定*(见本文最后的资料)的，在Father obj=new Child();这个语句中，如果Father中没有printname()这个函数，就不会为obj建立一个用于调用printname()函数的指针。所以调用obj.printname()会出错。如果Father中有这个函数。指向printname()函数的指针会被创建。在调用obj.printname()时，不会出错，而且，因为obj指向的是new Child()，是个Chld类的实例。所以调用obj.printname()时调用了Child类中定义的printname()。这就是方法的动态绑定。
那么，刚才说到把Father类中的printname()方法删掉后，obj将无法调用Child类中的printname()，因为obj.printname()会编译失败。那么如果我就是需要调用要怎么办呢？其实虽然obj是Father类型的，但是它指向的是一个Child类的实例。那么可以将obj强制类型转换为Child。再调用printname()方法就可以了。
在上面程序中，把Father类中的printname()方法整个删掉，再将obj.printname() 改成 ((Child)obj).printname()后，编译成功，结果输出：
4
I’m Child
两次输出的结果都是I’m Child。
那么如何可以运行Child类中的printname()来输出“I’m Father”呢？
其实只需要将Father obj=new Child();改成Father obj=new Father();就可以了，呵呵。另一个办法就是将Child类中定义的printname()整个删掉。为什么这样可以成功呢？自己想想，嘿嘿。最后会有个这样的思考题。
看到这儿你可能早就想问了：
为什么obj.r是4？为什么不是5？
呵呵。其实很简单。Java中的多态仅为方法而言，成员变量还是使用的父类的成员变量。也就是说，因为“Father obj =……”，所以obj是Father类型的，所以obj里面的r是Father里面的r，所以输出obj.r就是4了。
你又想问：
那么5去哪了？new Child()的时候，不是会把5放到Child的r中吗？
实际上5还是有的。只是obj.r是4而已。想访问Child中的r，把5读出来，可以这样写：
((Child)obj).r
就是把obj由Father型强制转换成了Child型。
OK，方法和属性在多态中是什么样的你都清楚了。现在做个题测试一下吧：
这是J@Whiz1.4的一道题：
class Base {
int i = 99;
public void amethod() {
System.out.println("Base.amethod()");
}
Base() {
amethod();
}
}
public class Derived extends Base {
int i = -1;
public static void main(String argv[]) {
Base b = new Derived();
System.out.println(b.i);
b.amethod();
}
public void amethod() {
System.out.println("Derived.amethod()");
}
}
会输出什么？
先想想，再看答案：
答案：
========================
Derived.amethod()
99
Derived.amethod()
========================
讲解：
这个程序的执行过程是这样的：
第一行：Base b=new Derived();
执行这一行语句的过程中，要构造Derived这个类，而它有父类Base，所以先构造Base类。构造Base类的默认构造函数有定义。内容是执行amethod()方法。
实际上，Base类构造方法中的执行amethod()，相当于执行this.amethod()，在这个程序中，就相当于执行b.amethod()。而b是Base类型的，指向了Derived类的实例的指针。所以跟据上面我们的总结，实际上执行的是Derived类的amethod()函数。所以，第一行“Base b=new Derived();”执行完，输出"Derived.amethod()"。
第二行：System.out.println(b.i);
这个很简单，成员变量，不考虑多不多态，只看它定义时前面的类型。这个程序中是Base b，所以b.i就是Base类中的i。输出99
第三行：b.amethod();
调用Derived类中的amethod()方法。
其实这行就是迷惑你的，如果没有这一行。你可能会警觉起来——咦？为什么这儿定义一个amethod()呢？没有地方调用它啊？
有了这行代码，就会使你放松警惕。觉得，啊。定义了这个是用来让b.amethod();调用的。
Java中多态的优缺点是什么？
多态的好处:扩展性强,父类的变量可以赋值不同的子类对象,而调用不同的子类重写的方法
多态的弊端:不能使用子类特有的功能
这就是Java多态的优缺点了，想学习Java，自学看黑马程序员，有视频，有学习路线，让你学习不迷茫！
