学生管理系统

好多人在学习完Java基础之后都找不到很好的基础项目进行练习,次项目主要是为了让初学者通过本项目来掌握面向对象的了解及其掌握;

学生管理系统主要完成用户登录,对学生信息的增删改查以及排序;

  1 package com.bj.dxb;
  2 
  3 public class Menu {
  4     private static Menu instance = null;
  5 
  6     /**
  7      * 无参构造方法
  8      */
  9     private Menu() {
 10 
 11     }
 12 
 13     /**
 14      * 单例设计模式
 15      */
 16     public static Menu getInstance() {
 17         if (instance == null) {
 18             instance = new Menu();
 19             return instance;
 20         }
 21         return instance;
 22     }
 23 
 24     /**
 25      * 主界面
 26      */
 27     public void mainMenu() {
 28         System.out.println("*************************");
 29         System.out.println("**      1 添加学生       **");
 30         System.out.println("**      2 查找学生       **");
 31         System.out.println("**      3 修改学生       **");
 32         System.out.println("**      4 删除学生       **");
 33         System.out.println("**      5 排序记录       **");
 34         System.out.println("**      6 退出系统       **");
 35         System.out.println("*************************");
 36     }
 37 
 38     /**
 39      * 添加界面
 40      */
 41     public void addMenu() {
 42         System.out.println("*************************");
 43         System.out.println("**      1 添加新记录      **");
 44         System.out.println("**      2 查看全记录      **");
 45         System.out.println("**      3 返回上一级      **");
 46         System.out.println("*************************");
 47 
 48     }
 49 
 50     /**
 51      * 查找界面
 52      */
 53     public void searchMenu() {
 54         System.out.println("*************************");
 55         System.out.println("**      1 按姓名查找      **");
 56         System.out.println("**      2 按年龄查找      **");
 57         System.out.println("**      3 按性别查找      **");
 58         System.out.println("**      4 按号码查找      **");
 59         System.out.println("**      5 按住址查找      **");
 60         System.out.println("**      6 按成绩查找      **");
 61         System.out.println("**      7 查看全记录      **");
 62         System.out.println("**      8 返回上一级      **");
 63         System.out.println("*************************");
 64 
 65     }
 66 
 67     /**
 68      * 修改界面
 69      */
 70     public void modifyMenu() {
 71         System.out.println("*************************");
 72         System.out.println("**      1 查看全记录      **");
 73         System.out.println("**      2 修改指定记录    **");
 74         System.out.println("**      3 返回上一级      **");
 75         System.out.println("*************************");
 76     }
 77 
 78     /**
 79      * 修改子界面
 80      */
 81     public void subModifyMenu() {
 82         System.out.println("*************************");
 83         System.out.println("**      1 修改姓名       **");
 84         System.out.println("**      2 修改年龄       **");
 85         System.out.println("**      3 修改性别       **");
 86         System.out.println("**      4 修改号码       **");
 87         System.out.println("**      5 修改住址       **");
 88         System.out.println("**      6 修改成绩       **");
 89         System.out.println("**      7 返回上一级     **");
 90         System.out.println("*************************");
 91     }
 92 
 93     /**
 94      * 删除界面
 95      */
 96     public void deleteMenu() {
 97         System.out.println("*************************");
 98         System.out.println("**      1 查看全记录      **");
 99         System.out.println("**      2 删除指定记录    **");
100         System.out.println("**      3 删除全部记录    **");
101         System.out.println("**      4 返回上一级      **");
102         System.out.println("*************************");
103     }
104 
105     /**
106      * 排序界面
107      */
108     public void orderMenu() {
109         System.out.println("*************************");
110         System.out.println("**      1 按姓名排序      **");
111         System.out.println("**      2 按年龄排序      **");
112         System.out.println("**      3 按性别排序      **");
113         System.out.println("**      4 按原始排序      **");
114         System.out.println("**      5 按成绩排序      **");
115         System.out.println("**      6 查看全部记录    **");
116         System.out.println("**      7 返回上一级      **");
117         System.out.println("*************************");
118     }
119 
120 }
Menu
  1 package com.bj.dxb;
  2 
  3 public class Student {
  4     /**
  5      * 学生ID
  6      */
  7     private int id;
  8     /**
  9      * 学生姓名
 10      */
 11     private String name;
 12     /**
 13      * 学生年龄
 14      */
 15     private String age;
 16     /**
 17      * 学生性别
 18      */
 19     private String sex;
 20     /**
 21      * 学生电话号码
 22      */
 23     private String telNum;
 24     /**
 25      * 学生地址
 26      */
 27     private String address;
 28     /**
 29      * 学生成绩
 30      */
 31     private double course;
 32 
 33     /**
 34      * 无参构造方法
 35      */
 36     public Student() {
 37 
 38     }
 39 
 40     /**
 41      * 有参构造函数
 42      * 
 43      * @param name
 44      * @param age
 45      * @param sex
 46      * @param telNum
 47      * @param address
 48      * @param course
 49      */
 50     public Student(String name, String age, String sex, String telNum,
 51             String address, double course) {
 52         super();
 53         this.name = name;
 54         this.age = age;
 55         this.sex = sex;
 56         this.telNum = telNum;
 57         this.address = address;
 58         this.course = course;
 59     }
 60 
 61     /**
 62      * 获取学生ID
 63      * 
 64      * @return
 65      */
 66     public int getId() {
 67         return id;
 68     }
 69 
 70     /**
 71      * 设置学生ID
 72      * 
 73      * @param id
 74      */
 75     public void setId(int id) {
 76         this.id = id;
 77     }
 78 
 79     /**
 80      * 获取学生姓名
 81      * 
 82      * @return
 83      */
 84     public String getName() {
 85         return name;
 86     }
 87 
 88     /**
 89      * 设置学生姓名
 90      * 
 91      * @param name
 92      */
 93     public void setName(String name) {
 94         this.name = name;
 95     }
 96 
 97     /**
 98      * 获取学生年龄
 99      * 
100      * @return
101      */
102     public String getAge() {
103         return age;
104     }
105 
106     /**
107      * 设置学生年龄
108      * 
109      * @param age
110      */
111     public void setAge(String age) {
112         this.age = age;
113     }
114 
115     /**
116      * 获取学生性别
117      * 
118      * @return
119      */
120     public String getSex() {
121         return sex;
122     }
123 
124     /**
125      * 设置学生性别
126      * 
127      * @param sex
128      */
129     public void setSex(String sex) {
130         this.sex = sex;
131     }
132 
133     /**
134      * 获取学生电话
135      * 
136      * @return
137      */
138     public String getTelNum() {
139         return telNum;
140     }
141 
142     /**
143      * 设置学生电话
144      * 
145      * @param telNum
146      */
147     public void setTelNum(String telNum) {
148         this.telNum = telNum;
149     }
150 
151     /**
152      * 获取学生地址
153      * 
154      * @return
155      */
156     public String getAddress() {
157         return address;
158     }
159 
160     /**
161      * 设置学生地址
162      * 
163      * @param address
164      */
165     public void setAddress(String address) {
166         this.address = address;
167     }
168 
169     /**
170      * 获取学生成绩
171      * 
172      * @return
173      */
174     public double getCourse() {
175         return course;
176     }
177 
178     /**
179      * 设置学生成绩
180      * 
181      * @param course
182      */
183     public void setCourse(double course) {
184         this.course = course;
185     }
186 
187     /**
188      * toString()方法
189      */
190     @Override
191     public String toString() {
192         return "# " + "姓名 " + name + "\t年龄 " + age + "\t性别 " + sex + "\t电话号码 "
193                 + telNum + "\t住址 " + address + "\t成绩 " + course;
194     }
195 }
Student
  1 package com.bj.dxb;
  2 
  3 import java.util.Scanner;
  4 
  5 /**
  6  * 用户输入验证类
  7  */
  8 public class StudentMangerRegex {
  9     /**
 10      * 对用户输入的用户名进行校验
 11      * 
 12      * @return
 13      */
 14     public String userNameRegex() {
 15         Scanner scanner = new Scanner(System.in);
 16         String regex = "[a-zA-Z]{1,10}";
 17         while (true) {
 18             System.out.println("输入用户名:1-10位字母");
 19             String inputStr = scanner.nextLine();
 20             if (inputStr.matches(regex)) {
 21                 return inputStr;
 22             } else {
 23                 System.out.println("输入用户名错误,请检查");
 24             }
 25         }
 26     }
 27 
 28     /**
 29      * 对用户输入的密码进行校验
 30      * 
 31      * @return
 32      */
 33     public String userpwdRegex() {
 34         Scanner scanner = new Scanner(System.in);
 35         String regex = "[a-zA-Z]{1,10}";
 36         while (true) {
 37             System.out.println("输入密码:1-10位字母");
 38             String inputStr = scanner.nextLine();
 39             if (inputStr.matches(regex)) {
 40                 return inputStr;
 41             } else {
 42                 System.out.println("输入密码错误,请检查");
 43             }
 44         }
 45     }
 46 
 47     /**
 48      * 对菜单输入选项的验证
 49      * 
 50      * @param min
 51      * @param max
 52      * @return
 53      */
 54     public int menuRegex(int min, int max) {
 55         Scanner scanner = new Scanner(System.in);
 56         String regex = "[" + min + "-" + max + "]{1}";
 57         int i = 0;
 58         while (true) {
 59             System.out.println("请输入正确的数字,最小是: " + min + " 最大是: " + max);
 60             String inputStr = scanner.nextLine();
 61             if (inputStr.matches(regex)) {
 62                 i = Integer.parseInt(inputStr);
 63                 return i;
 64             } else {
 65                 System.out.println("输入数字错误,请检查");
 66             }
 67         }
 68     }
 69 
 70     /**
 71      * 对用户输入姓名的验证
 72      * 
 73      * @return
 74      */
 75     public String nameRegex() {
 76         Scanner scanner = new Scanner(System.in);
 77         String regex = "[a-zA-Z]{1,10}";
 78         while (true) {
 79             System.out.println("输入姓名:1-10位字母");
 80             String inputStr = scanner.nextLine();
 81             if (inputStr.matches(regex)) {
 82                 return inputStr;
 83             } else {
 84                 System.out.println("输入姓名错误,请检查");
 85             }
 86         }
 87     }
 88 
 89     /**
 90      * 对用户输入年龄的验证
 91      * 
 92      * @return
 93      */
 94     public String ageRegex() {
 95         Scanner scanner = new Scanner(System.in);
 96         String regex = "[1-9]|[1-9]\\d|1[0-2]\\d";
 97         while (true) {
 98             System.out.println("输入年龄:1-100+");
 99             String inputStr = scanner.nextLine();
100             if (inputStr.matches(regex)) {
101                 return inputStr;
102             } else {
103                 System.out.println("输入年龄错误,请检查");
104             }
105         }
106     }
107 
108     /**
109      * 对用户输入性别的验证
110      * 
111      * @return
112      */
113     public String sexRegex() {
114         Scanner scanner = new Scanner(System.in);
115         String regex = "[mMfF]{1}";
116         while (true) {
117             System.out.println("输入性别,(男 m or M) (女 f or F)");
118             String inputStr = scanner.nextLine();
119             if (inputStr.matches(regex)) {
120                 return inputStr;
121             } else {
122                 System.out.println("输入性别错误,请检查");
123             }
124         }
125     }
126 
127     /**
128      * 对用户输入电话号码的验证
129      * 
130      * @return
131      */
132     public String telNumRegex() {
133         Scanner scanner = new Scanner(System.in);
134         String regex = "\\d{6,11}";
135         while (true) {
136             System.out.println("输入电话号码,6-11位数字");
137             String inputStr = scanner.nextLine();
138             if (inputStr.matches(regex)) {
139                 return inputStr;
140             } else {
141                 System.out.println("输入电话号码错误,请检查");
142             }
143         }
144     }
145 
146     /**
147      * 对用户输入地址的验证
148      * 
149      * @return
150      */
151     public String addressRegex() {
152         Scanner scanner = new Scanner(System.in);
153         String regex = "[a-zA-z0-9]{1,50}";
154         while (true) {
155             System.out.println("输入地址,1-50位字母或数字");
156             String inputStr = scanner.nextLine();
157             if (inputStr.matches(regex)) {
158                 return inputStr;
159             } else {
160                 System.out.println("输入地址错误,请检查");
161             }
162         }
163     }
164 
165     /**
166      * 对用户输入的成绩进行校验
167      */
168     public double courseRegex() {
169         Scanner scanner = new Scanner(System.in);
170         String regex = "[0-9]{1,3}";
171         while (true) {
172             System.out.println("输入成绩,1-3位数字");
173             String inputStr = scanner.nextLine();
174             if (inputStr.matches(regex)) {
175                 double course = Double.parseDouble(inputStr);
176                 return course;
177             } else {
178                 System.out.println("输入成绩错误,请检查");
179             }
180         }
181     }
182 }
StudentMangerRegex
  1 package com.bj.dxb;
  2 
  3 import java.util.Collections;
  4 import java.util.Comparator;
  5 import java.util.Vector;
  6 
  7 public class Operate {
  8     private Vector<Student> vector = new Vector<Student>();
  9     private int id = 1;
 10 
 11     /**
 12      * 对用户名和密码的校验
 13      * 
 14      * @return
 15      */
 16     public boolean login() {
 17         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
 18         String userName = studentMangerRegex.userNameRegex();
 19         String password = studentMangerRegex.userpwdRegex();
 20         if (userName.equals(password)) {
 21             System.out.println("你输入的用户名和密码正确,欢迎'".concat(userName).concat(
 22                     "'使用本系统!"));
 23             return true;
 24         } else {
 25             System.out.println("你输入的用户名和密码不正确,请重新输入!");
 26             return false;
 27         }
 28     }
 29 
 30     /**
 31      * 添加学生信息业务逻辑控制
 32      */
 33     public void addLogic() {
 34         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
 35         while (true) {
 36             Menu.getInstance().addMenu();
 37             int key = studentMangerRegex.menuRegex(1, 3);
 38             switch (key) {
 39             case 1:
 40                 addOperation();
 41                 break;
 42             case 2:
 43                 showAll();
 44                 break;
 45             case 3:
 46                 return;
 47             }
 48         }
 49     }
 50 
 51     /**
 52      * 学生信息查询业务逻辑控制
 53      */
 54     public void searchLogic() {
 55         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
 56         int size = vector.size();
 57         if (size == 0) {
 58             System.out.println("学生管理系统没有信息,请先添加信息后再操作!");
 59         } else {
 60             while (true) {
 61                 Menu.getInstance().searchMenu();
 62                 int key = studentMangerRegex.menuRegex(1, 8);
 63                 switch (key) {
 64                 case 1:
 65                     searchByName();
 66                     break;
 67                 case 2:
 68                     searchByAge();
 69                     break;
 70                 case 3:
 71                     searchBySex();
 72                     break;
 73                 case 4:
 74                     searchByTelNum();
 75                     break;
 76                 case 5:
 77                     searchByAdd();
 78                     break;
 79                 case 6:
 80                     searchByCourse();
 81                     break;
 82                 case 7:
 83                     showAll();
 84                     break;
 85                 case 8:
 86                     return;
 87                 }
 88             }
 89         }
 90     }
 91 
 92     /**
 93      * 学生信息修改业务逻辑控制
 94      */
 95     public void modifyLogicLogic() {
 96         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
 97         int size = vector.size();
 98         if (size == 0) {
 99             System.out.println("学生管理系统没有信息,请先添加信息后再操作!");
100         } else {
101             while (true) {
102                 Menu.getInstance().modifyMenu();
103                 int key = studentMangerRegex.menuRegex(1, 3);
104                 switch (key) {
105                 case 1:
106                     showAll();
107                     break;
108                 case 2:
109                     modify();
110                     break;
111                 case 3:
112                     return;
113                 }
114             }
115         }
116     }
117 
118     /**
119      * 学生信息删除业务逻辑控制
120      */
121     public void deleteLogic() {
122         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
123         int size = vector.size();
124         if (size == 0) {
125             System.out.println("学生管理系统没有信息,请先添加信息后再操作!");
126         } else {
127             while (true) {
128                 Menu.getInstance().deleteMenu();
129                 int key = studentMangerRegex.menuRegex(1, 4);
130                 switch (key) {
131                 case 1:
132                     showAll();
133                     break;
134                 case 2:
135                     delete();
136                     break;
137                 case 3:
138                     deleteAll();
139                     break;
140                 case 4:
141                     return;
142                 }
143             }
144         }
145     }
146 
147     /**
148      * 学生信息排序业务逻辑控制
149      */
150     public void orderLogic() {
151         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
152         int size = vector.size();
153         if (size == 0) {
154             System.out.println("学生管理系统没有信息,请先添加信息后再操作!");
155         } else {
156             while (true) {
157                 Menu.getInstance().orderMenu();
158                 int key = studentMangerRegex.menuRegex(1, 7);
159                 switch (key) {
160                 case 1:
161                     orderName();
162                     break;
163                 case 2:
164                     orderAge();
165                     break;
166                 case 3:
167                     orderSex();
168                     break;
169                 case 4:
170                     orderId();
171                     break;
172                 case 5:
173                     orderCourse();
174                     break;
175                 case 6:
176                     showAll();
177                     break;
178                 case 7:
179                     return;
180                 }
181             }
182         }
183     }
184 
185     /**
186      * 添加学生信息
187      */
188     public void addOperation() {
189         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
190         String name = studentMangerRegex.nameRegex();
191         String age = studentMangerRegex.ageRegex();
192         String sex = studentMangerRegex.sexRegex();
193         String telNum = studentMangerRegex.telNumRegex();
194         String address = studentMangerRegex.addressRegex();
195         double course = studentMangerRegex.courseRegex();
196         Student student = new Student(name, age, sex, telNum, address, course);
197         boolean tag = vector.add(student);
198         if (tag) {
199             id++;
200             System.out.println("添加学生成功!请继续操作!!");
201         } else {
202             System.out.println("添加学生失败!");
203         }
204     }
205 
206     /**
207      * 查询全部学生信息
208      */
209     public void showAll() {
210         int i = 0;
211         for (Student student : vector) {
212             System.out.println("序号  " + (i + 1) + student.toString());
213             i++;
214         }
215         if (i == 0) {
216             System.out.println("没有任何记录");
217         }
218     }
219 
220     /**
221      * 按照姓名查询学生信息
222      */
223     public void searchByName() {
224         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
225         String name = studentMangerRegex.nameRegex();
226         int i = 0;
227         for (Student student : vector) {
228             if (name.equals(student.getName())) {
229                 System.out.println("序号  " + (i + 1) + student.toString());
230                 i++;
231             }
232         }
233         if (i == 0) {
234             System.out.println("没有此人记录");
235         }
236     }
237 
238     /**
239      * 按照年龄查询学生信息
240      */
241     public void searchByAge() {
242         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
243         String age = studentMangerRegex.ageRegex();
244         int i = 0;
245         for (Student student : vector) {
246             if (age.equals(student.getAge())) {
247                 System.out.println("序号  " + (i + 1) + student.toString());
248                 i++;
249             }
250         }
251         if (i == 0) {
252             System.out.println("没有此人记录");
253         }
254     }
255 
256     /**
257      * 按照性别查询学生信息
258      */
259     public void searchBySex() {
260         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
261         String sex = studentMangerRegex.sexRegex();
262         int i = 0;
263         for (Student student : vector) {
264             if (sex.equals(student.getSex())) {
265                 System.out.println("序号  " + (i + 1) + student.toString());
266                 i++;
267             }
268         }
269         if (i == 0) {
270             System.out.println("没有此人记录");
271         }
272     }
273 
274     /**
275      * 按照电话号码查询学生信息
276      */
277     public void searchByTelNum() {
278         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
279         String telNum = studentMangerRegex.telNumRegex();
280         int i = 0;
281         for (Student student : vector) {
282             if (telNum.equals(student.getTelNum())) {
283                 System.out.println("序号  " + (i + 1) + student.toString());
284                 i++;
285             }
286         }
287         if (i == 0) {
288             System.out.println("没有此人记录");
289         }
290     }
291 
292     /**
293      * 按照地址查询学生信息
294      */
295     public void searchByAdd() {
296         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
297         String address = studentMangerRegex.addressRegex();
298         int i = 0;
299         for (Student student : vector) {
300             if (address.equals(student.getAddress())) {
301                 System.out.println("序号  " + (i + 1) + student.toString());
302                 i++;
303             }
304         }
305         if (i == 0) {
306             System.out.println("没有此人记录");
307         }
308     }
309 
310     /**
311      * 按照成绩查询学生信息
312      */
313     public void searchByCourse() {
314         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
315         double course = studentMangerRegex.courseRegex();
316         int i = 0;
317         for (Student student : vector) {
318             if (course == student.getCourse()) {
319                 System.out.println("序号  " + (i + 1) + student.toString());
320                 i++;
321             }
322         }
323         if (i == 0) {
324             System.out.println("没有此人记录");
325         }
326     }
327 
328     /**
329      * 修改指定记录信息
330      */
331     public void modify() {
332         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
333         int size = vector.size();
334         if (size == 0) {
335             System.out.println("学生管理系统没有信息,请先添加信息后再操作!");
336         } else {
337             System.out.println("请输入记录序号");
338             int num = studentMangerRegex.menuRegex(1, size);
339             while (true) {
340                 Menu.getInstance().subModifyMenu();
341                 int key = studentMangerRegex.menuRegex(1, 7);
342                 switch (key) {
343                 case 1:
344                     String name = studentMangerRegex.nameRegex();
345                     vector.get(num - 1).setName(name);
346                     System.out.println("修改成功!请继续操作!!");
347                     break;
348                 case 2:
349                     String age = studentMangerRegex.ageRegex();
350                     vector.get(num - 1).setAge(age);
351                     System.out.println("修改成功!请继续操作!!");
352                     break;
353                 case 3:
354                     String sex = studentMangerRegex.sexRegex();
355                     vector.get(num - 1).setSex(sex);
356                     System.out.println("修改成功!请继续操作!!");
357                     break;
358                 case 4:
359                     String telNum = studentMangerRegex.telNumRegex();
360                     vector.get(num - 1).setTelNum(telNum);
361                     System.out.println("修改成功!请继续操作!!");
362                     break;
363                 case 5:
364                     String address = studentMangerRegex.addressRegex();
365                     vector.get(num - 1).setAddress(address);
366                     System.out.println("修改成功!请继续操作!!");
367                     break;
368                 case 6:
369                     double course = studentMangerRegex.courseRegex();
370                     vector.get(num - 1).setCourse(course);
371                     System.out.println("修改成功!请继续操作!!");
372                     break;
373                 case 7:
374                     return;
375                 }
376             }
377         }
378     }
379 
380     /**
381      * 删除指定学生记录
382      */
383     public void delete() {
384         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
385         if (vector.size() == 0) {
386             System.out.println("学生管理系统内容已清空,请继续操作!");
387         } else {
388             System.out.println("请输入记录序号");
389             int num = studentMangerRegex.menuRegex(1, vector.size());
390             vector.remove(num - 1);
391             System.out.println("删除成功!请继续操作!!");
392         }
393     }
394 
395     /**
396      * 删除全部学生记录
397      */
398     public void deleteAll() {
399         if (vector.size() == 0) {
400             System.out.println("学生管理系统内容已清空,请继续操作!");
401         } else {
402             boolean tag = vector.removeAll(vector);
403             if (tag) {
404                 System.out.println("学生管理系统内容已清空,请继续操作!");
405             }
406         }
407     }
408 
409     /**
410      * 按学生姓名排序信息
411      */
412     public void orderName() {
413         Collections.sort(vector, new OrderByName());
414         System.out.println("排序完成!");
415     }
416 
417     /**
418      * 按学生年龄排序信息
419      */
420     public void orderAge() {
421         Collections.sort(vector, new OrderByAge());
422         System.out.println("排序完成!");
423     }
424 
425     /**
426      * 按学生性别排序信息
427      */
428     public void orderSex() {
429         Collections.sort(vector, new OrderBySex());
430         System.out.println("排序完成!");
431     }
432 
433     /**
434      * 按学生成绩排序信息
435      */
436     public void orderCourse() {
437         Collections.sort(vector, new OrderByCourse());
438         System.out.println("排序完成!");
439     }
440 
441     /**
442      * 按学生原始位置排序信息
443      */
444     public void orderId() {
445         Collections.sort(vector, new OrderById());
446         System.out.println("排序完成!");
447     }
448 
449     /**
450      * 按学生姓名排序内部类
451      */
452     class OrderByName implements Comparator<Student> {
453         @Override
454         public int compare(Student p1, Student p2) {
455             return p1.getName().compareTo(p2.getName());
456         }
457     }
458 
459     /**
460      * 按学生年龄排序内部类
461      */
462     class OrderByAge implements Comparator<Student> {
463         @Override
464         public int compare(Student p1, Student p2) {
465             int age1 = Integer.parseInt(p1.getAge());
466             int age2 = Integer.parseInt(p2.getAge());
467             return age1 - age2;
468         }
469     }
470 
471     /**
472      * 按学生性别排序内部类
473      */
474     class OrderBySex implements Comparator<Student> {
475         @Override
476         public int compare(Student p1, Student p2) {
477             return p1.getSex().compareTo(p2.getSex());
478         }
479     }
480 
481     /**
482      * 按学生成绩排序内部类
483      */
484     class OrderByCourse implements Comparator<Student> {
485         @Override
486         public int compare(Student p1, Student p2) {
487             if (p1.getCourse() - p2.getCourse() > 0) {
488                 return -1;
489             } else if (p1.getCourse() - p2.getCourse() == 0) {
490                 return 0;
491             } else {
492                 return 1;
493             }
494         }
495     }
496 
497     /**
498      * 按学生原始顺序排序内部类
499      */
500     class OrderById implements Comparator<Student> {
501         @Override
502         public int compare(Student o1, Student o2) {
503             int id1 = o1.getId();
504             int id2 = o2.getId();
505             return id1 - id2;
506         }
507     }
508 }
Operate
 1 package com.bj.dxb;
 2 
 3 /**
 4  * 程序启动入口类
 5  * 
 6  * @author void
 7  * 
 8  */
 9 public class App {
10     public static void main(String[] args) {
11         System.out.println("****此版本版权归董学斌所有****");
12         App app = new App();
13         app.start();
14     }
15 
16     /**
17      * 主菜单控制
18      */
19     public void start() {
20         StudentMangerRegex studentMangerRegex = new StudentMangerRegex();
21         Operate operate = new Operate();
22         while (true) {
23             if (operate.login()) {
24                 while (true) {
25                     Menu.getInstance().mainMenu();
26                     int key = studentMangerRegex.menuRegex(1, 6);
27                     switch (key) {
28                     case 1:
29                         operate.addLogic();
30                         break;
31                     case 2:
32                         operate.searchLogic();
33                         break;
34                     case 3:
35                         operate.modifyLogicLogic();
36                         break;
37                     case 4:
38                         operate.deleteLogic();
39                         break;
40                     case 5:
41                         operate.orderLogic();
42                         break;
43                     case 6:
44                         System.exit(0);
45                         break;
46                     }
47                 }
48             }
49         }
50     }
51 }
App

通过本项目,希望可以对那些Java初学者了解面向对象编程起到一定的帮助……

posted @ 2015-09-02 11:09  独年荒岛  阅读(519)  评论(0编辑  收藏  举报