面向对象进阶 | 深入探究 Java 静态成员与继承体系

个人主页

文章专栏

文章目录

- 个人主页
- 文章专栏
一、static（静态）
- 1.static 静态变量
- - 代码展示
  - 内存图
- 2.static 静态方法
- - 工具类：
  - - 练习：
- 3.static注意事项
- 4.重新认识`main`方法
二、继承
- 1.继承概述
- 2.继承的特点
- 3.子类到底能继承父类中的哪些内容
- 4.继承中访问特点
- - 继承中：成员变量的访问特点
  - 继承中：成员方法的访问特点
  - 继承中：构造方法的访问特点
  - this、super使用总结

一、static（静态）

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

1.static 静态变量

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

特点：

被该类的所有对象共享

不属于对象，属于类

随着类的加载而加载，优于对象存在

调用方式：

类名调用（推荐）

对象名调用

代码展示

需求：写一个JavaBean类来描述这个班级的学生
属性：姓名、年龄、性别
行为：学习

JAVA Bean 类

package staticdemo;

public class Student {
    //属性：姓名，年龄，性别
    //新增：老师的姓名
    private String name;
    private int age;
    private String gender;
    public  static  String teacherName;


    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    //行为
    public void study(){
        System.out.println(name+"正在学习");
    }
    public void show(){
        System.out.println(name+","+age+","+gender+","+teacherName);
    }
}

测试类

package staticdemo;

public class StudentTest {
    public static void main(String[] args) {
        //1.创建第一个学生对象
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(20);
        s1.setGender("男");
        //公共类，但是s2没有创建对象，所以无法访问teacherName，为null
        //public String teacherName;

        //于是我们想了个方法，用static修饰teacherName，但是这样就变成了静态属性，所有对象共享
        //public  static  String teacherName;
        s1.teacherName = "王老师";

        //还可以用类名.属性名来访问
        //Student.teacherName = "王老师";

        s1.study();
        s1.show();

        //2.创建第二个学生对象
        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(21);
        s2.setGender("女");

        s2.study();
        s2.show();

    }
}

内存图

在这里插入图片描述

栈内存
- 方法调用时会在栈内存中创建栈帧。这里main方法首先入栈，在main方法执行过程中：
  - 执行 Student.teacherName = "阿玮老师"; ，这一步只是对静态变量赋值，在栈内存中记录这个操作。
  - 执行 Student s1 = new Student(); 时，在栈内存为引用变量 s1 分配空间，存放指向堆内存中 Student 对象的地址（假设为 0x0011 ）。
  - 执行 s1.name = "张三"; 和 s1.age = 23; ，是通过 s1 引用操作堆内存中对象的实例变量。
  - 执行 s1.show(); 时，show 方法的栈帧入栈，在栈帧中记录方法内的局部变量（这里无额外局部变量）以及要操作的对象属性（通过 s1 找到堆内存对象属性）。
  - 执行 Student s2 = new Student(); ，在栈内存为引用变量 s2 分配空间，存放指向堆内存中另一个 Student 对象的地址（假设为 0x0022 ）。
  - 执行 s2.show(); 时，show 方法栈帧再次入栈，通过 s2 引用操作其对应的堆内存对象属性。
堆内存
- 当执行new Student()时，在堆内存创建Student对象实例。
  - 第一个 Student 对象（对应 s1 ），在堆内存中分配空间存储实例变量 name 值为 “张三” ，age 值为 23 。
  - 第二个 Student 对象（对应 s2 ），在堆内存中分配空间存储实例变量 name 初始值 null （字符串默认初始值），age 初始值 0 （整数默认初始值）。
- 静态变量 teacherName 存储在堆内存的静态存储位置（静态区），值为 “阿玮老师” ，所有 Student 类的对象共享这个静态变量。

注意：静态变量随类的出现而出现，优于变量。

2.static 静态方法

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

特点：

多用在测试类和工具类中

Javabean类中很少会用
调用方式：

类名调用（推荐）

对象名调用

工具类：

帮助我们做一些事情的，但是不描述任何事物的类

Javabean类：用来描述一类事物的类。比如：Student、Teather、Dog等

测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口

遵守的规范：

类名见名知意
私有化构造方法
方法定义为静态的

练习：

第一题：

需求：在实际开发中，经常会遇到一些数组使用的工具类

请按照如下要求编写一个数组的工具类：ArrayUtil

在这里插入图片描述

工具类：

package sta02;

public class ArrayUtil {
    //私有构造方法，防止外部实例化
    private ArrayUtil() {}
    public static String printArray(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append( "[");
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);
            if (i < arr.length - 1) {
                sb.append(", ");
            }else {
                sb.append("]");
            }
        }
        return sb.toString();
    }
    public static double getArray(double[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];  //累加数组元素
        }
        return sum/arr.length;
    }
}

测试类

package sta02;

public class Testdemo {
    public static void main(String[] args) {
        //测试printArray方法
        int[] arr = {1, 2, 3, 4, 5};
        String result = ArrayUtil.printArray(arr);
        System.out.println(result);
        //测试getArray方法
        double[] arr2 = {1.0, 2.0, 3.0, 4.0, 5.0};
        double average = ArrayUtil.getArray(arr2);
        System.out.println(average);
    }
}

