继承问题

Question

public class A
{
  public void m()
  {
     if(this instanceof A)
     {
      System.out.println("A");
      }
     if(this instanceof B)
     {
      System.out.println("B")
     }
  }  public static void main(String[] args)
  {
    A a=new B();
    a.m();
  }
}class B extends A
{
  public void m()
  {
   super.m();
  }
}输出结果
A
B
why?
不解中！。

Answer 1

public class A 
{ 
  public void m() 
  { 
    if(this instanceof A) //实际传进来的是B类对象， X instanceof Y ：判断X是否是Y或者Y的子类的一个实例，这里显然是true
    { 
      System.out.println("A"); 
      } 
    if(this instanceof B) //同上，也是true
    { 
      System.out.println("B") 
    } 
  }   public static void main(String[] args) 
  { 
    A a=new B(); //父类引用指向子类对象，这里实际上是一个B类对象
    a.m(); //动态存在，因为子类B重写了父类A的m()方法。
  } 
} class B extends A 
{ 
  public void m() 
  { 
  super.m(); 
  } 
} 

Answer 2

X instanceof Y ：判断X是否是Y或者Y的子类的一个实例，这里显然是true,而程序中的this实际上指向的是B的一个实例

Answer 3

我觉得因为A B 的父子类关系，经过A a=new B(); 后 a即是A的实例又是B的实例~~

Answer 4

关键是这句：
XXX instanceof DDD
这个操作符判断的是当前的XXX引用的实际对象。
如果引用的实际对象是DDD(可能是接口)类型的对象
或者是DDD类型的子类的对象，则返回真，否则返回假。
在你的程序里边,
你的a引用的实际对象是B类型的对象，所以
第一个判断if(this instanceof A){ 
      System.out.println("A"); 
      } a所引用的实际对象是A的子类的对象，所以返回真，输出A；
第二个判断：
if(this instanceof B){ 
      System.out.println("A"); 
      } 
[/code]
a所引用的实际对象是B类的对象，所以也返回真，输出B；

Answer 5

public class A 
{ 
  public void m() 
  { 
    if(this instanceof A) //instanceof 　是判断实例是否属于那个类。当然，这两个判断就是true
    { 
      System.out.println("A"); 
      } 
    if(this instanceof B) 
    { 
      System.out.println("B") 
    } 
  }   public static void main(String[] args) 
  { 
    A a=new B(); //父类引用子类，　a只能调用A类中的方法和B类重载的方法。
    a.m(); 
  } 
} class B extends A 
{ 
  public void m() 
  { 
  super.m(); //m 方法重载了，　a.m()调用这个方法，　而super.m(); 调用父类的m()；方法
  } 
} 

Answer 6

public class A 
{ 
public A()
{
System.out.println("!!!!!!!!");
}
  public void m() 
  { 
    if(this instanceof A) 
    { 
      System.out.println("A"); 
      } 
    if(this instanceof B) 
    { 
      System.out.println("B") 
    } 
  }   public static void main(String[] args) 
  { 
    A a=new B(); 
    a.m(); 
  } 
} 
A a=new B();
这要从构造函数看，A是父类，在得到new B的子类，其实程序进入的时候是从A类的构造函数出现的，你可以从A的构造函数输出一句话，肯定会出现在A、B之前，然后你在B的构造函数输出一句话，你就可以看明白了，明白了先后顺序，构造函数是进入判断类的关键

Answer 7

a.m(); //多态存在，因为子类B重写了父类A的m()方法。更正一个字，我在1楼把多态写成了动态

Answer 8

A a=new B();
创建的是B的一个实例 是A的引用；
调用B方法 因为创建的是B的实例
B重写的A的方法
a是B的一个实例啊
创建的时候就是了
B是从A继承的显然是A的一个实例啊
折旧是多态啊

Answer 9

A a=new B(); 
1.new B()之后，a是B的实例
2.同时，B是A的子类，所以，a也是A实例中的一员，所以instance of A成立
3.A a=new B();是指，让a具有A的接口，当作一个A的实例来用

Answer 10

super  就是指向父类
 this 指向自己类