java基础复习 之 多态

1．  什么是多态？为什么要用多态？

　　a)         多态是Java面向对象的三大特性（封装、继承、多态）之一。封装和继承几乎都是为多态而准备的。

　　b)         多态的定义: 指允许不同类的对象对同一消息做出的响应。即同一消息可以根据发送对象的不同而采取多种不同的行为方式。

　　c)         在java中存在多态的现象有：

　　　　i.             方法的重载

　　　　ii.              方法的重写

　　　　iii.              转型（向上转型，和向下转型）

　　　　iv.              接口

　　　　v.              抽象类

2．  多态的作用

　　a)         应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。

　　b)         派生类的的功能可以被基类方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。

　　c)         概括的说多态就是为了消除类型之间的耦合关系。

3．  多态存在的三个必要条件

　　a)         要有继承；（发生在基类与子类之间：转型，接口，抽象类）

　　b)         要有重写；（发生在同一个类中）

　　c)         父类引用指向子类对象；

4．  多态的一些现象

　　a)         方法的重载：

　　　　例子：问题描述：写一个类实现整型，长整型，浮点型，双精度浮点型，字符串的相加。

public class Addition {
    /**
     * 两整数相加
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static int add(int num1, int num2) {
        return num1 + num2;
    }

    /**
     * 两个双精度浮点数相加
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static double add(double num1, double num2) {
        return num1 + num2;
    }

    /**
     * 两个长整型数相加
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static long add(long num1, long num2) {
        return num1 + num2;
    }

    /**
     * 两个浮点数相加
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static float add(float num1, float num2) {
        return num1 + num2;
    }

    /**
     * 两个字符串相加
     * 
     * @param num1
     * @param num2
     * @return
     */
    public static String add(String num1, String num2) {
        return num1 + num2;
    }

}

　　　　重载的特点：

　　　　　　->发生在同一个类中

　　　　　　->出现了方法名相同，参数列表不同（参数的个数，参数类型，参数顺序）

　　b)　　方法的重写

          例子：写一个基类Vehicle可以行驶（run），可以停止（stop）。再写一个自行车类（bike）继承自基类Vehicle,重写行驶（run），和停止（stop）

/**
 * 交通工具类
 * @author Administrator
 *
 */
public class Vehicle {
    
    
    public void run(){
        System.out.println("交通工具可以行驶.");
    }
    
    public void stop(){
        System.out.println("交通工具可以停止.");
    }
}

/**
 * 
 * @author Administrator
 *
 */
public class Bike extends Vehicle{
    
    /*
     * 实现了run方法的重写
     * (non-Javadoc)
     * @see com.test.www.Vehicle#run()
     */
    @Override
    public void run() {
        System.out.println("自行车可以骑着行驶.");
    }
    
    /*
     * 实现了stop方法的重写
     * (non-Javadoc)
     * @see com.test.www.Vehicle#stop()
     */
    @Override
    public void stop() {
        System.out.println("自行车脚磨擦地面停止.");
    }
    
}

　　　　重写的特点

　　　　　　->发生在父类和子类之间，在子类中出现与父类重名的方法

　　　　　　->方法名，参数列表，和返回值都相同。方法体不相同。

　　　　　　->子类重写的方法的访问控制权限不能严于父类。（比如：父类的run方法的访问权限是public,那么子类的run方法的访问权限就不能是private,protected.）

　　　　c)　　转型

　　　　例子：

/**
 * 基类
 * @author Administrator
 *
 */
public class Animal {
    int legs;
    public void eat(){
        System.out.println("吃饭");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    
    public void catchM(){
        System.out.println("猫抓鱼");
    }
}

public  class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗追着咬猫");
    }
    
    public void lookDoor(){
        System.out.println("看大门");
    }
    
}

public class Test {
    
    public static void f1(Animal animal){
　　　　　　//父类引用子类对象，调用的是子类的方法
　　　　　　//向上转型（即子类向父类转型，这是一种自动转型。向后兼容，父类引用子类方法） 多态的一种形式
        animal.eat();
        if(animal instanceof Cat){
            //下转型（父类向子类转型，这是一种强制转型）
            ((Cat) animal).catchM();
        }
        if(animal instanceof Dog){
            ((Dog) animal).lookDoor();
        }
    }
    
    public static void main(String[] args) {
        Animal myDog=new Dog();//多态的一种形式
        Animal myCat=new Cat();
        
        f1(myDog);
        f1(myCat);
    }
}

　　　　转型总结：

　　　　　　->上转型：从子类向父类转型（自动类型转换）（向后兼容，父类引用子类方法）

　　　　　　->下转型：从父类向子类转型 （强制类型转换）