第二题：

需求：定义一个集合，用于存储3个学生对象

学生类的属性：name、age、gender

定义一个工具类，用于获取集合中最大学生的年龄

JavaBean类：

package sat03;

public class Student {
    private String name;
    private int age;
    private String gender;

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }


}

方法类：

package sat03;

import java.util.ArrayList;

public class StudentUtil {
    //私有构造方法，防止外部实例化
    private StudentUtil() {}
    //静态方法
    public static int getMaxScore(ArrayList<Student> list ) {
        //1.定义一个参照物
        int maxAge = list.get(0).getAge();
        //2.遍历集合
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getAge() > maxAge) {
                maxAge = list.get(i).getAge();
            }
        }
        return maxAge;

    }
}

测试类：

package sat03;

import java.util.ArrayList;

public class testmax {
    public static void main(String[] args) {
        //1.创建一个集合来存储
        ArrayList<Student> list = new ArrayList<Student>();
        //2.创建3个学生对象
        Student s1 = new Student("Zhangsan", 20, "男");
        Student s2 = new Student("lisi", 23, "男");
        Student s3 = new Student("wangwu", 25, "女");
        //3.将学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //4.调用方法
        int max=StudentUtil.getMaxScore(list);
        System.out.println(max);
    }
}

3.static注意事项

静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中是没有this关键字的

总结：

静态方法中，只能访问静态

非静态方法可以访问所有

静态方法中没有this关键字

4.重新认识`main`方法

public class HelloWorld{
    public static void main (String[] args){
        System.out.println("HelloWorld");
    }
}

public : 被JVM调用，访问权限足够大
static ：被JVM调用，不用创建对象，直接类名访问

因为main方法是静态的，所以测试类中其他方法也是需要是静态的
void : 被JVM调用，不需要给JVM返回值
main : 一个通用的名称，虽然不是关键字，但是被JVM识别
String[] args ：以前用于接受键盘录入数据的，现在没用

二、继承

面向对象三大特征：封装、继承、多态

封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

在这里插入图片描述

我们发现在Student类与Teacher类中有重复的元素，于是为了使程序更加便捷便出现了”继承“

在这里插入图片描述

1.继承概述

java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系
```
public class Student extends Person{}
```
- Student称为子类（派生类）,Person称为父类（基类或超类）

优点：

可以把多个子类中重复的代码抽取到父类中，提高代码的复用性
子类可以在父类的基础上，增加其他的功能，使子类更强大

在这里插入图片描述

什么时候用继承？

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

2.继承的特点

java中只支持单继承，不支持多继承，但支持多层继承

单继承：一个子类只能继承一个直接父类

不支持多继承：子类不能同时继承多个父类

多层继承：子类A继承父类B，父类B可以继承父类C

C是A的间接父类

每一个类都直接或者间接的继承于Object

练习：

在这里插入图片描述

核心点：共性内容抽取，子类是父类中的一种
在这里插入图片描述

写代码是从父类开始写，最后写子类

JAVABean类

package st5;

public class Animal {
    public void eat() {
        System.out.println("我会吃饭");
    }
    public void water (){
        System.out.println("我会喝水");
    }
}

package st5;

public class Cat extends Animal {
    public void mice() {
        System.out.println("我会抓老鼠");
    }

}

package st5;

public class Dog extends Animal {
    public void lookhome() {
        System.out.println("我会看家");
    }

}

package st5;

public class Ragdoll extends Cat{

}

package st5;

public class Lihua extends Cat{

}

package st5;

public class Husky extends Dog{
    public void breakhome() {
        System.out.println("我会拆家");
    }
}

package st5;

public class Teddy extends Dog{
    public void Ceng(){
        System.out.println("我喜欢蹭一蹭");
    }
}

测试类：

package st5;

public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法

        //创建布偶猫的对象
        Ragdoll rd = new Ragdoll();
        System.out.println("我是布偶猫");
        rd.mice();
        rd.water();
        rd.eat();
        System.out.println("-------------------");

        //创建狸花猫的对象
        Lihua lh = new Lihua();
        System.out.println("我是狸花猫");
        lh.mice();
        lh.water();
        lh.eat();
        System.out.println("-------------------");

        //创建泰迪的对象
        Teddy td = new Teddy();
        System.out.println("我是泰迪");
        td.lookhome();
        td.water();
        td.eat();
        td.Ceng();
        System.out.println("-------------------");

        //创建哈士奇的对象
        Husky hs = new Husky();
        System.out.println("我是哈士奇");
        hs.lookhome();
        hs.water();
        hs.eat();
        hs.breakhome();

    }
}

试运行：

在这里插入图片描述

注意：子类只能访问父类中非私有的成员

3.子类到底能继承父类中的哪些内容

构造方法	非私有不能	private 不能
成员变量	非私有能	private 能但不能直接用
成员方法	虚方法表能	否则不能

