前言
本章将学习用java创建学生管理系统
一、主要功能
为StudentsManagementSystemProject添加菜单，有4个功能：
1. 添加学生（提示输入姓名后创建）
2. 显示所有学生（使用良好的格式显示）
3. 查询学生（输入姓名后查询学生）
4. 退出
二、读懂代码
1.Main代码
这段Java代码是一个学生管理系统的主程序。以下是对代码的逐行解释：
package code;//定义了一个名为code的包，包含Main类
import java.util.List;
import java.util.Scanner;
//导入了List和Scanner类，用于处理列表和用户输入
public class Main {
public static void main(String[] args) {
/**
* This program is a student management system that allows users to add, remove,
* and search for students by name, major, and GPA. It uses the Student and
* StudentManagementSystem classes to store and manage student data.
*/
// Initialize the scanner
Scanner scanner = new Scanner(System.in);//创建了一个Scanner对象，用于从控制台读取用户输入
StudentManagementSystem sms = new StudentManagementSystem();//创建了一个StudentManagementSystem对象，用于管理学生数据
boolean running = true;//定义了一个布尔变量running，用于控制程序的主循环
while (running) {//使用一个while循环来持续运行程序，直到用户选择退出
// Prompt user for input
System.out.println("Enter 1 to add a student");
System.out.println("Enter 2 to remove a student");
System.out.println("Enter 3 to search for a student by name");
System.out.println("Enter 4 to search for a student by major");
System.out.println("Enter 5 to search for a student by GPA");
System.out.println("Enter 6 to show all students");
System.out.println("Enter 7 to exit");
// Get user input
//输出菜单选项，让用户选择要执行的操作
int choice = scanner.nextInt();
// Process user input
//读取用户输入的选项
switch (choice) {
case 1:
// Add a student
System.out.println("Enter student name:");
String name = scanner.next();
System.out.println("Enter student age:");
int age = scanner.nextInt();
System.out.println("Enter student gender:");
String gender = scanner.next();
System.out.println("Enter student ID:");
String id = scanner.next();
System.out.println("Enter student major:");
String major = scanner.next();
System.out.println("Enter student GPA:");
double gpa = scanner.nextDouble();
Student student = new Student(name, age, gender, id, major, gpa);
sms.addStudent(student);
System.out.println("Student added successfully!\n");
break;
case 2:
// Remove a student
System.out.println("Enter student ID to remove:");
String removeId = scanner.next();
List<Student> students = sms.getStudents();
boolean removed = false;
for (Student s : students) {
if (s.getId().equals(removeId)) {
sms.removeStudent(s);
removed = true;
System.out.println("Student removed successfully!\n");
break;
}
}
if (!removed) {
System.out.println("Student not found!");
}
break;
case 3:
// Search for a student by name
System.out.println("Enter student name to search:");
String searchName = scanner.next();
List<Student> searchResults = sms.searchByName(searchName);
if (searchResults.isEmpty()) {
System.out.println("No students found!");
} else {
System.out.println("Search results:");
for (Student s : searchResults) {
System.out.println(s);
}
}
break;
case 4:
// Search for a student by major
System.out.println("Enter student major to search:");
String searchMajor = scanner.next();
searchResults = sms.searchByMajor(searchMajor);
if (searchResults.isEmpty()) {
System.out.println("No students found!");
} else {
System.out.println("Search results:");
for (Student s : searchResults) {
System.out.println(s);
}
}
break;
case 5:
// Search for a student by GPA
System.out.println("Enter student GPA to search:");
double searchGpa = scanner.nextDouble();
searchResults = sms.searchByGpa(searchGpa);
if (searchResults.isEmpty()) {
System.out.println("No students found!");
} else {
System.out.println("Search results:");
for (Student s : searchResults) {
System.out.println(s);
}
}
break;
case 6:
// Show all Students
List<Student> studentList = sms.getStudents();
if (studentList.size() == 0) {
System.out.println("The System Data is empty Now!");
}else {
for (Student studentItem : studentList) {
System.out.println(studentItem.toString());
}
}
break;
case 7:
// Exit the program
running = false;
System.out.println("Exit Successfully!");
break;
default:
// Invalid input
System.out.println("Invalid choice!");
break;
}
}
// Close scanner
scanner.close();
}
}
这个程序提供了一个简单的文本界面，允许用户对学生数据进行增删查改操作。需要注意的是，代码中省略了Student和StudentManagementSystem类的定义，这些类应该包含在同一个包中，以实现学生数据的存储和管理。
2、Student代码
这段Java代码定义了一个名为Student的类，它代表一个学生实体，并包含了学生的属性以及相应的构造器、getter和setter方法。以下是代码的逐行解释：
package code;
public class Student {//声明了六个私有成员变量，分别代表学生的姓名、年龄、性别、学号、专业和GPA
private String name;
private int age;
private String gender;
private String id;
private String major;
private double gpa;
public Student(String name, int age, String gender, String id, String major, double gpa) {//定义了一个公共构造器，它接受六个参数，分别对应学生的六个属性，并将这些参数值赋给相应的成员变量
this.name = name;
this.age = age;
this.gender = gender;
this.id = id;
this.major = major;
this.gpa = gpa;
}
public String getName() {//定义了一个名为getName的公共方法，它返回学生的姓名
return name;
}
public void setName(String name) {//定义了一个名为setName的公共方法，它接受一个字符串参数，并将其设置为学生的姓名
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public double getGpa() {
return gpa;
}
public void setGpa(double gpa) {
this.gpa = gpa;
}
@Override
public String toString() {//重写了Object类的toString方法，以提供一种将Student对象转换为字符串的便捷方式。这个方法返回一个包含所有学生属性值的字符串
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
", id='" + id + '\'' +
", major='" + major + '\'' +
", gpa=" + gpa +
'}';
}
}
这些方法使得外部代码能够安全地访问和修改Student对象的私有属性。this关键字用于区分成员变量和局部变量（参数）
3、StudentManagementSystem代码
这段Java代码定义了一个名为StudentManagementSystem的类，它负责管理学生列表，并提供添加、删除、获取以及按条件搜索学生信息的方法。以下是代码的逐行解释：
package code;
import java.util.ArrayList;
import java.util.List;
public class StudentManagementSystem {
private List<Student> students;//声明了一个私有成员变量students，它是一个List<Student>类型的列表，用于存储学生对象
public StudentManagementSystem() {//定义了一个公共构造器，它初始化students列表为一个空的ArrayList
students = new ArrayList<>();
}
public void addStudent(Student student) {//定义了一个名为addStudent的公共方法，它接受一个Student对象作为参数，并将其添加到students列表中
students.add(student);
}
public void removeStudent(Student student) {//定义了一个名为removeStudent的公共方法，它接受一个Student对象作为参数，并从students列表中移除该对象
students.remove(student);
}
public List<Student> getStudents() {
return students;
}
public List<Student> searchByName(String name) {//定义了一个名为searchByName的公共方法，它接受一个字符串参数name，并返回所有姓名与该参数匹配的学生列表
List<Student> result = new ArrayList<>();
for (Student student : students) {
if (student.getName().equals(name)) {
result.add(student);
}
}
return result;
}
public List<Student> searchByMajor(String major) {
List<Student> result = new ArrayList<>();
for (Student student : students) {
if (student.getMajor().equals(major)) {
result.add(student);
}
}
return result;
}
public List<Student> searchByGpa(double gpa) {
List<Student> result = new ArrayList<>();
for (Student student : students) {
if (student.getGpa() == gpa) {
result.add(student);
}
}
return result;
}
}
这个类提供了对学生信息的基本管理功能，包括添加、删除、获取学生列表，以及根据姓名、专业和GPA进行搜索。在搜索方法中，创建了一个新的ArrayList来存储匹配的结果，并遍历students列表来查找匹配的学生。最后，返回包含匹配结果的新列表。如果没有任何匹配项，将返回一个空的列表。
4、StudentManagementSystemTest代码
package code;
import java.util.List;
import java.util.Scanner;
public class StudentManagementSystemTest {
public static void main(String[] args) {
StudentManagementSystem sms = new StudentManagementSystem();
Student s1 = new Student("John", 20, "Male", "001", "Computer Science", 3.5);
Student s2 = new Student("Mary", 21, "Female", "002", "Mathematics", 3.8);
Student s3 = new Student("Tom", 19, "Male", "003", "Physics", 3.2);
sms.addStudent(s1);
sms.addStudent(s2);
sms.addStudent(s3);
System.out.println("All students: " + sms.getStudents());
System.out.println("Search by name: " + sms.searchByName("John"));
System.out.println("Search by major: " + sms.searchByMajor("Mathematics"));
System.out.println("Search by GPA: " + sms.searchByGpa(3.5));
sms.removeStudent(s2);
System.out.println("All students after removing Mary: " + sms.getStudents());
}
}
这个测试类演示了如何使用StudentManagementSystem类来添加、移除和搜索学生。通过创建几个Student对象并将它们添加到系统中，然后执行搜索和移除操作，并打印结果，来验证StudentManagementSystem类的功能是否按预期工作。
三、基本语法讲解
1. 变量
变量是存储数据的容器。在Java中，你必须声明并初始化变量才能使用它。
int number = 10; // 声明一个整型变量number，并初始化为10
String name = "Alice"; // 声明一个字符串变量name，并初始化为"Alice"
2. 数据类型
Java是静态类型语言，这意味着所有变量必须声明其数据类型。
- 基本数据类型：
int,double,float,byte,short,long,char,boolean - 引用数据类型：
String, 数组, 类, 接口等
3. 运算符
Java支持各种运算符，包括算术运算符（+, -, *, /）、关系运算符（==, !=, >, <）、逻辑运算符（&&, ||, !）等。
int a = 10;
int b = 20;
int sum = a + b; // 算术运算
boolean isGreater = a > b; // 关系运算
boolean isTrue = isGreater && (b > 0); // 逻辑运算4. 控制结构
- 条件语句：
if,else if,else - 循环语句：
for,while,do-while
if (a > b) {
System.out.println("a is greater than b");
} else {
System.out.println("a is not greater than b");
}
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
5. 函数/方法
Java中的函数称为方法。它们用于封装可重用的代码块。
public static int add(int x, int y) {
return x + y;
}
6. 类和对象
Java是一门面向对象的编程语言。类是创建对象的蓝图。
public class Person {
String name;
int age;
public void introduce() {
System.out.println("My name is " + name + " and I am " + age + " years old.");
}
}
Person alice = new Person();
alice.name = "Alice";
alice.age = 30;
alice.introduce();
7. 构造器
构造器是一种特殊的方法，用于初始化对象。
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// ... 方法 ...
}
Person bob = new Person("Bob", 40);
8. 继承
继承允许子类继承父类的属性和方法。
public class Employee extends Person {
String position;
public Employee(String name, int age, String position) {
super(name, age); // 调用父类的构造器
this.position = position;
}
// ... 方法 ...
}
9. 接口
接口定义了一组抽象方法，类可以实现接口。
public interface Animal {
void eat();
void sound();
}
public class Dog implements Animal {
public void eat() {
System.out.println("Dog eats meat.");
}
public void sound() {
System.out.println("Dog barks.");
}
}
10. 包
包用于组织类和接口，并提供命名空间。
package mypackage;
public class MyClass {
// ...
}
四、类讲解
在Java编程语言中，类（Class）是面向对象编程（OOP）的基础。类定义了对象的属性和行为。以下是关于Java类的一些关键总结：
-
类的定义：类使用
class关键字定义，包含成员变量（字段）和方法（函数）。 -
成员变量：成员变量是类中定义的数据，表示对象的属性或状态。
-
构造器：构造器是一种特殊的方法，用于创建类的实例。构造器的名称必须与类名相同。
-
方法：方法定义了类的行为，可以是访问和操作成员变量的函数。
-
访问修饰符：访问修饰符控制类成员的访问级别，包括
public,private,protected, 和默认。 -
封装：封装是面向对象编程的一个原则，它隐藏了类的内部实现细节，只通过公共接口访问。
-
继承：继承允许一个类继承另一个类的属性和方法，子类可以扩展父类的功能。
-
多态：多态允许一个接口被多个类实现，或者一个类可以有多个子类，它们都可以以不同的方式实现接口或继承的方法。
-
抽象类和方法：抽象类不能被实例化，只能被继承。抽象方法是没有实现体的方法，必须在子类中被实现。
-
静态成员：静态成员属于类本身，而不是类的任何实例，可以通过类名直接访问。
通过这些概念，Java允许开发者创建可重用、可扩展、易于维护的代码。这些基础概念是学习Java和面向对象编程的基础。
扫一扫
211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
