Java基础提高篇（二）多态

在面向对象的程序设计语言中，多态是继数据抽象和继承之后的第三种特征。

不同类的对象对同一消息作出不同的响应就叫做多态。

多态存在的三个条件

1、有继承关系　　

2、子类重写父类方法　　

3、父类引用指向子类对象

多态方法调用允许一种类型表现出与其他相似类型之间的区别，只要它是从同一基类导出而来的，这种区别是根据方法行为的不同而表现出来的，虽然这些方法都可以通过同一个基类来调用。

看一个简单的多态例子

enum Ball{
    BASKETBALL,FOOTBALL
}
class Sport{
    public void play(Ball ball){
        System.out.println("Sport------"+ball);
    }
}
class BaskSport extends Sport{
    @Override
    public void play(Ball ball) {
        System.out.println("BaskSport-------"+ball);
    }
}

public class Demo1 {
    public static void p(Sport s){
        s.play(Ball.BASKETBALL);
    }
public static void main(String[] args) {
        BaskSport baskSport=new BaskSport();
        p(baskSport);
    }
}

输出: BaskSport——-BASKETBALL

Demo1.p()接收一个Sport引用，同时也可以接收任何Sport的导出类，当将BaskSport引用传递给p（）时，由于这是向上转型，是允许的，向上转型可能会缩小接口，但不会比父类的全部接口更窄。

多态的二个缺陷

1.“覆盖”私有方法

public class Demo1 {
private void fun(){
    System.out.println("Demo1的私有fun方法");
}   
public static void main(String[] args) {
        Demo1 demo1 = new Zi();
        demo1.fun();
    }
}
class Zi extends Demo1{
    public void fun(){
        System.out.println("Zi的fun方法");
    }
}

输出:Demo1的私有fun方法

按道理，应该输出”Zi的fun方法”才对，但是这里有个陷阱就是Demo1的fun方法是私有的，无法被覆盖，而Zi类中的fun是新的方法。所以:只有非private方法才可以被覆盖。

2.域和静态方法

只有普通方法的调用可以是多态的，域和静态方法不能是多态的。

class NBA{
    public String location="USA";
    public void f(){
        System.out.println(location);
    }
}
class CBA extends NBA{
    public String location="CBA";
    public void f(){
        System.out.println(location);
    }
}
public class Demo1 {

public static void main(String[] args) {
         NBA nba = new CBA();
         String location = nba.location;
         System.out.println(location);
         nba.f();
    }
}

输出:

USA
CBA

可以看到，当子类对象转型为父类引用时，任何域访问操作都将由编译器解析，因此不是多态的。其实在实际开发过程中，我们不会将域设置为public的，一般设置成private,因此不能直接访问它们，只能通过调用方法访问。

如果某个方法是静态的，它的行为就不具有多态性

class NBA{
    public static void f1(){
        System.out.println("NBA");
    }
    public void f2(){
        System.out.println("NBA----f2");
    }
}
class CBA extends NBA{
    public static void f1(){
        System.out.println("CBA");
    }
    public void f2(){
        System.out.println("CBA----f2");
    }
}
public class Demo1 {

public static void main(String[] args) {
        NBA nba = new CBA();
        nba.f1();
        nba.f2();
    }
}

输出:

NBA
CBA----f2

**
静态方法是与类，而非与单个对象相关联的。**

向下转型

class NBA{
    public void f1(){}
}
class CBA extends NBA{
    public void f1(){}
    public void f2(){}
}
public class Demo1 {

public static void main(String[] args) {
        NBA nba = new NBA();
        nba.f1();
        ((CBA)nba).f2();
    }
}

重点是这句:((CBA)nba).f2();

如果单纯的nba.f2();那么无法编译，因为NBA类并没有f2()方法，所以必须进行向下转型，转换为CBA类型的，因为CBA类型有f2()。

向上转型和向下转型其实很好理解，小的—>大的，大的—>不能说是小的。毕竟中国是上海的，这句话要被笑话的。

友情链接:
谈谈多态