面向对象最重要的特点之一，就是可以实现对类的复用;通过“继承”一个现有的类，可以使用已经定义的类中的方法和变量。类的方法可以被继承，但是类的构造器不能被继承.类继承的基本语法：

  1. <modifier>  class  <name>  [extends <superclass> ] 
  2.  
  3. { 
  4.  
  5.             <declaration> * 
  6.  
  7. } 

在Java中，一个类只能继承一个父类，这种方式叫做单继承。这一点和C++不一样。虽然一个类只可以继承一个父类，但是一个父类却可以被多个子类所继承。

Java中的所有类都有一个共同的父类:java.lang.Object.

对于继承:从子类的角度看，它是“继承（extends）”父类；而从父类的角度看，它是“派生（derive）”子类。它们指的都是同一个动作，只是角度不同而已。

 

类的继承的例子:

 

  1. public class Animal{ 
  2.     protected int weight;        
  3.     public int getWeight(){ 
  4.         return weight; 
  5.     }    
  6.     public void setWeight(int w){ 
  7.         weight=w; 
  8.     } 
  9. } 

 

  1. public class Dog extends Animal{ 
  2.   /** 
  3.    *子类新增方法 
  4.    */ 
  5.   public void bark(){ 
  6.     System.out.println("Wang~~Wang~~~"); 
  7.   } 
  8. } 

 

  1. public class MyDog{ 
  2.     public static void main(String args[]){ 
  3.         Dog myDog = new Dog(); 
  4.         myDog.setWeight(50); 
  5.         System.out.println("My Dog's Weight"+myDog.getWeight()); 
  6.         myDog.bark(); 
  7.     } 
  8. } 

 

接下来看这样一个例子:

 

  1. /** 
  2.  * 这是父类 
  3.  * @author Y_tao 
  4.  */ 
  5. public class Father { 
  6.     private void makePaper(){ 
  7.         System.out.println("这是父亲的造纸厂"); 
  8.     } 
  9.      
  10.     public void computer(){ 
  11.         System.out.println("这是父亲的计算机生产线"); 
  12.     } 
  13. } 

 

  1. /** 
  2.  * 这是子类 
  3.  * @author Y_tao 
  4.  */ 
  5. public class Son extends Father{ 
  6.      
  7.     /** 
  8.      * Son现在要对从Father中继承过来的computer方法进行一些改变 
  9.      */ 
  10.     public void computer(){ 
  11.         System.out.println("子类重写了的父类的computer"); 
  12.     } 
  13.      
  14.     public void plane(){ 
  15.         System.out.println("这是子类创建飞机制造厂"); 
  16.     } 
  17.  
  18. } 

当我们做如下调用时,结果是什么呢?

 

  1. public class Test { 
  2.  
  3.     public static void main(String[] args){ 
  4.         Father f = new Son(); 
  5.         f.computer(); 
  6.     } 
  7. } 

执行结果是:子类重写了的父类的computer

结论:子类的对象可以隐式转换给父类的引用,这个父类的引用f访问的就是子类中的方法,但是只能够访问从父类继承到子类中的方法子类中所特有的方法不能被访问