面向对象编程的三大特性(继承）

基本含义

创建

继承语法：
[访问控制修饰符] [非访问控制修饰符] class 子类名 extends 父类名{ 类体 }

项目	含义
含义	继承父类的属性和方法。
目的	复用代码。便于维护。
父类别名	基类或者超类。
特性	单继承（即子类只有一个父类，父类可以有多个子类）
Object类	Java中，是所有的类的父类。

调用父类方法——未被重写后

语法：super.父类被重写方法名();
子类重写父类：

项目	含义
目的	继承父类时，展现特性。
别名	覆盖（override）
重写父类	一大两小两同
访问控制修饰符	不小于父类
非访问控制修饰符	不限
返回值类型	不大于父类
抛出的异常类	不大于父类
方法名	与父类相同
参数列表	与父类相同

调用父类方法——构造器

语法：
[ 访问控制修饰符 ] [ 非访问控制修饰符 ] 类名{ super(参数列表);…}

注意：

1. 同一构造器中，super(参数)必须放置有效执行方法体首行。
2. 同一构造器中，super(参数)只能出现一次。
3. 同一构造器中，super(参数)必须出现一次。
4. 同一构造器中，super只能出现在子类的方法体中。
5. 同一构造器中，只能引用一个构造器。
6. 同一构造器中，this(参数)和super(参数)只能出现一个。

特别提醒：
若父类显式声明只有有参构造器，而子类未调用显式有参构造器，则会出错。

具体操作

主函数入口源文件：

public class MainEntrance{
  public static void main(String[] args){ 
    Rabbit rb = new Rabbit("小白兔", 1, 3, "雄");
      // 封装属性调用：
      System.out.println(rb.getName()); // 外部类调用，子类的父类的封装属性。
      // rb.setLegNumber();
      System.out.println(rb.getAge()); // 
      rb.eat();
  }
}

动物类源文件：

public class Animal{
  // 封装属性：动物共性，名字和年龄。
  private String name;
  private int age;
  /* 构造器：无参。
   * 被调用：子类构造器必须调用父类构造器。
   * 此处目的：防止子类没有调用父类有参构造函数时，报错情况发生。
   * 
   */ 
  public Animal(){  
  }
  public Animal(int age){
    // 封装属性调用：本类中，this.私有变量名。
    this.age = age;
  }
  public Animal(String name, int age, String sex){
    // 封装属性调用：本类中，this.私有变量名。
    this.name = name;
    this.age = age;
    this.sex = sex;
  }
	  
  // 对象方法：
  public void eat(){
    System.out.println(this.name + "也需要吃东西" );
  }
  public void sleep(){
    System.out.println(this.name + "已经" + this.age + "岁了！");
  }
  public void life(){
    System.out.println("每个动物都有声明！");
  }
	  
  // set和get方法：通过创建此两种方法，让外部类访问被封装的属性。
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
}

兔子类源文件：

public class Rabbit extends Animal{
  private int legNumber;
  /*
  * 构造器
  * 同一构造器中，只能引用一个构造器。
  * 同一构造器中，this(参数)和super只能出现一个。
  * 同一构造器中，super(参数)必须出现一次。
  * 同一构造器中，super(参数)只能出现一次。
  * 同一构造器中，super(参数)必须放置有效执行方法体首行。
  * 同一构造器中，super只能出现在子类的方法体中。
  * 若父类显式声明只有有参构造器，而子类未调用显式有参构造器，则会出错。
  */
  public Rabbit(String name, int age, int legNumber, String sex){		
    super(name,age,sex);
    judgeLegNumber(legNumber);
//	this(legNumber); // 同一构造器中，this(参数)和super只能出现一个。
  }
  // 重载构造器：其它相同，只是参数列表和方法体不同。
  public Rabbit(int legNumber){
    super(legNumber);
  }
	
  // 重写父类方法：两大一小两同原则。
  public void eat(){
    super.eat(); // 调用父类的对象方法。
    System.out.println(super.getName() + "是食草动物！"); // 调用父类封装的属性。
    System.out.println(this.sex + "兔跑得快吗？"); // 调用父类未封装的属性。也可省略this。
  }
  // 对象方法：
  public void judgeLegNumber(int legNumber){
    if(legNumber != 4){
       System.out.println("这不是一个正常的兔子！");
    }else{
       this.legNumber = legNumber;
    }
  }
	
  // get方法和set方法：帮助外类获取封装的属性。
  public int getLegNumber() {
    return legNumber;
  }
  public void setLegNumber(int legNumber) {
    this.legNumber = legNumber;
  }	
}