面向对象---继承

1.继承

• 定义：从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能拓展新的能力

• 继承通过extends关键字来实现

  public class 子类名 extends 父类名{

  }

• 优点：大大缩短开发周期，降低开发费用

• 子类在继承的时候，继承了父类所有的属性和方法

• 父类的私有属性不能被子类继承，子类可以用get、set方法使用

• 父类的构造方法子类也不可以继承，但可以使用

• 子类继承父类代码的执行顺序：先走父类的属性和构造函数，在走子类的属性和构造函数

• Java中只支持单继承。不直接支持多继承，但是对c++中的多继承提供了改良。

  单继承：一个类只能有一个父类。类似于一个儿子只能有一个父亲。

  多继承：一个子类可以有多个直接父类（java中不允许，进行改良）

            不直接支持，因为多个父类中有相同成员，会产生调用的不确定性。在Java中是通过“多实现”的方式来体现。

  Java支持多层(多重)继承

  C继承B，B继承A时，就会出现一个继承体系。

  1、查看该体系的顶层类，了解该体系的基本功能。

  2、创建体系中的最子类对象，完成功能的使用。

  package text02;
  /**
   * 父类  hero army相同属性和方法
   * @author LENOVO
   *
   */
  public class Persion {
      private String name;//昵称
      private int health;//生命值
      
      //无参构造
      public Persion() {
          System.out.println("无参构造");
      }
      //有参构造
      public Persion(String name,int health) {
          this.name="艾琳";
          this.health=1200;
          System.out.println("带两个参数的构造函数");
      }
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public int getHealth() {
          return health;
      }
  ​
      public void setHealth(int health) {
          this.health = health;
      }
      
      //展示信息
      public void print() {
          System.out.println("人物的自白：\n我的昵称是" +name+"生命值"+health);
      }
  }
  package text02;
  //子类
  public class Hero extends Persion{
      private String sex;//性别
      private String occupation;//职业
      
      //无参
      public Hero() {
          System.out.println("无参构造");
      }
      public Hero(String name,int health,String occupation) {
          super.setName(name);
          super.setHealth(health);
          this.occupation=occupation;
          System.out.println("这是子类的构造函数");
      }
      public String getSex() {
          return sex;
      }
      public void setSex(String sex) {
          this.sex = sex;
      }
      public String getOccupation() {
          return occupation;
      }
      public void setOccupation(String occupation) {
          this.occupation = occupation;
      }
      
  }
  ​
  package text02;
  //子类
  public class Army extends Persion{
      private String birth;//出生地
      public Army() {
          
      }
      public Army(String name,String birth) {
          super.setName(name);
          this.birth=birth;
          System.out.println("这是子类的构造函数");
      }
      public String getBirth() {
          return birth;
      }
  ​
      public void setBirth(String birth) {
          this.birth = birth;
      }
      
  }
  package text02;
  //测试类
  public class TestYc {
      public static void main(String[] args) {
          Hero hero=new Hero("周瑜",1000,"法师");
          hero.print();
          
          Hero hero1=new Hero();
          hero1.setName("小新");
          hero1.print();
          
          Army army=new Army("黑猫", "华夏");
          army.print();
      }
  }

2.重写

重写的目的：父类的继承方法不能满足子类的需求

重写的定义：在子类中可以对从父类继承的方法进行重写，称为方法的重写或覆盖

重写的要求：子类和父类的方法名相同，参数列表相同，返回值类型相同，访问修饰符不能严于父类即 子类的访问修饰符必须大于父类的访问修饰符

在子类中被重写调用父类被重写的方法，可以在子类方法中通过“super.方法名”实现

super.name; //访问直接父类的name属性
super.print(); //访问直接父类的print()方法
super(name); //访问直接父类对应构造方法，只能出现在构造方法中

3.抽象类

• 用abstract修饰类和方法

• 抽象类不能实例化

• 抽象方法只有方发声明，没有方法实现

• 子类继承、重写里面的抽象方法

• 抽象类中既可以有普通方法，也可以有抽象方法

• 如果一个类中有抽象方法那么这个类一定是抽象类

• 如果一个类继承了抽象类，那么子类必须重写父类中所有的冲向方法，如果没有重写完，那么子类也是一个抽象类

• 抽象方法 ：public abstract void print();

4.final

final修饰的类不能再被继承

final修饰的方法不能被子类重写

final修饰的变量为常量

5.super和this的区别

• this对本类的引用

super对父类对象的引用

• this：没有继承也可以使用

  super：只能在继承条件下才可以使用

• this() 本类的构造方法

  super() 父类的构造方法