Java类的继承

Java类的继承
一   类的继承
   继承是一种由已有的类创建新类的机制。利用继承，我们可以先创建一个共有属性的一般类，根据该一般类再创建具有特殊属性的新类，新类继承一班类的状态和行为，并根据需要增加它自己的新的状态和行为。由继承而得到的类称为子类，被继承的类称为父类，超类。Java不支持多重继承，子类只能有一个父类。
    1   创建子类
       在类的声明中，通过使用关键字extends来创建一个类的子类，格式如下：
          class 子类名 extends 父类名
例如：
       class Students extends People
把Students 声明为People类的子类。People是Students的父类。

     2 子类的继承性
     1 子类和父类在同一包中的继承性
          如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然的继承了父类中不是private的方法作为自己的方法。

     例子17：
        import java.applet.*;
        import java.awt.*;
class Father
{
      private int money;
      float weight,height;
      String head;
        String speak(String s)
      {
         return s;                   
      }
}

class Son extends Father
{
String hand,foot;
}
public class Example4_17 extends Applet
{
      Son boy;
      public void init()
      {
        boy=new Son();
        boy.weight=1.8f;
        boy.height=120f;
        boy.head="一个头";boy.hand="两只手";
        boy.foot="两只脚";
}

       public void paint(Graphics g)
       {
        g.drawString(boy.speak("我是儿子"),5,20);
        g.drawString(boy.hand+boy.foot+boy.head+boy.weight+boy.height,5,40);
        }
}

   2 子类和父类不在同一包中的继承
   如果子类和父类不在同一包中，那么，子类继承了父类的protected,public成员变量做为子类的成员变量，并且继承了父类的protected,public方法为子类的方法。如果子类和父类不在同一个包里，子类不能继承父类的友好变量和友好方法。

下面的例子中，Father和Jerry分别隶属不同的包。
例子18：
Father.java:
package tom.jiafei;
public class Father
{
      int height;
      protected int money;
      public int weight;

      public Father(int m)
      {
        money=m;
      }

      protected int getMoney()
      {
         return money;
       }

       void setMoney(int newMoney)
      {

         money=newMoney;

       }

}

Jerry.java:
package sun.com;
import tom.jiafei.Father;
          public class Jerry extends Father //Jerry 和Father在不同的包中

               {

                  public Jerry()

                     {

                           super(20);

                      }

              public static void main(String args[])

                    {

                         Jerry jerry=new Jerry();

                        jerry.height=12;         //非法，因为Jerry没有继承友好的height

                        jerry.weight=200;   //合法

                       jerry.money=800;           //合法

                        int m=jerry.getMoney();     //非法，因为Jerry没有继承友好的方法setMoney

                       System.out.println("m="+m);

                     }

               }

注：如果一个类的声明中没有使用extends 关键字，这个类被系统默认为是Object的子类。Object是包java.lang中的类。

    3   成员变量的隐藏和方法的重写

    当我们在子类中定义的成员变量和父类中的成员变量同名时，则父类中的成员变量不能被继承，此时称子类的成员变量隐藏了父类的成员变量。当子类中定义了一个方法，并且这个方法的名字，返回类型，及参数个数和类型和父类的某个方法完全相同时，父类的这个方法将被隐藏。我们说，我们重写了父类的方法或置换了父类的方法。

    子类通过成员变量的隐藏和方法的重写可以把父类的状态和行为改变为自身的状态和行为。在下面的例子中，子类重写了父类的方法f。

对于子类创建的一个对象，如果子类重写了父类的方法，则运行时系统调用了类重写的方法，如果子类继承了父类的方法（未重写），那么子类创建的对象也可以调用这个方法，只不过方法产生的行为和父类的相同而已。如下述例子。

   例子20：

     import java.applet.*;

     import java.awt.*;

    class Area

        {

             float f(float r)

              {

                return 3.14159f*r*r;

             }

      float g(float x,float y)

           {

               return x+y;

           }

        }

class Circle extends Area

         {

            float f(float r)

              {

                     return 3.14159f*2.0f*r;

               }

         }

    public class Example4_20 extends Applet

          {

            Circle yuan;

             public void init()

                 {

                     yuan=new Circle();

                 }

public vid paint(Graphics g)
{
  g.drawString("yuan="+yuan.f(5.0f),5,20);   //调用子类重写的方法f.
  g.drawString(" "+yuan.g(2.0f,8.0f),5,40);   //调用继承父类的方法g.
}

}

注：重写父类的方法时，不可以降低方法的访问权限。下面的代码中，子类重写父类的方法f，该方法在父类中的访问权限是protected级别，子类重写时不允许级别低于protected级别。
     import java.applet.*;

    import java.awt.*;

     class Chengji
         {
              protected float f(float x,float y)
                 {
                     return x*y;
                 }
          }

     class Xiangjia extends Chengji
        {
                float f(float x,float y)   //非法，因为降低了访问级别。
                     {
                         return x+y;
                    }
        }

   class Xiangjian extends Chengji
       {
          public float f(float x,float y)    //合法，没降低访问级别。
            {
               return x-y;
          }
       }
4   final 类final方法
     final 类不能被继承，即不能有子类，如
        final class A
          {   ……   }

A就是一个final类。有时候是出于安全性的考虑，将一些类修饰为final类。例如，Java提供的String类，它对于编译器和解释器的正常运行有很重要的作用，对它不能轻易改变，因此它被修饰为final类。

如果一个方法被修饰为final方法，则这个方法不能被重写，如果一个成员变量被修饰为final的，就是常量。