JAVA基础知识(一)——继承

继承的基本语法：

     在JAVA语言中， 用extends关键字来表示一个类继承另一个类，例如：

public class Sub extends Base {
     ...
}

以上代码表明Sub类继承了Base类。那么Sub类到底继承了Base类的哪些东西呢？这需要分两种情况：

• 当Sub类和Base类位于同一个包中，Sub类继承了Base类中public、protected和默认级别的成员变量和成员方法。
• 当Sub类和Base类位于不同包中，Sub类继承了Base类中public、protected的成员变量和成员方法。

1、方法重载（Overload）：

      重载方法必须满足以下条件：

• 方法名相同。
• 方法的参数类型、个数、顺序至少有一项不同。
• 方法的返回类型可以不相同。
• 方法的修饰符可以不相同。

例如以下Simple类中已经定义了一个amethod()方法。

public class Simple {
    public void amethod(int i, String s);
    //加入其他方法
}

下面哪些方法可以加入到Simple类中，并且保证编译正确呢？

A）public void amethod(String s, int i){}                       （可以）

B）public int amethod(int i, String s){return 0;}           （不可以）

C）private void amethod(int i, String mystring){}         （不可以）

D）public void Amethod(int i, String s){}                       （可以）

E）abstract void amethod(int i);                                    （不可以）



2、方法覆盖（Override）：

     覆盖方法必须满足多种约束：

     （1）子类方法的名称、参数类型和返回类型必须和父类方法的名称、参数类型和返回类型一致。例如：以下代码将导致编译错误：
 

public class Base {
    public void method() {...}
}

public class Sub extends Base {
   public int method() {  //编译错误，返回类型不一致
     return 0;
   }
}

   （2）子类方法不能缩小父类方法的访问权限。例如：

public class Base {
    public void method() {...}
}

public class Sub extends Base {
    private void method() {...} //编译错误子类方法缩小了父类方法的访问权限
} 

   （3）子类方法不能抛出比父类方法更多的异常。子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常是父类方法抛出的异常的子类。

    例如，假设异常类ExceptionSub1和ExceptionSub2是ExceptionBase类的子类，则以下代码是合法的：

publc class Base {
    void method() throws ExceptionBase  {}
}

public class Sub1 extends Base {
   void method() throws ExceptionSub1  {}
}

public class Sub2 extends Base {
   void method() throws ExceptionSub1,ExceptionSub2  {}
}

public class Sub3 extends Base {
   void method() throws ExceptkionBase  {}
}

  
以下代码不合法：

public class Base {
    void method() throws ExceptionSub1 {} 
}

public class Sub1 extends Base {
   void method() throws ExceptionBase {}  //编译出错
}

public class Sub2 extends Base {
  void method() throws ExceptionSub1,ExceptionSub2 {}  //编译出错
}

   （4）方法覆盖只存在于父类之间（包括直接父类和间接父类）之间。在同一个类中的方法只能重载，不能覆盖。

   （5）父类的静态方法不能被子类覆盖为非静态方法。例如以下代码将编译错误：

public class Base {
  public static void method() {...}
}

public class Sub extends Base {
  public void method() {...}  //编译出错 

     
   （6）子类可以定义与父类的静态方法同名的静态方法，以便在子类中可以隐藏父类的静态方法。在编译时，子类定义的静态方法也必须方法覆盖类似的约束:方法的参数签名一致，返回类型一致，不能缩小父类的访问权限，不能抛出更多的异常。

public class Base {
   static int method(int i) throws BaseException() {return 0;}
}

public class Sub extends Base {
  public static int method(int i) throws SubException() {return 0;}
} 

   
   （7）父类非静态方法不能被子类覆盖为静态方法。例如以下代码不合法：

public class Base {
   void method() {}
}

public class Sub extends Base {
  static void method() {}  //编译出错
}

     
   （8）父类的私有方法不能被子类覆盖。

      （9）父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法；二是子类重新声明父类的的，抽象方法。例如以下代码是合法的：
  

public abstract class Base {
    abstract void method1();
    abstract void method2();
}

public abstract Sub extends Base {
   public void method1() {...}  //实现method1()方法，并且扩大访问权限。
  public abstract void method2()  //重新声明method2()方法，仅扩大访问权限，但不实现。
}

       
   （10）父类的非抽象方法可以被覆盖为抽象方法。例如以下代码是合法的：

public class Base {
    void method() {}
}

public class Sub extends Base {
    public abstract void method();  //合法
}

 
3、方法覆盖与方法重载的异同

    方法覆盖和方法重载具有以下相同点：

• 都要求方法同名。
• 都可以用于抽象方法和非抽象方法之间。

  

方法覆盖和方法重载不同点：

• 方法覆盖要求参数签名一致，而方法重载要求参数签名不一致。
• 方法覆盖要求返回类型必须一致，而方法重载对此不做限制。
• 方法覆盖只用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类继承而来的方法）。
• 方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制 。
• 父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。

   

以下是子类Sub覆盖了父类Base的method(int v)方法，并且提供了多种重载方法：

public class Base {   
   protected void method(int v) {}   
   private void method(String s){}  //重载   
}   
  
public abstract class Sub extends Base {   
   public void method(int v) {}  //覆盖   
  public int method(int v1, int v2) {return 0;}  //重载   
  protected void method(String s) Exception {}  //重载   
  abstract void method();  //重载   
}