声明父类对象而调用子类的问题

时间:2022-09-29 11:29:34
class A{
int z=4;
}
class B extends A{
int z=6;
void map(A x){
      System.out.println("z="+x.z);
}
}
public class text{
public static void main(String args[]){
B b=new B();
//move a=new move();
b.map(b);
}
}

为什么不是z=6,这不是声明父类对象而调用子类的成员吗?请教高手!

6 个解决方案

#1


是声明父类对象而调用子类的成员函数,但是 b.map(b),所以输出的是b.z

#2


那应该是z=6啊!

#3


"为什么不是z=6,这不是声明父类对象而调用子类的成员吗?请教高手!"
你这句话有几个错误,
其一:不是声明父类对象,是用一个父类类型的引用指向一个子类的对象。
其二:父类引用指向子类对象的时候,它只能访问子类中重写父类的那些函数,而不能调用其他非父类的成员,包括与父类同名的成员变量。
下面给出两个例子。
一:如果子类中的成员与父类中的成员变量同名,只是将父类中的成员变量隐藏了,但是子类的引用也是可以访问的,通过super

class A2{
    int i;
    public A2(){
        i=4;
    }
}
class B2 extends A2{
    int i;
    public B2(){
        i=6;
    }
    public void print(){
        System.out.println("B2.i:"+i+"\nA2.i:"+super.i);
    }
}
public class Polymorphism2 {
    public static void main(String args[]){
        B2 b=new B2();
        b.print();
    }
}

二:父类引用调用子类方法示例

class A{
    public void print(){
        System.out.println("This is A's function");
    }
}
class B extends A{
    public void print(){
        System.out.println("This is B's function");
    }
}
public class Polymorphism {
    public static void main(String args[]){
        A p;
        p=new A();  //A类引用指向A类对象
        p.print();
        p=new B();  //A类引用指向B类对象
        p.print();
    }
}

#4


class A{
    int z=4;
    void mapA(A x){
        System.out.println("Hello");
      }
}
class B extends A{
    int z=6;
    @Override
    void mapA(A x){
      System.out.println("z="+x.z);
    }
    
    void mapB(B x){
     System.out.println("z="+x.z);
    }
    
}
public class Test{
    public static void main(String args[]){
     A a = new A();
        a.mapA(a);
    
        B b=new B();
        b.mapA(b);
        ((A)b).mapA(b);
        b.mapB(b);       
    }
}

变量不会被重写,map中传入的是A类型,则会调用A中的z,传入B类型才会调用B中的z

#5


谢谢各位,懂了,
System.out.println("z="+x.z);
这里只能调用父类A的成员。所以是z=4。

#6


答案是等于4,原因很简单,map(A x)方法中的参数是A类型的,虽然你是传入了一个B的对象b进去,但是b发生了向上转型,所以map(A x)方法中的x.z还是A类中的z值。
关键在于属性是不存在覆写这个概念的,覆写只能修饰于方法,所以,子类中重新定义一个z变量和父类中的z变量没有关系》》》这是重点```

#1


是声明父类对象而调用子类的成员函数,但是 b.map(b),所以输出的是b.z

#2


那应该是z=6啊!

#3


"为什么不是z=6,这不是声明父类对象而调用子类的成员吗?请教高手!"
你这句话有几个错误,
其一:不是声明父类对象,是用一个父类类型的引用指向一个子类的对象。
其二:父类引用指向子类对象的时候,它只能访问子类中重写父类的那些函数,而不能调用其他非父类的成员,包括与父类同名的成员变量。
下面给出两个例子。
一:如果子类中的成员与父类中的成员变量同名,只是将父类中的成员变量隐藏了,但是子类的引用也是可以访问的,通过super

class A2{
    int i;
    public A2(){
        i=4;
    }
}
class B2 extends A2{
    int i;
    public B2(){
        i=6;
    }
    public void print(){
        System.out.println("B2.i:"+i+"\nA2.i:"+super.i);
    }
}
public class Polymorphism2 {
    public static void main(String args[]){
        B2 b=new B2();
        b.print();
    }
}

二:父类引用调用子类方法示例

class A{
    public void print(){
        System.out.println("This is A's function");
    }
}
class B extends A{
    public void print(){
        System.out.println("This is B's function");
    }
}
public class Polymorphism {
    public static void main(String args[]){
        A p;
        p=new A();  //A类引用指向A类对象
        p.print();
        p=new B();  //A类引用指向B类对象
        p.print();
    }
}

#4


class A{
    int z=4;
    void mapA(A x){
        System.out.println("Hello");
      }
}
class B extends A{
    int z=6;
    @Override
    void mapA(A x){
      System.out.println("z="+x.z);
    }
    
    void mapB(B x){
     System.out.println("z="+x.z);
    }
    
}
public class Test{
    public static void main(String args[]){
     A a = new A();
        a.mapA(a);
    
        B b=new B();
        b.mapA(b);
        ((A)b).mapA(b);
        b.mapB(b);       
    }
}

变量不会被重写,map中传入的是A类型,则会调用A中的z,传入B类型才会调用B中的z

#5


谢谢各位,懂了,
System.out.println("z="+x.z);
这里只能调用父类A的成员。所以是z=4。

#6


答案是等于4,原因很简单,map(A x)方法中的参数是A类型的,虽然你是传入了一个B的对象b进去,但是b发生了向上转型,所以map(A x)方法中的x.z还是A类中的z值。
关键在于属性是不存在覆写这个概念的,覆写只能修饰于方法,所以,子类中重新定义一个z变量和父类中的z变量没有关系》》》这是重点```