继承

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”。子类是父类的扩展。

public class person{}
public class student extends person{}//这样就是继承了person这个父类（基类）

• Java中只有单继承，没有多继承。

  • 可以理解成一个儿子只能有一个父亲，但一个父亲可以有很多个儿子。

• 继承是类和类之间的一种关系，除此之外，类和类的之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示。

• 子类和父类之间，从意义上类讲应该具有“is a”的关系。

• 举例：

  • 父类

  //人 类 ：父类（基类）
  //Java默认继承 object这个父类
  public class Person /*extends object*/{
  
      //一些修饰符（是按优等级排序），继承关系中大部分是public方法，属性才是私有的
      //public：公共的
      //protected：受保护的
      //defauit：默认
      //private:私有
      private int money = 10_0000_0000;
  
  
      //子类可以继承父类的所有方法
      public void say(){
          System.out.println("说了一句话");
      }
  
      public int getMoney() {
          return money;
      }
  
      public void setMoney(int money) {
          this.money = money;
      }
  }
  

  • 子类

  //教师 is 人 ：子类（派生类）
  public class Teacher extends Person {
  }
  //学生类 is 人：子类（派生类）
  public class Student extends Person {
  }
  

  • 调用

  public class Application {
      public static void main(String[] args) {
  
          Student student = new Student();
          student.say();
  
          student.setMoney(10_0000_0000);
          System.out.println(student.getMoney());
      }
  }
  

• object类：Java中所有的类，都默认直接或间接继承object类

  • 快捷键：在类中 Ctrl+h可以查看类和类的关系。

---

• super：

  • super注意点：
    • super调用父类的构造方法，必须在构造方法的第一个。
    • super必须只能出现在子类的方法或者构造方法中。
    • super和this不能同时调用构造方法。
  • Vs this：
    • 代表的对象不同：
      • this：本身调用者是这个对象
      • super：代表父类的对象引用
    • 前提：
      • this：没有继承也可以使用
      • super：只能在继承的条件下使用
    • 构造方法：
      • this（）：本类的构造
      • super（）:父类的构造

  //父类
  public class Persons {
      //父类如果没有无参构造，子类也不用无参构造
      public Persons() {
          System.out.println("Persons无参执行了");
      }
  
      protected String name = "法外狂徒";
  
      //修饰符是private ：私有的无法被继承
      public void print(){
          System.out.println("打印了Persons内容");
      }
  

  //子类
  public class Students extends Persons {
  
      public Students() {
          //隐藏了一段代码：默认调用了父类的无参构造
          super();//调用父类的构造器，必须要在子类的第一行，否则会报错
          //this();和super（）；不能共存
          System.out.println("Students无参执行了");
      }
  
      public void print(){
          System.out.println("打印了Students内容");
      }
  
      private String name = "张三";
  
  
      public void test1(){
          print();//打印了Students内容
          this.print();//打印了Students内容
          super.print();//打印了Persons内容
      }
  
  
      public void test(String name){
          System.out.println(name);//zhangsan
          System.out.println(this.name);//张三
          System.out.println(super.name);//法外狂徒
  
      }
  }
  

  public class Application {
      public static void main(String[] args) {
          Students students = new Students();
          //students.test("zhangsan");
          //students.test1();
      }
  }
  

• 简单的说就是super=调用父类；this=本身类。

---

• 方法重写：

  • 重写都是方法的重写与属性无关。
  • 需要有继承关系，子类重写父类的方法。
  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符：范围可以扩大，但不可以缩小。public > protected > default > private
  • 抛出异常：范围，可以被缩小，但不能扩大。ClassNotFoundException -->Exception(大)
  • 重写，子类方法和父类必须要一致，方法体不同！

• 为什么要重写：

  • 父类的功能，子类不一定需要，或者比一定满足！

• 重写快捷键：

  • Alt + Insert ：override；

//重写都是方法的重写与属性无关
//父类
public class A {
    public  void test(){
        System.out.println("A=test()");
    }
}

//子类 ：继承时才能方法重写
public class B extends A{
    @Override//有功能的注释
    //override:重写
    //快捷键：Alt+Insert 选择override
    public void test() {
        //super.test();快捷键生成的方法默认调用父类的方法
        System.out.println("B=test()");
    }
}

public class Application {
    //静态方法和非静态方法差别很大
    //静态方法：方法的调用只和左边定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        B b = new B();
        b.test();

        //父类的引用指向子类
        A a = new B();
        a.test();
    }
}