Java基础（六）——继承

个人简介

👀个人主页： 前端杂货铺

⚡开源项目： rich-vue3 （基于 Vue3 + TS + Pinia + Element Plus + Spring全家桶 + MySQL）

🙋‍♂️学习方向： 主攻前端方向，正逐渐往全干发展

📃个人状态： 研发工程师，现效力于中国工业软件事业

🚀人生格言： 积跬步至千里，积小流成江海

🥇推荐学习：🍖开源 rich-vue3 🍍前端面试宝典 🍉Vue2 🍋Vue3 🍓Vue2/3项目实战 🥝Node.js实战 🍒Three.js

🌕个人推广：每篇文章最下方都有加入方式，旨在交流学习&资源分享，快加入进来吧

文章目录

• • 前言
  • 继承
  • • Java 继承的特点
    • 方法重写
    • 继承中构造方法的访问特点
    • static
    • 总结

      前言

      大家好，这里是前端杂货铺。

      本篇文章，我们主要学习 Java 中继承，并顺带认识一下 static。

      ---

      继承

      继承，可以让类和类之间产生子父的关系。我们可以把多个子类中重复的代码抽取到父类中，子类可以直接使用，减少代码冗余，提高代码复用性。

      子类可以得到父类的属性和行为，子类可以使用。

      子类可以在父类的基础上新增其他功能，使得子类更强大。

      public class 子类 extends 父类 {}
      

      Java 继承的特点

      • Java 只支持单继承，不支持多继承，但支持多层继承（A 继承父类 B，B 继承父类 C…）
      • Java 中所有的类都直接或间接继承于 Object 类
      • 子类只能访问父类中的非私有成员
      • 子类中 不能继承 父类中 非私有和私有的构造方法
      • 子类中 能继承 父类中 非私有和私有的成员变量（但私有不可用）
      • 子类中 能继承 父类中 虚方法表（非private、非static、非final修饰）中的成员方法，其余不能继承
      • 继承中成员变量访问特点：就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上

        ---

        方法重写

        几个注意事项：

        • 重写方法的名称、形参列表必须与父类中的一致
        • 子类重写父类方法时，访问权限子类必须大于等于父类（空着不写
        • 子类重写父类方法时，返回值类型子类必须小于等于父类
        • 只有被添加到虚方法表中的方法才能被重写

          package com.javabasic.define;
          public class Test {
              public static void main(String[] args) {
                  Student student = new Student();
                  student.lunch();
              }
          }
          class Person {
              public void eat() {
                  System.out.println("父类-吃馒头");
              }
              public void drink() {
                  System.out.println("父类-喝开水");
              }
          }
          class Student extends Person {
              public void lunch() {
                  this.eat();
                  this.drink();
                  super.eat();
                  super.drink();
              }
              @Override
              public void eat() {
                  System.out.println("子类-吃辣条");
              }
              @Override
              public void drink() {
                  System.out.println("子类-喝饮料");
              }
          }
          

          

          ---

          继承中构造方法的访问特点

          • 子类不能继承父类的构造方法，但是可以通过super调用
          • 子类构造方法的第一行，有个默认的super()
          • 默认先访问父类中无参的构造方法，再执行自己
          • 如果想要调用父类的有参构造方法，必须手动书写

            Person.java

            package com.javabasic.define;
            public class Person {
                String name;
                int age;
                public Person() {
                    System.out.println("父类的无参构造");
                }
                public Person(String name, int age) {
                    this.name = name;
                    this.age = age;
                }
            }
            

            Student.java

            package com.javabasic.define;
            public class Student extends Person {
                public Student() {
                    super();
                    System.out.println("子类的无参构造");
                }
                public Student(String name, int age) {
                    super(name, age);
                }
            }
            

            Test.java

            package com.javabasic.define;
            public class Test {
                public static void main(String[] args) {
                    // 调用无参构造，先走父，再走子
                    Student student = new Student();
                    // 间接调用父类的有参构造
                    Student student2 = new Student("张三", 22);
                    System.out.println(student2.name + ", " + student2.age);
                }
            }
            

            

            ---

            static

            static 表示静态，是 Java 中的一个修饰符，可以修饰成员方法，成员变量。

            被 static 修饰的成员变量，叫做静态变量。

            • 被该类所有对象共享
            • 不属于对象，属于类
            • 随着类的加载而加载，优先于对象存在

              Student.java

              package com.javabasic.define;
              public class Student {
                  private String name;
                  private int age;
                  public static String teacherName;
                  public void show() {
                      System.out.println(name + " " + age + " " + teacherName);
                  }
                  public Student() {
                  }
                  public Student(String name, int age) {
                      this.name = name;
                      this.age = age;
                  }
                  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;
                  }
              }
              

              Test.java

              package com.javabasic.define;
              public class Test {
                  public static void main(String[] args) {
                      Student.teacherName = "xx老师";
                      Student student = new Student("前端杂货铺", 20);
                      student.show();
                  }
              }
              

              

              ---

              被 static 修饰的成员方法，叫做静态方法。

              • 多用在测试类和工具类中
              • Javabean 类中很少会用
              • 静态方法中没有 this 关键字
              • 静态方法只能访问静态
              • 非静态方法可以访问非静态方法和静态方法

                下面，我们创建一个工具类 ArrayUtil.java，里面均为静态方法，用于处理一些数组数据。

                ArrayUtil.java

                package com.javabasic.define;
                public class ArrayUtil {
                    private ArrayUtil() {}
                    public static String printArr(int[] arr) {
                        StringBuilder sb = new StringBuilder();
                        sb.append("[");
                        for (int i = 0; i  
                Test.java
                 
                package com.javabasic.define;
                public class Test {
                    public static void main(String[] args) {
                        int[] arr1 = {1, 2, 3, 4, 5};
                        String str = ArrayUtil.printArr(arr1);
                        System.out.println(str);
                        double[] scores = {1.0, 2.0, 3.0, 4.0, 5.0};
                        double average = ArrayUtil.getAverage(scores);
                        System.out.println(average);
                    }
                }
                 
                 
                总结
                 
                本篇文章，我们学习了继承的相关内容，并认识了 static 的特性及使用场景…
                 
                好啦，本篇文章到这里就要和大家说再见啦，祝你这篇文章阅读愉快，你下篇文章的阅读愉快留着我下篇文章再祝！
                 
                参考资料：
                 
                 
                Java 基础（bilibili-黑马程序员）
                菜鸟教程–Java