Java 多态/向下转型/instanceof

1. 多态

1.1 概述

多态：事务的不同形态，如动物，其有多种形态：猫，狗之类的；

1.2 使用方法

虚拟方法（父类被重写的方法在多态中叫做虚拟方法）调用：

父类引用指向子类对象（子类对象赋给父类引用），

即 ” 编译看左边，执行看右边“；

以下是虚拟方法与正常方法的简单对比：

正常方法：

Animal a = new Animal ();

虚拟方法：

Animal a = new Dog;

1.3 使用前提

1. 面向对象的继承性；

2. 重写父类方法；

3. 对象的多态性只适用于方法，不适用于属性，可认为属性没有被重写；

以下是关于动物，猫与狗三类结合多态性的案例：

/**动物类*/
public class Animal {int age;public Animal(){};public void eat(){System.out.println("动物需要补充能量。");}public void sleep(){System.out.println("动物需要睡觉。");}
}
/**狗狗类*/
class Dog extends Animal{@Overridepublic void eat(){System.out.println("狗爱吃骨头！");}@Overridepublic void sleep(){System.out.println("狗闭着眼睛睡觉！");}public void type(){System.out.println("汪星人最可爱的啦！");}
}
/**猫猫类*/
class Cat extends Animal{@Overridepublic void eat(){System.out.println("猫爱吃鱼！");}@Overridepublic void sleep(){System.out.println("猫躺着睡觉！");}public void type(){System.out.println("猫猫也很可爱的啦！");}
}
class AnimalTest{public static void main(String[] args) {
//        创建动物的对象Animal an = new Animal();an.eat();an.sleep();
//        创建狗狗的对象Dog d = new Dog();d.eat();d.sleep();System.out.println("=====================");
//        多态：事物的不同形态；如 动物 可以是 猫，可以是 狗，也可以是其他Animal a = new Dog();
//        使用：1. 父类引用指向子类对象（子类对象赋给父类引用）
//              2. 编译看左边，eat/sleep 方法父类中创建过，
//                 执行看右边：但执行的是子类重写的方法；a.eat();a.sleep();
//        报错：type 是子类独有的，不符合 “编译在左边”，不符多态的使用，因此会报错
//        a.type();}
}

2. 多态的体现

简而言之，多态的使用体现在将子类对象赋给父类，

通过形参为父类，使用匿名对象的方法，避免为多个对象重载，

进而调用不同子类的重写方法，实现不同的功能，

以此降低代码的冗余，提高代码的复用性；

public class multipleTypePeople {private String name;private int age;
//    构造方法public multipleTypePeople(){}public multipleTypePeople(String name,int age){this.age = age;this.name = name;}
//    set/get 方法public void setName(String name){this.name = name;}public String getName(){return name;}public void setAge(int age){this.age = age;}public int getAge(){return age;}
//    方法public void eat(){System.out.println("吃饭长身体！");}public void sleep(){System.out.println("睡眠不足有害身体健康！");}
}
class teacher extends multipleTypePeople{@Overridepublic void eat(){System.out.println("教师也很累！");}@Overridepublic void sleep(){System.out.println("教师睡眠不足！");}
}
class Student extends multipleTypePeople{@Overridepublic void eat(){System.out.println(" 学生也累啊！");}@Overridepublic void sleep(){System.out.println("学业压力也很大！");}
}
class mulTest{public static void main(String[] args) {
//        multipleTypePeople mt = new teacher();mulTest mt = new mulTest();mt.func(new teacher());//mulTest mt = new teacher();mt.func(new Student());//mulTest mt = new student();// 避免为多个对象重载,降低代码的冗余，提高代码的复用性
//        System.out.println("=======================");
//        teacher t = new teacher();
//        t.eat();
//        t.sleep();
//        System.out.println("=======================");
//        Student s = new Student();
//        s.eat();
//        s.sleep();}public void func(multipleTypePeople mt){//形参为父类，使用匿名对象的方法mt.eat();mt.sleep();}
}

3. 向下类型转换

以上多态的使用，均属于向上类型转换：

如 Animal a = new Dog ;

将范围小的 Dog 类赋值给范围大的 Aniaml 类；

3.1 作用

解决无法调用子类特有的方法或属性的问题；

情景：如下动物类，狗类以及测试类。

通过子类对象赋给父类引用，

发现无法通过对象调用子类特有的属性和方法；

因为有了对象的多态性之后，内存虽然加载了子类的结构，

但对象声明为父类类型，只能调用父类的属性和子类的重写方法，

无法调用子类特有的的结构；

class reAnimal {int age;public reAnimal(){};public void eat(){System.out.println("动物需要补充能量。");}public void sleep(){System.out.println("动物需要睡觉。");}
}
class reDog extends reAnimal{//    特有的属性public String name;@Overridepublic void eat(){System.out.println("狗爱吃骨头！");}@Overridepublic void sleep(){System.out.println("狗闭着眼睛睡觉！");}//    特有的方法public void type(){System.out.println("汪星人最可爱的啦！");}public void color(String color){System.out.println("狗狗的颜色是" + color);}
}
class reAnimalTest{public static void main(String[] args) {reAnimal ra = new reDog();
//      无法调用子类特有的方法或属性；因为编译时，rat 是 reAnimal 类，只能调用父类的结构ra.name = "团子";ra.color("黄色");}
}

3.2 格式

子类子类对象 = （子类）父类对象

理解：

赋值运算符两边数据类型要么相同，

要么右边数据类型可以自动上升为左边，

显然，向下类型转换不能完成，

因此使用（），实现强制转换；

4. instanceof 关键字

4.1 引入

使用向下类型转换需要强制类型转换，

强制类型转换总伴随缺点，

对其他子类再实现向下类型转换

就会出现异常；

如下：对狗向下类型转换之后，再对猫实现向下类型转换，就会发生异常；

class reAnimal {int age;public reAnimal(){};public void eat(){System.out.println("动物需要补充能量。");}public void sleep(){System.out.println("动物需要睡觉。");}
}
class reCat extends reAnimal{@Overridepublic void eat(){System.out.println("猫爱吃鱼！");}@Overridepublic void sleep(){System.out.println("猫躺着睡觉！");}public void type(){System.out.println("猫猫也很可爱的啦！");}
}
class reDog extends reAnimal{//    特有的属性public String name;@Overridepublic void eat(){System.out.println("狗爱吃骨头！");}@Overridepublic void sleep(){System.out.println("狗闭着眼睛睡觉！");}//    特有的方法public void type(){System.out.println("汪星人最可爱的啦！");}public void color(String color){System.out.println("狗狗的颜色是" + color);}
}
class reAnimalTest{public static void main(String[] args) {reAnimal ra = new reDog();
//      可以调用父类的属性ra.age = 12;
//       向下类型转换reDog rd = (reDog) ra;rd.name = "大黄";rd.color("黄色");
//        缺点：可能出现异常reCat rc = (reCat) ra;rc.eat();}
}

4.2 作用

为避免向下转型出现异常，

在向下转型之前，

常用 instanceof 判断，

结果为 true ，进行向下转型；

结果为 false ，不进行向下转型；

5. 练习

public class GeoTest {protected String color;protected double weight;protected GeoTest(){}protected GeoTest(String color){this.color = color;this.weight = weight;}public void setColor(String color){this.color = color;}public String getColor(){return color;}public void setWeight(double weight){this.weight = weight;}public double getWeight(){return weight;}public double findArea(){return 0;}
}class Circle extends GeoTest{private double radius;public Circle(){}public Circle(String color,double radius){super(color);this.radius = radius;}public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}@Overridepublic double findArea(){return Math.PI*radius*radius;}
}class MyRectangle extends GeoTest{private double width;private double height;public MyRectangle(){}public MyRectangle(String color,double width,double height){super(color);this.width = width;this.height = height;}public void setWidth(double width){this.width = width;}public double getWidth(){return width;}public void setHeight(double height){this.height = height;}public double getHeight(){return height;}@Overridepublic double findArea(){return width * height;}
}
class GeomeTest{public static void main(String[] args) {GeomeTest get = new GeomeTest();MyRectangle mt = new MyRectangle("白色",10,10);Circle cl = new Circle("紫色",12);get.equalArea(cl,mt);//GeoTest gt1 = new MyRectangle,GeoTest gt2 = new Circleget.displayGeomeArea(cl);//GeoTest gt = new Circleget.displayGeomeArea(mt);//GeoTest gt = new MyRectangle}public void equalArea(GeoTest gt1,GeoTest gt2){System.out.println(gt1.findArea() == gt2.findArea());}public void displayGeomeArea(GeoTest gt){System.out.println(gt.findArea());}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/4603.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！