虚方法表：就是经常要用的方法，什么叫虚方法表呢？非private 非static非final

4.继承中访问特点

继承中：成员变量的访问特点

public class Fu{
    String name = "Fu";
}
public class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);
    }
}
//就近原则:谁离我近，我就用谁
//完整版就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上
//run:ziShow

如果出现了重名的成员变量怎么找：

System.out.println(name);//从局部位置开始往上找
System.out.println(this.name);//从本类成员位置开始往上找
System.out.println(super.name);//从父类成员位置开始往上找

public class Test{
    public static void main (String [] args){
        Zi z = new Zi();
        z.ziShow();
    }
}

public class Fu{
    String name = "Fu";
}
public class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);//ziShow
        System.out.println(this.name);//Zi
        System.out.println(super.name);//Fu
    }
}

继承中：成员方法的访问特点

直接调用满足就近原则：谁离我近，我就用谁

super调用，直接访问父类

package jicehng;

public class test {
    public static void main(String[] args) {
        //创建一个对象
        Student s = new Student();
        s.lunch();
        /*
        吃面条
        咖啡
        吃米饭
        喝水
         */
    }
}
class Person {
    public void eat(){
        System.out.println("吃米饭");
    }
    public void water(){
        System.out.println("喝水");
    }
}
class Student extends Person {
    public void lunch(){
        this.eat();//就近读取子类吃面条
        this.water();//就近读取子类咖啡

        super.eat();//调用父类吃米饭
        super.water();//调用父类喝水
    }
    public void eat(){
        System.out.println("吃面条");
    }
    public void water(){
        System.out.println("咖啡");
    }
}

方法的重写：

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式：

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法

@Override重写体系

@Override是放在重写后的方法上，校验子类重写时语法是否正确
加上注解后如果有红色波浪线，表示语法错误
建议重写方法都加@Override注解，代码安全，优雅！

在这里插入图片描述

方法重写注意事项和要求：

重写方法的名称、形参列表必须于父类中的一致
子类重写父类方法时，访问权限子类必须大于等于父类（暂时了解：空着不写<protected<public）
子类重写父类方法时，返回值类型必须小于等于父类
建议：重写的方法尽量和父类保持一致
只有被添加到虚方法表中的方法才能被重写

在这里插入图片描述

JAVABean类：

package jice;

public class Dog {
    public void eat() {
        System.out.println("Dog is eating.");
    }
    public void drink() {
        System.out.println("Dog is drinking.");
    }
    public void lookhome() {
        System.out.println("Dog is lookhome.");
    }
}

package jice;

public class hashiqi extends Dog {
    public void breakhome() {
        System.out.println("hashiqi is breakhome.");
    }
}

package jice;

public class shapi extends Dog{
    @Override
    public void eat() {
        super.eat();// 调用父类的eat方法
        System.out.println("shapi is eating gouliang.");
    }
}

package jice;

public class chinesedog extends Dog{
    @Override
    public void eat() {
        super.eat();// 调用父类的eat方法
        System.out.println("Chinesedog is eating chinesefood.");
    }
}

测试类

package jice;

public class test {
    public static void main(String[] args) {
        hashiqi hashiqi = new hashiqi();
        hashiqi.eat();
        hashiqi.drink();
        hashiqi.lookhome();

        shapi shapi = new shapi();
        shapi.eat();
        shapi.drink();
        shapi.lookhome();

        chinesedog chinesedog = new chinesedog();
        chinesedog.eat();
        chinesedog.drink();
    }
}

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

父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己

为什么？
- 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
- 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化
怎么调用父类构造方法的？
- 子类构造方法的第一行语句默认都是：super(),不写也存在，且必须在第一行
- 如果想调用父类有参构造，必须手动写super进行调用

this、super使用总结

this：理解为一个变量，表示当前发给发调用者的地址值；

super：代表父类存储空间

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量访问本类成员变量	this.成员方法（…）访问本类成员方法	this(…) 访问本类构造方法
super	super.成员变量访问父类成员变量	super.成员方法（…）访问父类成员方法	super(…) 访问父类构造方法

 chinesedog chinesedog = new chinesedog();
    chinesedog.eat();
    chinesedog.drink();
}

}


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

- 父类中的构造方法不会被子类继承

- 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己

  为什么？

  - 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
  - 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化

  怎么调用父类构造方法的？

  - 子类构造方法的第一行语句默认都是：`super()`,不写也存在，且必须在第一行
  - 如果想调用父类有参构造，必须手动写`super`进行调用

### this、super使用总结

this：理解为一个变量，表示当前发给发调用者的地址值；

super：代表父类存储空间

| 关键字 | 访问成员变量                     | 访问成员方法                           | 访问构造方法                 |
| ------ | -------------------------------- | -------------------------------------- | ---------------------------- |
| this   | this.成员变量  访问本类成员变量  | this.成员方法（...） 访问本类成员方法  | this(...)  访问本类构造方法  |
| super  | super.成员变量  访问父类成员变量 | super.成员方法（...） 访问父类成员方法 | super(...)  访问父类构造方法 |

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=8yhmagt33rj