今天写一个学生管理系统，那咱们就用 Java 搞一个简单的出来，顺便展示一下面向对象编程（OOP）的四大核心概念：封装、继承、抽象和多态。我希望你很好看好好学兄弟，我尽量给你整得生动点，made，别睡着啊！
系统设计目标
首先咱们这个学生管理系统得有以下功能：
- 学生信息管理：能添加、查看、修改、删除学生信息。
- 课程管理：给学生分配课程，查看他们选了啥。
- 成绩管理：记录课程成绩，算个平均分啥的。
为了整明白 OOP，咱们得设计几个类：
Student：学生类，装学生的基本信息。Course：课程类，装课程相关的东西。StudentManagementSystem：管理系统类，负责把学生和课程串起来。
1. 封装
封装就是把数据和操作数据的方法绑一块儿，用访问控制保护起来，防止外面瞎搞，不然Tamara的他在外面就能搞我程序，mark我不就是肥五了吗。咱们给 Student 和 Course 类设私有属性，然后弄点公共的 Getter 和 Setter 方法。
Student 类代码
import java.util.ArrayList;
import java.util.List;
public class Student {
private String name; // 姓名
private int id; // 学号
private List<Course> courses = new ArrayList<>(); // 课程列表，不会列表就去查，兄弟本文不教最基础的了。
public Student(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<Course> getCourses() {
return courses;
}
public void addCourse(Course course) {
courses.add(course);
}
public void removeCourse(Course course) {
courses.remove(course);
}
// 计算平均成绩
public double calculateAverageGrade() {
if (courses.isEmpty()) {
return 0.0;
}
double sum = 0.0;
for (Course course : courses) {
sum += course.getGrade();
}
return sum / courses.size();
}
}
Course 类代码
public class Course {
private String courseName; // 课程名
private int courseId; // 课程ID
private double grade; // 成绩
public Course(String courseName, int courseId) {
this.courseName = courseName;
this.courseId = courseId;
this.grade = 0.0; // 默认成绩为0
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public int getCourseId() {
return courseId;
}
public void setCourseId(int courseId) {
this.courseId = courseId;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
if (grade >= 0 && grade <= 100) {
this.grade = grade;
} else {
System.out.println("兄弟，成绩得在0-100之间，你这输入的是啥？");
}
}
}
看明白没？这封装搞得挺规范，属性都 private，外面只能通过 Getter Setter 访问。Course 里的 setGrade 还加了个校验，防着你乱填成绩。还行吧？要是这都不懂，你是 big 吗？赶紧回去看基础篇。
2. 继承
继承就是让子类复用父类的代码，顺便扩展点新功能。咱们弄个 GraduateStudent 类，继承 Student，给研究生加个论文题目啥的。
GraduateStudent 类代码
public class GraduateStudent extends Student {
private String thesisTitle; // 论文题目
public GraduateStudent(String name, int id, String thesisTitle) {
super(name, id); // 调用父类构造方法
this.thesisTitle = thesisTitle;
}
public String getThesisTitle() {
return thesisTitle;
}
public void setThesisTitle(String thesisTitle) {
this.thesisTitle = thesisTitle;
}
@Override
public void addCourse(Course course) {
if (getCourses().size() < 5) {
super.addCourse(course); // 调用父类的添加课程方法
} else {
System.out.println("研究生课程不能超5门，兄弟，别贪多嚼不烂啊！");
}
}
}
继承整得还行吧，GraduateStudent 拿了 Student 的所有东西，还加了个 thesisTitle。重写了 addCourse，限制课程数不超过5门。有什么别的想法没，不过现实中课程限制可能更复杂，先这样吧，基础篇嘛。
3. 抽象
抽象是定义个通用模板，让子类去实现具体行为。咱们搞个 Person 抽象类，Student 继承它，体现一下抽象的魅力。
Person 抽象类代码
public abstract class Person {
private String name;
private int id;
public Person(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public int getId() {
return id;
}
// 抽象方法，子类必须实现
public abstract void performDuty();
}
修改 Student 类（继承 Person）
import java.util.ArrayList;
import java.util.List;
public class Student extends Person {
private List<Course> courses = new ArrayList<>();
public Student(String name, int id) {
super(name, id);
}
@Override
public void performDuty() {
System.out.println("学生 " + getName() + " 在学习呢，别打扰！");
}
public List<Course> getCourses() {
return courses;
}
public void addCourse(Course course) {
courses.add(course);
}
public void removeCourse(Course course) {
courses.remove(course);
}
public double calculateAverageGrade() {
if (courses.isEmpty()) {
return 0.0;
}
double sum = 0.0;
for (Course course : courses) {
sum += course.getGrade();
}
return sum / courses.size();
}
}
Person 定义了个 performDuty 抽象方法，Student 实现成“在学习”。挺好，不过这 performDuty 就打印一句，实际项目里得复杂点，先这样吧，基础篇嘛。
4. 多态
多态就是用父类引用指向子类对象，运行时调用子类的实现。咱们在 StudentManagementSystem 里展示一下。
StudentManagementSystem 类代码
import java.util.ArrayList;
import java.util.List;
public class StudentManagementSystem {
private List<Person> people = new ArrayList<>();
public void addPerson(Person person) {
people.add(person);
}
public void performDuties() {
for (Person person : people) {
person.performDuty(); // 多态：调用具体子类的实现
}
}
}
List<Person> 能装 Student 和 GraduateStudent，调用 performDuty 时自动跑各自的实现。有发现什么问题吗，这 GraduateStudent 没重写 performDuty，得加上，比如“研究生在搞研究”，不然不完整啊，你是 big 吗？
5. 完整系统整合
最后，咱们把这些拼一块儿，弄个简单的命令行示例，跑起来看看效果。
Main 类代码
public class Main {
public static void main(String[] args) {
StudentManagementSystem sms = new StudentManagementSystem();
// 创建学生和课程
Student student = new Student("张三", 1);
Course math = new Course("数学", 101);
Course english = new Course("英语", 102);
student.addCourse(math);
student.addCourse(english);
math.setGrade(90);
english.setGrade(85);
// 创建研究生
GraduateStudent gradStudent = new GraduateStudent("李四", 2, "Java 编程");
Course java = new Course("Java", 201);
gradStudent.addCourse(java);
java.setGrade(95);
// 加入管理系统
sms.addPerson(student);
sms.addPerson(gradStudent);
// 输出平均成绩
System.out.println("学生 " + student.getName() + " 的平均成绩: " + student.calculateAverageGrade());
System.out.println("研究生 " + gradStudent.getName() + " 的平均成绩: " + gradStudent.calculateAverageGrade());
// 执行职责
System.out.println("\n所有人的职责：");
sms.performDuties();
}
}
运行输出：
学生 张三 的平均成绩: 87.5
研究生 李四 的平均成绩: 95.0
所有人的职责：
学生 张三 在学习呢，别打扰！
学生 李四 在学习呢，别打扰！
系统整合得还行，学生和课程都管起来了，平均分也算出来了。不过这界面太简陋，实际得加个 Scanner 让用户输入啥的。但先这样吧，基础篇嘛。研究生 performDuty 没改，你看着办吧！
总结
这个学生管理系统展示了 OOP 四大核心：
- 封装：私有属性 + Getter/Setter，数据安全得很。
- 继承：
GraduateStudent继承Student，扩展功能。 - 抽象：
Person抽象类定了通用规则。 - 多态：
StudentManagementSystem用父类引用管子类，灵活得很。