1. class A
   
2. {
   
3.         int i,j;
   
4.         void setIJ(int i,int j)
   
5.         {
   
6.                 this.i=i;
   
7.                 this.j=j;
   
8.         }
   
9.         int multiply()
   
10.         {
    
11.                 return i*j;
    
12.         }
    
13. }
    
14. 
    
15. class B extends A
    
16. {
    
17.         int i,k;
    
18.         B(int i,int k)
    
19.         {
    
20.                 this.i=i;
    
21.                 this.k=k;
    
22.         }
    
23.         int multiply()
    
24.         {
    
25.                 return i*j*k;
    
26.         }
    
27. }
    
28. 
    
29. public class ABtest
    
30. {
    
31.         public static void main(String a[])
    
32.         {
    
33.                 B subO=new B(6,9);
    
34.                 subO.setIJ(7,8);//调用父类方法setIJ（）;    疑问语句
    
35.                 int m=subO.multiply();
    
36.                 System.out.println("m="+m);
    
37.         }
    
38. }

复制代码

输出为：m=432


subO通过构造初始化，i=6   k=9
然后 subO.setIJ（7，8）； 这一语句中，8被赋给了变量j . 参数7发生了什么？  因为最后的结果表明子类对象的变量i被初始化为6后，这一语句仅给j赋值了    参数7的处理细节是什么样的？

1. 
   
2. <P>class A
   
3. {
   
4.         int i,j;
   
5.         void setIJ(int i,int j)
   
6.         {
   
7.                 this.i=i;   
   
8.                 this.j=j;
   
9.         }
   
10.         int multiply()
    
11.         {
    
12.                 return i*j;
    
13.         }
    
14. }</P>
    
15. <P>class B extends A
    
16. {
    
17.         int i,k;
    
18.         B(int i,int k)
    
19.         {
    
20.                 this.i=i;
    
21.                 this.k=k;
    
22.         }
    
23.         int multiply()
    
24.         {
    
25.                 return i*j*k;
    
26.         }
    
27. }</P>
    
28. <P>public class ABtest
    
29. {
    
30.         public static void main(String a[])
    
31.         {
    
32.                 B subO=new B(6,9);
    
33.                 subO.setIJ(7,8);//调用父类方法setIJ（）;    疑问语句
    
34. <FONT color=red>因为上面你的方法用了this关键字.你把参数传递过去.默认就赋值使用this关键字的变量.  7那个参数也用了this..所以全赋值到了父类的变量上了.</FONT>
    
35.                 int m=subO.multiply();
    
36.                 System.out.println("m="+m);
    
37.         }
    
38. }
    
39. </P>

复制代码

这认为是这样的：
1，如果子父类中都有相同的变量，父类变量会被复盖，所以B中会有三个变量:i,j,k;这跟复盖方法差不多吧。
2，因为B中的i变量复盖了A变量中的i,所以在multiply()中用到的i是子类的i;
3,要在B类中得到父类的i变量可以通过super.i得到。
class B extends A
{
        int i,k;
        B(int i,int k)
        {
                this.i=i;
                this.k=k;
        }
        int multiply()
        {
      
                return (super.i)*j*k;//这样就可以得到父类的i了
        }
}

package Day12;
class A
{
        int i,j;
        void setIJ(int i,int j)
        {
                this.i=i;
                this.j=j;
        }
        int multiply()
        {
                return i*j;
        }
        public void printF()
        {
                System.out.println("i="+this.i);
        }
}

class B extends A
{
        int i,k;
        B(int i,int k)
        {
                this.i=i;
                this.k=k;
        }
        int multiply()
        {
                System.out.println("i="+i+":j="+j+"k="+k);
             return i*j*k;
        }
        void print()
        {
                System.out.println("i="+i+":k="+k);
        }
}

public class Demo1
{
        public static void main(String a[])
        {
                B subO=new B(1,2);
                subO.setIJ(3,4);//调用父类方法setIJ（）;    疑问语句
                //你的子类方法multiply()中,有父类不存在的k变量,所以.使用子类方法时,他使用的是子类的变量,
                int m=subO.multiply();//父类中没有k,没有的,他就去父类找,有的,就自己用.
                System.out.println("m="+m);
                subO.print();//出输1:2:
                subO.printF();//输出3//i的赋值是3.当你输出父类有的属性时,它就会输出父类的.子父类有方法覆盖.
        }
}

class A
{
        int i,j;
        void setIJ(int i,int j)
        {
                this.i=i;
                this.j=j;
        }
        int multiply()
        {
                return i*j;
        }
}

class B extends A
{
        int i,k;
        B(int i,int k)
        {
                this.i=i;
                this.k=k;
        }
        int multiply()
        {
                return i*j*k;
        }
}

public class ABtest
{
        public static void main(String a[])
        {
                B subO=new B(6,9);
                subO.setIJ(7,8);//调用父类方法setIJ（）;
/*
如果子父类中有同名的成员变量x  子类对象调用的方法 （此方法继承于父类）访问到这个x 那么这个变量会在父类中访问的是父类的x 因为调用的父类的函数中含有的是父类对象的引用this  this.x当然是父类的                        即subO.setIJ(7,8)这句话  寻找到父类的变量i 并复制7 寻找到父类的j并复制8  而子类对象的i依然为6  由于子类的j继承于父类  所以子类中方法multiply（）用到的j为父类的j
*/
          System.out.println(subO.i)//这句话打印出来一定是6
        }
}