JAVA继承

一、继承

        继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

• 子类继承父类，父类派生子类。
• 父类又叫基类。
• 子类又叫派生类。

        面向对象的程序设计有三大特征：

• 封装：解决了数据的安全性问题
• 继承：解决了代码的重用问题
• 多态：解决了程序的扩展问题

        通常情况，最高层是最普遍的、最一般的情况，往下每一层都比上一层更具体，并包含有高层的特征，通过这样的层次结构使下层的类能自动享用上层类的特点和性质。继承其实就是自动地共享基类中成员属性和成员方法的机制。

二、类的继承格式

        继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

        在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

        在Java中使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

三、继承的作用

        继承是能自动传播代码和重用代码的有力工具，继承能够在某些比较一般的类的基础上建造、建立和扩充新类，能减少代码和数据的重复冗余度，并通过增强一致性来减 少模块间的接口和界面，从而增强了程序的可维护性，能清晰地体现出类与类之间的层次结构关系。

        继承是单方向的，即派生类可以继承和访问基类中的成员 ，但基类则无法访问派生类中的成员。在Java中只允许单一继承方式，即一个派生类只能继承于 一个基类，而不能象C++中派生类继承于多个基类的多重继 承方式。

四、类成员的访问控制权限

public：不受任何限制，本类或非本类均可随意访问。
protected：本类及其子类可以访问（父子友好），同一个包中的其它类也可访问（包内友好）。
缺省：只有相同包中的类可以访问（包内友好）。
private：只有本类可以访问，其余都不可以。

        还可以在定义类时为类添加访问修饰符，对类进行访问权限控制。

        对类使用的访问修饰符只有public和缺省两种。

        被public修饰的类可以从任何地方访问，不受限制。

        不加访问修饰符，缺省修饰的类只能从本包中访问，不同包则无法访问到。

        但要注意的是：在一个源文件中只能有一个被public修饰的类，并且文件名必须与public的类同名。

        如果要定义多个public的类，则必须分别写在不同的源文件中，一个源文件只写一个类是良好的编程习惯。

五、继承中的构造方法

        父类中的构造方法不能被子类继承，即便它是public的。父类的构造方法负责初始化属于它的成员变量，而子类的构造方法则只需考虑属于自己的成员变量，不必去关注父 类的情况。

class ParentClass { //定义父类
    public ParentClass() { //构造方法
        System.out.println("这是父类的构造方法。");
    }
}

class ChildClass extends ParentClass { //子类继承于父类
    public ChildClass() { //构造方法
        System.out.println("这是子类的构造方法。");
    }
}

public class ConstructorTest { //该类用于容纳main方法
    public static void main(String[] args) {
        ChildClass cc = new ChildClass(); //实例化子类对象
    }
}

        当实例化子类的对象时，必须先执行父类的构造方法，然后再执行子类的构造方法。如果父类还有更上级的父类，就会先调用最高父类的构造方法，再逐个依次地将所有继承关系的父类构造方法全部执行。如果父类的构造方法执行失败，那么子类的对象也将无法实例化。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

六、super关键字

        在Java中，super关键字有两个主要用途。

        第一种用途是：在子类的构造方法中，super关键字可以显式地调用父 类的构造方法，用于将参数传递给它。其一般语法是： super(实际参数)。 l 需要注意的是：该语句必须是子类构造方法的第一条语句。

        第二种用途是：如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员。super关键字可以明确地指定要访问父类中的成员，其一般语法是： super.成员名，前提条件是：父类中的该成员不是private的。

七、super 与 this 关键字

        super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

        this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

八、final关键字

        final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

// 声明类
final class 类名 {//类体}

// 声明方法
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

      结束！