继承

1. 1.class Foo {   
   2.    public int a;   
   3.  
   4.    public Foo() {   
   5.        a = 3;   
   6.    }   
   7.  
   8.    public int addFive() {   
   9.        a += 5;   
   10.        return a;   
   11.    }   
   12.  
   13.    public int getA() {   
   14.        return a;   
   15.    }   
   16.}   
   17.  
   18.public class Bar extends Foo {   
   19.    public int a;   
   20.  
   21.    public Bar() {   
   22.        a = 8;   
   23.    }   
   24.  
   25.    public int addFive() {   
   26.        this.a += 5;   
   27.        return a;   
   28.    }   
   29.  
   30.    public int getA() {   
   31.        return a;   
   32.    }   
   33.  
   34.    public static void main(String[] args) {   
   35.        Foo foo = new Bar();   //foo.a=3,bar.a=8   
   36.        //调用的是子类中的方法   
   37.        System.out.println(foo.getA());   
   38.        //直接调用父类中的a   
   39.        System.out.println("Value: " + foo.a);  //foo.a=3,bar.a=13   
   40.        //调用的是子类中的方法   
   41.        System.out.println(foo.addFive());  //bar.a=8+5 
   42.           
   43.    }   
   44.}  
   

   父类中的a和子类中的a是两个不同的成员变量，同时存在的，不会出现覆盖的现象。

 输出结果：
8
Value: 3
13

楼主，只需要明白一点就行了：在Java中重写指的是方法的重写，而不是属性的重写，还有多态也只是方法的多态 ，没有属性的多态。

 

 注意：这句  Foo foo = new Bar();创建了一个Bar对象
一个对象创建的过程分成4步：
1.分配总空间
2.递归创建父类对象
3.调用本类构造方法 
4.初始化本类属性；
还有第2点 其实是创建了父类的属性和方法,并没有创建父类对象,用人们的眼光来把它
单独拿出来看,像是创建了父类对象似的;
父类的除private方法以外的方法都被子类所继承.并且覆盖但是属性却没有被覆盖,所以foo.a  访问的是父类的 属性,而 foo.addFive(); 调用的是子类覆盖父类的 addFive()方法,既然调用的是子类的方法,所以这个方法修改的是子类属性的值

 其实去看Debug View的内存树会比较清楚

 

在子类中调用父类同名属性可以这样写super.a

 

 

 

---------------------------

class Base{  
   public int a;  
   public static int b;  
   public Base(){  
     a=1;  
     b=1;  
   }  
   public void addFivetoa(){  
    a+=5;  
   }  
   public static void addSixtob(){  
    b+=6;  
   }  
}  
public class Son extends Base{  
  //public int a;  
  //public static int b;  
  public Son(){  
   a=2;  
   b=2;  
  }  
public void addFivetoa(){  
   a+=5;  
  }  
public static void addSixtob(){  
   b+=6;  
}  
public static void main(String args[]){  
Son son = new Son();  
Base base = son;  
base.addFivetoa();  
base.addSixtob();  
System.out.println(base.a);//7  
System.out.println(base.b);//8  
System.out.println(son.a);//7  
System.out.println(son.b);//8  
}  
}  

过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化a=2，b=2； 
base.addFivetoa();//a=7;调用的子类的 
base.addSixtob();//b=8；调用的父类的 
属性是不能多态的，静态方法也不能多态。 
图示： 
[img] http://dl.iteye.com/upload/attachment/146753/1c112269-254f-3f9e-9bd4-afa547d99cd3.jpg[/img] 

衍生： 
Java代码 
class Base{  
   public int a;  
   public static int b;  
   public Base(){  
     a=1;  
     b=1;  
   }  
   public void addFivetoa(){  
    a+=5;  
   }  
   public static void addSixtob(){  
    b+=6;  
   }  
}  
public class Son extends Base{  
  public int a;  
  public static int b;  
  public Son(){  
   a=2;  
   b=2;  
  }  
public void addFivetoa(){  
   a+=5;  
  }  
public static void addSixtob(){  
   b+=6;  
}  
public static void main(String args[]){  
Son son = new Son();  
Base base = son;  
base.addFivetoa();  
base.addSixtob();  
System.out.println(base.a);//1  
System.out.println(base.b);//7  
System.out.println(son.a);//7  
System.out.println(son.b);//2  
}  
}  

 

0 0

class Base{ 
   public int a; 
   public static int b; 
   public Base(){ 
     a=1; 
     b=1; 
   } 
   public void addFivetoa(){ 
    a+=5; 
   } 
   public static void addSixtob(){ 
    b+=6; 
   } 
} 
public class Son extends Base{ 
  //public int a; 
  //public static int b; 
  public Son(){ 
   a=2; 
   b=2; 
  } 
public void addFivetoa(){ 
   a+=5; 
  } 
public static void addSixtob(){ 
   b+=6; 
} 
public static void main(String args[]){ 
Son son = new Son(); 
Base base = son; 
base.addFivetoa(); 
base.addSixtob(); 
System.out.println(base.a);//7 
System.out.println(base.b);//8 
System.out.println(son.a);//7 
System.out.println(son.b);//8 
} 
} 

过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化a=2，b=2；
base.addFivetoa();//a=7;调用的子类的
base.addSixtob();//b=8；调用的父类的
属性是不能多态的，静态方法也不能多态。
图示：
[img] http://dl.iteye.com/upload/attachment/146753/1c112269-254f-3f9e-9bd4-afa547d99cd3.jpg[/img]

衍生：
Java代码
class Base{ 
   public int a; 
   public static int b; 
   public Base(){ 
     a=1; 
     b=1; 
   } 
   public void addFivetoa(){ 
    a+=5; 
   } 
   public static void addSixtob(){ 
    b+=6; 
   } 
} 
public class Son extends Base{ 
  public int a; 
  public static int b; 
  public Son(){ 
   a=2; 
   b=2; 
  } 
public void addFivetoa(){ 
   a+=5; 
  } 
public static void addSixtob(){ 
   b+=6; 
} 
public static void main(String args[]){ 
Son son = new Son(); 
Base base = son; 
base.addFivetoa(); 
base.addSixtob(); 
System.out.println(base.a);//1 
System.out.println(base.b);//7 
System.out.println(son.a);//7 
System.out.println(son.b);//2 
} 
} 


过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化子类中的a和b，a=2，b=2；
base.addFivetoa();//调用子类的方法，son.a=7
base.addSixtob();//调用父类的方法，base.b=1+6=7
剩下的base.a和son.b都没有变化所以分别为1，2。
其中加粗红色的1是父类的b的值，base.addSixtob()(是静态的)所以要调用addSixtob()所在类base的b的值也就是，或者说是base对象调用了addSixtob()，所以要访问base对象所在类的b值。

--static静态方法不能重写，所以调用父类，父类b值发生改变。