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

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