黑马程序员技术交流社区

标题: instanceof 方法的具体含义？ [打印本页]
作者: asvsass    时间: 2014-3-6 14:50
标题: instanceof 方法的具体含义？
instanceof（）方法不知道什么意思，查阅api 发现不是Object的方法？具体怎么用呢。
作者: 欢欢    时间: 2014-3-6 14:59
instanceof 不是个方法，是个二元运算符。
API查不到的。
A instanceof B    结果为true或者false。
A为对象，B为类。
意思是：A是否为B的实例化对象。
作者: 郝大龙0104    时间: 2014-3-6 15:23
这不是方法   是一种判断    在多态时经常的用   
来判断    一个对象是不是一个类的实例
下面是一个例子希望对你有所帮助
  1. /*
  2. * 基础班的学生：
  3. * 学习，睡觉。
  4. * 高级班学生：
  5. * 学习，睡觉。
  6. * 可以将两类事物进行抽取
  7. */

  9. abstract  class Student {
  10.         public  abstract void study();
  11.         public void sleep(){
  12.                 System.out.println("躺着睡觉");
  13.         }
  14.        
  15. }

  17. class BaseStudent extends Student{
  18.         public void study(){
  19.                 System.out.println("学习基础");
  20.         }
  21.         public void sleep() {
  22.                 System.out.println("zuozheshui");
  23.         }
  24.         public void show(){
  25.                 System.out.println("好好学基础，为了上提高");
  26.         }
  27. }
  28. class AdvStudent extends Student{
  29.         public void study(){
  30.                 System.out.println("学习 adv");
  31.         }
  32. }

  34. class DoSome{
  35.         public static void doSome(Student s){
  36.                 if(s instanceof BaseStudent){
  37.                         BaseStudent b = (BaseStudent)s;
  38.                         s.sleep();
  39.                         s.study();
  40.                         b.show();
  41.                 }
  42.                 if(s instanceof AdvStudent){
  43.                         AdvStudent b = (AdvStudent)s;
  44.                         b.sleep();
  45.                         b.study();
  46.                 }
  47.                
  48.         }
  49. }

  51. public class DuoTai {
  52.         public static void main(String[] args) {
  53.                 Student s = new BaseStudent();
  54.                 DoSome.doSome(s);
  55.         }
  56.        
  57. }
复制代码
作者: xiaochen33520    时间: 2014-3-6 16:17
instanceof 是一个运算符, 一般和 if 语句结合使用，比如if(参数 instanceof 要转化的类型),如果参数可以被转化成这个类型，表示这个条件为真，不能就为假，instanceof经常用于健壮性判断.
作者: ╰つ    时间: 2014-3-6 16:22
instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

　　String s = "I AM an Object!";
　　boolean isObject = s instanceof Object;

　　我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
　　instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

　　public class Bill {//省略细节}
　　public class PhoneBill extends Bill {//省略细节}
　　public class GasBill extends Bill {//省略细节}

　　在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

　　public double calculate(Bill bill) {
　　if (bill instanceof PhoneBill) {
　　//计算电话账单
　　}
　　if (bill instanceof GasBill) {
　　//计算燃气账单
　　}
　　...
　　}
　　这样就可以用一个方法处理两种子类。

　　然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

　　public double calculate(PhoneBill bill) {
　　//计算电话账单
　　}

　　public double calculate(GasBill bill) {
　　//计算燃气账单
　　}

　　所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。
作者: syw02014    时间: 2014-3-6 19:01
java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
用法:result = object instanceof class
参数
Result：布尔类型。
Object：必选项。任意对象表达式。
Class：必选项。任意已定义的对象类。
说明
如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。
例子:
  1. interface A{ }
  2. class B implements A{ }
  3. class C extends B { }
  4. class instanceoftest
  5. {
  6.         public static void main(String[] args)
  7.         {
  8.                 A a=null;
  9.                 B b=null;
  10.                 boolean res;
  11.                 System.out.println("instanceoftest test case 1: ------------------");
  12.                 res = a instanceof A;
  13.                 System.out.println("a instanceof A: " + res);
  14.                 res = b instanceof B;
  15.                 System.out.println("b instanceof B: " + res);
  16.                 System.out.println("\ninstanceoftest test case 2: ------------------");

  18.                 a=new B();
  19.                 b=new B();
  20.                 res = a instanceof A;
  21.                 System.out.println("a instanceof A: " + res);
  22.                 res = a instanceof B;
  23.                 System.out.println("a instanceof B: " + res);
  24.                 res = b instanceof A;
  25.                 System.out.println("b instanceof A: " + res);
  26.                 res = b instanceof B;
  27.                 System.out.println("b instanceof B: " + res);
  28.                 System.out.println("\ninstanceoftest test case 3: ------------------");

  30.                 B b2=(C)new C();
  31.                 res = b2 instanceof A;
  32.                 System.out.println("b2 instanceof A: " + res);
  33.                 res = b2 instanceof B;
  34.                 System.out.println("b2 instanceof B: " + res);
  35.                 res = b2 instanceof C;
  36.                 System.out.println("b2 instanceof C: " + res);
  37.         }
  38. 　}

  40. result:
  41. instanceoftest test case 1: ------------------
  42. a instanceof A: false
  43. b instanceof B: false
  44. instanceoftest test case 2: ------------------
  45. a instanceof A: true
  46. a instanceof B: true
  47. b instanceof A: true
  48. b instanceof B: true
  49. instanceoftest test case 3: ------------------
  50. b2 instanceof A: true
  51. b2 instanceof B: true
  52. b2 instanceof C: true
复制代码
当你拿到一个对象的引用时（例如参数），你可能需要判断这个引用真正指向的类。所以你需要从该类继承树的最底层开始，使用instanceof操作符判断，第一个结果为true的类即为引用真正指向的类。例如下面的例子：
  1. class Person{}
  2. class Student extends Person{}
  3. class Postgraduate extends Student{}
  4. class Animal{}
  5. public class InstanceofTester
  6. {
  7.         public static void main(String[] args)
  8.         {
  9.                 instanceofTest(new Student());
  10.         }
  11.         public static void instanceofTest(Person p)
  12.         {// 判断p的真正类型
  13.                 if (p instanceof Postgraduate)
  14.                 {
  15.                         System.out.println("p是类Postgraduate的实例");
  16.                 }
  17.                         else if(p instanceof Student)
  18.                         {
  19.                                 System.out.println("p是类Student的实例");
  20.                         }
  21.                                 else if(p instanceof Person)
  22.                                 {
  23.                                         System.out.println("p是类Person的实例");
  24.                                 }
  25.                                         else if(p instanceof Object)
  26.                                         {
  27.                                                 System.out.println("p是类Object的实例");
  28.                                         }
  29.         }
  30. }
复制代码







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2