Java 静态成员与继承封装实战：从报错到彻底吃透核心特性

在学习 Java 面向对象编程时，"静态成员（static）""封装（private）""继承（extends）"看似基础，却是最容易在实际编程中踩坑的部分。作为物联网工程专业的学生，我在完成《静态成员与简单继承》实验时，从多处报错到彻底理解底层逻辑，最终真正理解了 Java 面向对象的设计思想。

本文面向初学者，通过 完整代码 + 高亮解释 + 踩坑还原 + 思维总结 的方式，从实战角度带你掌握 Java 静态成员、封装与继承的核心本质。

📌 一、实验背景与任务目标

实验环境：JDK 1.8 + Eclipse

本次实验分两个部分：

1）Dog + Person 实体类与互动功能（同包）

目标：

使用 static 统计狗狗总数
创建狗狗对象、打印信息
Person 与 Dog 关联，实现改名、玩耍等功能
运用封装思想管理属性

2）跨包继承设计（不同包）

父类：gc.Person
子类：gc.zg.Teacher & gc.xs.Student
实践不同权限修饰符的访问规则
理解 super(...) 构造方法调用机制

📌 二、核心代码实现（附详细解析）

✅ 2.1 狗狗管理与人狗互动模块

Dog 类：含静态数量统计（static）

java 复制代码

package xyt_1;

public class Dog {
    String numbers;
    String name;
    int age;
    String colour;

    // 静态变量：所有对象共享
    public static int count = 0;

    public Dog(){}

    public Dog(String numbers,String name,int age,String colour) {
        this.numbers = numbers;
        this.name = name;
        this.age = age;
        this.colour = colour;
        ++count; // 每创建一个对象，总数+1
    }

    void enjoy() {
        System.out.println(name + "很开心，汪汪汪地叫");
    }

    void printDog() {
        System.out.println("狗狗编号：" + numbers);
        System.out.println("名字：" + name);
        System.out.println("年龄：" + age);
        System.out.println("颜色：" + colour);
    }
}

Person 类：人与狗狗交互，运用封装

java 复制代码

package xyt_1;

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

    private Dog dog;

    public Person() {}

    public Person(String name,int age,String gender,Dog dog) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.dog = dog;
    }

    // 为狗狗改名
    public void changeDogName(String newName) {
        System.out.println(name + "正在为狗狗改名：");
        dog.name = newName;
        System.out.println("狗狗的新名字是：" + dog.name);
    }

    // 与狗狗玩耍
    public void playWith() {
        System.out.println(name + "正在和狗狗玩耍～");
        dog.enjoy();
    }

    public void printPerson() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("性别：" + gender);
        dog.printDog();
    }
}

测试类 TestStatic

java 复制代码

package xyt_1;

public class TestStatic {
    public static void main(String args[]) {
        Dog dog_1 = new Dog("123","小花",4,"黄色");
        Dog dog_2 = new Dog("456","太吉",5,"红色");

        dog_1.printDog();
        dog_2.printDog();

        System.out.println("\n一共有 " + Dog.count + " 条狗");

        Person p1 = new Person("lily",18,"女",dog_1);
        p1.printPerson();
        p1.changeDogName("Bailey");

        System.out.print("\nlily同Bailey玩耍，");
        dog_1.enjoy();
    }
}

✅ 2.2 跨包继承模块（权限修饰符 + super 调用）

父类 Person（gc 包）

java 复制代码

package gc;

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

    public Person(){}

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

    public void info() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("性别：" + gender);
    }
}

Teacher 子类（gc.zg 包）

java 复制代码

package gc.zg;

import gc.Person;

public class Teacher extends Person {
    private String rank;

    public Teacher(){}

    public Teacher(String name,int age,String gender,String rank){
        super(name,age,gender);  // 调用父类构造
        this.rank = rank;
    }

    public void info_teacher(){
        System.out.println("===== 教师信息 =====");
        super.info();
        System.out.println("职称：" + rank);
    }
}

Student 子类（gc.xs 包）

java 复制代码

package gc.xs;

import gc.Person;

public class Student extends Person {
    private String school;

    public Student(){}

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

    public void info_student(){
        System.out.println("===== 学生信息 =====");
        super.info();
        System.out.println("学校：" + school);
    }
}

📌 三、实验踩坑记录与解决方案（最实用部分）

✅ 1. 静态变量访问错误

错误写法：

java 复制代码

System.out.println(count);

报错：count cannot be resolved

正确写法：

java 复制代码

System.out.println(Dog.count);

✅ 2. 跨包继承忘记 import 导致找不到类

报错：The import gc.Person cannot be resolved

解决：

java 复制代码

import gc.Person;

✅ 3. 子类未调用 super，父类属性全部是 null/0

解决：

java 复制代码

super(name, age, gender);

✅ 4. 错误理解"private 不会继承"

正确理解：

private 会继承，只是子类不能直接访问
子类通过构造方法、getter/setter 来让父类自己初始化

✅ 5. void 方法被拼接字符串输出导致 null

错误：

java 复制代码

System.out.println("玩耍：" + dog_1.enjoy());

输出：

复制代码

Bailey很开心...
玩耍：null

原因：void 方法返回值当成 null。

正确写法：

java 复制代码

System.out.print("玩耍：");
dog_1.enjoy();

📌 四、核心知识点总结（适合作为复习笔记保存）

✅ 1. static 静态成员

属于类，不属于对象
所有实例共享
用途：计数、共享资源、常量等
推荐使用：类名.静态成员

✅ 2. 封装（private + getter/setter）

目的：

隐藏内部数据
防止外部非法修改
可增加验证逻辑（如年龄范围）

✅ 3. 继承 extends（代码复用核心）

子类拥有父类全部非 private 成员
private 继承但不可直接访问
构造方法不继承，必须手动调用 super(...)
子类可扩展自己的功能与属性

✅ 4. 权限修饰符总结

修饰符	同类	同包	子类	跨包	典型用途
private	✅	❌	❌	❌	属性封装
默认	✅	✅	❌	❌	包内部共享
protected	✅	✅	✅	❌	子类可访问
public	✅	✅	✅	✅	对外接口

📌 五、实验收获：从语法学习到真正面向对象思维

通过这次编程实践，我深刻理解了：

static 是"类级共享资源"
封装是"数据安全的基础"
继承是"代码复用的最佳方式"
权限修饰符决定了跨包访问行为
遇到报错不要慌，要先理解原理

这些都是 Java 面向对象的底层能力，也是后续学习框架（Spring、MyBatis）、设计模式的重要基础。

如果你觉得本文对你有帮助，欢迎点赞、收藏、评论交流。