java基础14 多态（及关键字：instanceof）

面向对象的三大特征:

1.封装   （将一类属性封装起来，并提供set()和get()方法给其他对象设置和获取值。或者是将一个运算方法封装起来，其他对象需要此种做运算时，给此对象调用）

2.继承   （继承关系通过extends关键字体现）

3.多态   （父类的引用指向子类的对象，或者接口的引用类型变量指向接口实现类的对象）

---

1、多态的含义

父类的引用指向子类的对象，或者接口的引用类型变量指向接口实现类的对象

2、多态的应用

1.多态应用于形式参数的时候,可以接收更多类型的数据.
    2.多态用于返回值时,可以返回更多类型的数据.

3、多态的好处

提高了代码的拓展性.

4、多态的弊端

虽然提高了扩展性，但是只能使用父类引用指向父类成员。

5、多态的前提

类与类之间有关系，继承或者实现

6、多态体现

1：父类引用变量指向了子类的对象
    2：父类引用也可以接受自己的子类对象

7、类型转换场景的问题

java.lang.ClassCaseException.类型转换失败

8、附录

如果需要访问子类特有的成员,那么需要进行强制类型转换

1、基本数据类型转换:
　　小数据类型------>大数据类型    自动转换
　　大数据类型------>转小数据类型   强制类型转换   

2、引用类型转换：
　　小数据类型------->大数据类型    自动转换
　　大数据类型------->转小数据类型    强制类型转换

9、实现关系下的多态

接口的引用类型变量指向接口实现类的对象
  格式：
    接口 变量 = new 接口实现类的对象

例子：

 interface Dao {  //接口的方法全部都是非静态的方法
     public void add();
     public void delete();
 }

 //接口的实现类
 class UserDao implements Dao{
     public void add(){
         System.out.println("添加员工!!!");
     }
     public void delete(){
         System.out.println("删除员工");
     }
 }

 class Demo2 {
     public static void main(String[] args) {
         //实现关系下的多态
         Dao d=new UserDao(); //接口的引用类型变量指向接口的实现类的对象
         d.add();
         d.delete();
     }
 }

10、实例

例子1：

/*
    1：Father类
        1：非静态成员变量x
        2：静态成员变量y
        3：非静态方法eat,方法体输出父类信息
        4：静态方法speak();方法体输出父类信息
    2：Son类
        1：非静态成员变量x
        2：静态成员变量y
        3：非静态方法eat，方法体输出子类信息
        4：静态方法speak();方法体输出子类信息
*/
class Father {
    int x = 1;
    static int y = 2;

    void eat() {
        System.out.println("开吃");
    }
    static void speak() {
        System.out.println("小头爸爸");
    }
}

class Son extends Father {
    int x = 3;
    static int y = 4;

    void eat() {
        System.out.println("大头儿子很能吃");
    }
    static void speak() {
        System.out.println("大头儿子。");
    }
}

class Demo10 {
    public static void main(String[] args) {
        Father f = new Son(); // 父类引用指向了子类对象。
        System.out.println(f.x); //返回结果：1
        System.out.println(f.y); //返回结果：2

        f.eat(); // 输出的是子类的方法
        f.speak(); // 输出的是父类的方法
    }
}

解析：子类（Son）继承父类（Father）

1：创建Father f=new Son();
1：这就是父类引用指向了子类对象。
2：问f.x=?（非静态）
3：问f.y=?（静态）
4：问f.eat()输出的是子类还是父类信息？（非静态）
5：问f.speak()输出的是子类还是父类信息？（静态）

总结：

1：当父类和子类具有相同的非静态成员变量，那么在多态下访问的是父类的成员变量
2：当父类和子类具有相同的静态成员变量，那么在多态下访问的是父类的静态成员变量     所以：父类和子类有相同的成员变量，多态下访问的都是父类的成员变量。
3：当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的成员方法。
4：当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。

例子2：

 //动物类
 abstract class Animal{
     String name;
     public Animal(String name){
         this.name=name;
     }

     public abstract void run(); //抽象方法
 }
 //老鼠类
 class Mouse extends Animal{
     public Mouse(String name){ //调用父类构造器，目的：获取成员变量name中的值
         super(name);
     }
     public void run(){ //重写父类的抽象方法
         System.out.println(name+"四条腿慢慢走");
     }

     public void dig(){//Mouse子类特有的方法
         System.out.println(name+"老打洞...");

     }
 }
 //鱼类
 class Fish extends Animal{
     public Fish(String name){
         super(name);
     }
     public void run(){ //重写父类的抽象方法
         System.out.println(name+"摇着尾巴游啊游...");
     }
     public void bubble(){ //Fish子类特有的方法
         System.out.println(name+"吹泡泡....");
     }
 }

 class Demo6 {
     public static void main(String[] args) {
         Animal a=new Mouse("米老鼠");//多态,父类的引用指向子类的对象
         a.run();
         //a.dig(); //报错

         Mouse m=(Mouse)a;//强制类型转换
         m.dig(); //如果直接用a.dig()的话，会报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型

         Animal a1=new Fish("金枪鱼");
         Fish f=(Fish)a1;
         print(f);
     }

     //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
     //instanceof
     public static void print(Animal a){//Animal a=new Fish();
         if(a instanceof Fish){
              Fish f=(Fish)a;
              f.bubble();
         }else if(a instanceof Mouse){
             Mouse m=(Mouse)a;
             m.dig();
         }else{
             System.out.println("输入错误");
         }
     }
 }

例子3：instanceof关键字（在末尾）

 //形状类
 abstract class MyShape{//抽象类
     public abstract void getLength(); //抽象方法
     public abstract void getArea(); //抽象方法
 }
 //圆形
 class Circle extends MyShape{
     public final static double PI=3.14; //常量
     double r;
     public Circle(double r){
         this.r=r;
     }

     public void getLength(){
         System.out.println("这是圆形的周长"+2*PI*r);
     }
     public void getArea(){
         System.out.println("这是圆形的面积"+PI*r*r);

     }
 }
 //矩形
 class Rect extends MyShape{
     int width;
     int height;

     public Rect(int width,int height){
         this.width=width;
         this.height=height;
     }
     public void getLength(){
         System.out.println("这是矩形的周长"+2*(width+height));
     }
     public void getArea(){
         System.out.println("这是矩形的面积"+width*height);
     }
     public void t(){
         System.out.println("来咬我啊!!!");
     }
 }

 class Demo5 {
     public static void main(String[] args) {    
         MyShape mp=new Circle(3.0);//多态,父类的引用指向了子类的对象
         mp.getLength();
         mp.getArea();
47　　　　　//方法2
　　　　　Circle c = new Circle(3.0);
         Rect r = new Rect(5,8);
         MyShape m = new Rect(8,3);
         //m.t(); //报错，此处需要强制类型转换
         print(r);
         print(c);//new Circle(3.0)
     }

     //需求1.定义一个函数可以接收任意类型的对象,并且打印图形的面积与周长
     public static void print(MyShape s){//相当于：MyShape s=new Circle(3.0)
         s.getLength();
         s.getArea();
         MyShape m = getShape(1);
     }

     //需求2:定义一个函数可以返回任意类型的图形对象.
     public static MyShape getShape(int i){

         if(i == 1){
             return new Circle(2.0);
         }else if(i == 0){
             return new Rect(6,9);
         }else{
             return null;
         }
     }
 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/8891998.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）