内部类（2） + 学生管理系统

ゝ一纸荒年。 2024-04-11 09:57 49阅读 0赞

## 内部类（2） + 学生管理系统 ##

### 一、内部类 ###

#### 1.接口内部类 ####

##### 1.需求：创建接口内部类的对象，调用方法 #####

##### 2.注意： #####

###### 1.接口内部类创建对象的方式与静态内部类创建对象的方式一致 ######

###### 2.接口内部类默认使用public static修饰 ######

public static void main(String[] args) {
        
    		
    		//创建接口内部类的对象
    		Inner inner = new Outter.Inner();
    		
    		//调用方法
    		inner.method();
    	}
    }

//接口
    public interface Outter {
        
    	
    	//默认是使用public static final修饰
    	int i = 100;
    	
    	//接口内部类
    	//默认是使用public static修饰
    	public class Inner{
        
    		
    		public void method(){
        
    			System.out.println("接口内部类的method方法");
    		}
    	}
    	
    }

#### 2.局部内部类 ####

##### 1.注意：局部内部类使用到外部类的局部变量时，该变量会变成常量(使用final修饰) #####

##### 需求：调用局部内部类中的方法 #####

##### 面试题：局部内部类使用到外部类的局部变量时，为什么该变量会变成常量 #####

> ##### 因为常量的生命周期更长，保障了外部类方法结束时，该常量还能正常使用 #####

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		Outter outter = new Outter();
    		Object obj = outter.outterMethod();
    		System.out.println(obj);
    	}
    }

//外部类
    public class Outter {
        
    
    	public Object outterMethod(){
        
    		int i = 100;
    		
    		class Inner{
        
    			@Override
    			public String toString() {
        
    				return "局部内部类：" + i;
    			}
    		}
    		//创建局部内部类的对象
    		Inner inner = new Inner();
    		return inner;
    	}
    }

#### 3.匿名内部类 ####

##### 1.注意 #####

###### 1.抽象类的子类只创建一次对象，就可以选择直接new抽象类 - 匿名内部类 ######

###### 2.接口的实现类只创建一次对象，就可以选择直接new接口 - 匿名内部类 ######

public class Test01 {
        
    
    	public static void main(String[] args) {
        
    		//创建匿名内部类对象
    		//底层实现步骤：
    		//1.底层创建匿名类，继承A类，重写A类中的method方法
    		//2.创建匿名子类的对象
    		//3.将子类对象(内存地址)赋值给父类引用 --- 多态
    		A a = new A(){
        
    		public void method(){
        
    			System.out.println("匿名内部类");
    		}
    		};
    		a.method();
    		
    		System.out.println("----------------");
    		//创建匿名内部类
    		//底层实现步骤：
    		//1.底层创建匿名类，实现I1接口中的method方法
    		//2.创建匿名实现类的对象
    		//3.将匿名实现类对象(内存地址)赋值给接口的引用 -- 多态
    		I1 i1 = new I1(){
        
    			public void method(){
        
    				System.out.println("匿名内部类");
    			}
    		};
    		i1.method();
    	}
    }

package com.qf.outter_inner_07;
    
    public interface I1 {
        
    	public void method();
    }

public abstract class A {
    	
    	public abstract void method();
    }

#### 4.总结 - 内部类的使用场景： ####

##### 1.如果B类对象只在A类中使用，并且B类对象用到了A类中所有的属性，就可以考虑将B类作为A类的成员内部类（常用） #####

##### 2.如果B类对象只在A类中使用，并且B类对象用到了A类中静态的属性，就可以考虑将B类作为A类的静态内部类（常用） #####

##### 3.如果B类对象只在I1接口中使用，就可以考虑将B类作为I1接口的接口内部类 #####

##### 4.如果B类对象只在A类method方法中使用，就可以考虑将B类作为A类method方法中的局部内部类 #####

##### 5.如果抽象类A的子类B只创建了一次，就考虑不编写B类，直接newA类 – 匿名内部类（常用） #####

##### 6.如果接口I1的实现类B只创建了一次，就考虑不编写B类，直接newI1接口 – 匿名内部类（常用） #####

### 二、学生管理系统 ###

#### 判断学生信息合法性的工具类 ####

##### 1.姓名只能是2~18个字符长度 #####

##### 2.性别只能是男或女 #####

##### 3.年龄只能是18~40 #####

##### 4.班级号只能是4个字符长度 #####

##### 5.学号只能是3个字符长度 #####

import com.qf.pojo.Student;
    public class StuInfoUtils {
        
    
    	public static boolean isStu(Student stu){
        
    		
    		String name = stu.getName();
    		char sex = stu.getSex();
    		int age = stu.getAge();
    		String classId = stu.getClassId();
    		String id = stu.getId();
    		
    		if(isName(name) && isSex(sex) && isAge(age) && isClassId(classId) && isId(id)){
        
    			return true;
    		}
    		
    		return false;
    	}
    	
    	public static boolean isName(String name){
        
    		//获取字符串中字符长度
    		int len = name.length();
    		if(len >= 2 && len <= 18){
        
    			return true;
    		}
    		return false;
    	}
    	
    	public static boolean isSex(char sex){
        
    		if(sex == '男' || sex == '女'){
        
    			return true;
    		}
    		return false;
    	}
    	
    	public static boolean isAge(int age){
        
    		if(age >= 18 && age <= 40){
        
    			return true;
    		}
    		return false;
    	}
    	
    	public static boolean isClassId(String classId){
        
    		if(classId.length() == 4){
        
    			return true;
    		}
    		return false;
    	}
    	
    	public static boolean isId(String id){
        
    		if(id.length() == 3){
        
    			return true;
    		}
    		return false;
    	}	
    }

import java.util.Arrays;
    import static com.qf.container.Code.*;
    import com.qf.container.StuTypeContainer;
    import com.qf.pojo.Student;
    import com.qf.sms.IStudentManagerSystem;
    import com.qf.util.StuInfoUtils;
    
    public class StudentManagerSystem implements IStudentManagerSystem{
        
    
    	//默认容量
    	private static final int DEFAULT_CAPACITY = 3;
    	//学生容器
    	private Student[] stus;
    	//元素个数/指针
    	private int size;
    
    	public StudentManagerSystem() {
        
    		stus = new Student[DEFAULT_CAPACITY];
    
    		add(new Student("大桥", '女', 22, "2211", "001"));
    		add(new Student("小乔", '女', 25, "2211", "002"));
    		add(new Student("孙尚香", '女', 19, "2211", "003"));
    		add(new Student("貂蝉", '女', 29, "2211", "004"));
    		add(new Student("芈月", '女', 21, "2211", "005"));
    		add(new Student("西施", '女', 20, "2211", "006"));
    		add(new Student("伽罗", '女', 19, "2211", "007"));
    		add(new Student("艾琳", '女', 18, "2211", "008"));
    		add(new Student("钟无艳", '女', 21, "2211", "009"));
    		add(new Student("亚瑟", '男', 25, "2211", "010"));
    
    		add(new Student("安吉拉", '女', 22, "2212", "001"));
    		add(new Student("瑶妹", '女', 24, "2212", "002"));
    		add(new Student("妲己", '女', 20, "2212", "003"));
    		add(new Student("王昭君", '女', 22, "2212", "004"));
    		add(new Student("赵飞燕", '女', 27, "2212", "005"));
    		add(new Student("虞姬", '女', 23, "2212", "006"));
    		add(new Student("杨贵妃", '女', 22, "2212", "007"));
    		add(new Student("凯哥", '男', 27, "2212", "008"));
    		add(new Student("后裔", '男', 24, "2212", "009"));
    
    	}
    
    	public StudentManagerSystem(int initCapacity){
        
    		if(initCapacity <= DEFAULT_CAPACITY){
        
    			stus = new Student[DEFAULT_CAPACITY];
    		}else{
        
    			stus = new Student[initCapacity];
    		}
    	}
    
    	@Override
    	public AddCode add(Student stu) {
        
    		//1.判断学生信息的合法性
    		if(!StuInfoUtils.isStu(stu)){
        
    			return AddCode.A_ERROR;
    		}
    
    		//2.判断是否有该学生
    		if(query(stu.getClassId(), stu.getId()) != null){
        
    			return AddCode.B_ERROR;
    		}
    
    		//3.判断是否扩容
    		if(size == stus.length){
        
    			expansion();
    		}
    
    		//4.添加学生
    		stus[size++] = stu;
    		return AddCode.OK;
    	}
    
    	@Override
    	public void expansion() {
        
    		int oldCapacity = stus.length;
    		int newCapacity = oldCapacity + (oldCapacity>>1);
    		stus = Arrays.copyOf(stus, newCapacity);
    	}
    
    	@Override
    	public DeleteCode delete(String classId, String id) {
        
    		//1.判断学生信息合法性
    		if(!StuInfoUtils.isClassId(classId) || !StuInfoUtils.isId(id)){
        
    			return DeleteCode.A_ERROR;
    		}
    
    		//2.判断是否有该学生
    		int index = queryToIndex(classId, id);
    		if(index == -1){
        
    			return DeleteCode.B_ERROR;
    		}
    
    		//3.删除学生
    		for (int i = index; i < size-1; i++) {
        
    			stus[i] = stus[i+1];
    		}
    		size--;
    		stus[size] = null;
    		return DeleteCode.OK;
    	}
    
    	//如果用户选择修改年龄 --> int类型的数据 --> Integer类型的数据 --> Object类型的数据
    	@Override
    	public UpdateCode update(String classId, String id, int type, Object val) {
        
    		//1.判断学生信息的合法性
    		if(!StuInfoUtils.isClassId(classId) || !StuInfoUtils.isId(id)){
        
    			return UpdateCode.A_ERROR;
    		}
    		//2.判断是否有该学生
    		int index = queryToIndex(classId, id);
    		if(index == -1){
        
    			return UpdateCode.B_ERROR;
    		}
    		//3.判断修改类型
    		switch (type) {
        
    		case StuTypeContainer.NAME:
    			return updateName(val, index);
    		case StuTypeContainer.SEX:
    			return updateSex(val, index);
    		case StuTypeContainer.AGE:
    			return updateAge(val, index);
    		case StuTypeContainer.CLASS_ID:
    			return updateClassId(id, val, index);
    		case StuTypeContainer.ID:
    			return updateId(classId, val, index);
    		default:
    			return UpdateCode.C_ERROR;
    		}
    	}
    
    	private UpdateCode updateId(String classId, Object val, int index) {
        
    		//判断修改数据的类型
    		if(val instanceof String){
        
    			String targetId = (String) val;
    			//判断修改数据的合法性
    			if(!StuInfoUtils.isId(targetId)){
        
    				return UpdateCode.E_ERROR;
    			}
    			//判断学号是否会重复
    			if(queryToIndex(classId, targetId) != -1){
        
    				return UpdateCode.G_ERROR;
    			}
    			//修改数据
    			stus[index].setId(targetId);
    			return UpdateCode.OK;
    		}else{
        
    			return UpdateCode.D_ERROR;
    		}
    	}
    
    	private UpdateCode updateClassId(String id, Object val, int index) {
        
    		//判断修改数据的类型
    		if(val instanceof String){
        
    			String targetClassId = (String) val;
    			//判断修改数据的合法性
    			if(!StuInfoUtils.isClassId(targetClassId)){
        
    				return UpdateCode.E_ERROR;
    			}
    			//判断目标班级上，学号是否会重复
    			if(queryToIndex(targetClassId, id) != -1){
        
    				return UpdateCode.F_ERROR;
    			}
    			//修改数据
    			stus[index].setClassId(targetClassId);
    			return UpdateCode.OK;
    		}else{
        
    			return UpdateCode.D_ERROR;
    		}
    	}
    
    	private UpdateCode updateName(Object val, int index) {
        
    		//判断修改数据的类型
    		if(val instanceof String){
        
    			String name = (String) val;
    			//判断修改数据的合法性
    			if(!StuInfoUtils.isName(name)){
        
    				return UpdateCode.E_ERROR;
    			}
    			//修改数据
    			stus[index].setName(name);
    			return UpdateCode.OK;
    		}else{
        
    			return UpdateCode.D_ERROR;
    		}
    	}
    	
    	private UpdateCode updateSex(Object val, int index) {
        
    		//判断修改数据的类型
    		if(val instanceof Character){
        
    			char sex = (Character) val;
    			//判断修改数据的合法性
    			if(!StuInfoUtils.isSex(sex)){
        
    				return UpdateCode.E_ERROR;
    			}
    			//修改数据
    			stus[index].setSex(sex);
    			return UpdateCode.OK;
    		}else{
        
    			return UpdateCode.D_ERROR;
    		}
    	}
    	
    	private UpdateCode updateAge(Object val, int index) {
        
    		//判断修改数据的类型
    		if(val instanceof Integer){
        
    			int age = (Integer) val;
    			//判断修改数据的合法性
    			if(!StuInfoUtils.isAge(age)){
        
    				return UpdateCode.E_ERROR;
    			}
    			//修改数据
    			stus[index].setAge(age);
    			return UpdateCode.OK;
    		}else{
        
    			return UpdateCode.D_ERROR;
    		}
    	}
    
    	@Override
    	public int queryToIndex(String classId, String id) {
        
    		//创建临时学生对象 -- 该对象中只包含班级号和学号
    		Student stu = new Student(classId, id);
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].equals(stu)){
        
    				return i;
    			}
    		}
    		return -1;
    	}
    
    	@Override
    	public Student query(String classId, String id) {
        
    		//创建临时学生对象 -- 该对象中只包含班级号和学号
    		Student stu = new Student(classId, id);
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].equals(stu)){
        
    				return stus[i];
    			}
    		}
    		return null;
    	}
    
    	@Override
    	public Student[] queryByName(String name) {
        
    		//1.判断学生信息合法性
    		if(!StuInfoUtils.isName(name)){
        
    			return null;
    		}
    		//2.判断符合条件的学生个数
    		int count = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getName().equals(name)){
        
    				count++;
    			}
    		}
    		if(count == 0){
        
    			return null;
    		}
    		//3.创建新数组
    		Student[] newStus = new Student[count];
    		//4.将符合条件的学生对象装载到新数组中
    		int index = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getName().equals(name)){
        
    				newStus[index++] = stus[i];
    			}
    		}
    		return newStus;
    	}
    
    	@Override
    	public Student[] queryBySex(char sex) {
        
    		//1.判断学生信息合法性
    		if(!StuInfoUtils.isSex(sex)){
        
    			return null;
    		}
    		//2.判断符合条件的学生个数
    		int count = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getSex() == sex){
        
    				count++;
    			}
    		}
    		if(count == 0){
        
    			return null;
    		}
    		//3.创建新数组
    		Student[] newStus = new Student[count];
    		//4.将符合条件的学生对象装载到新数组中
    		int index = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getSex() == sex){
        
    				newStus[index++] = stus[i];
    			}
    		}
    		return newStus;
    	}
    
    	@Override
    	public Student[] queryByAge(int startAge, int endAge) {
        
    		//1.判断学生信息合法性
    		if(!StuInfoUtils.isAge(startAge) || !StuInfoUtils.isAge(endAge)){
        
    			return null;
    		}
    		//2.判断符合条件的学生个数
    		int count = 0;
    		for (int i = 0; i < size; i++) {
        
    			int age = stus[i].getAge();
    			if(age >= startAge && age <= endAge){
        
    				count++;
    			}
    		}
    		if(count == 0){
        
    			return null;
    		}
    		//3.创建新数组
    		Student[] newStus = new Student[count];
    		//4.将符合条件的学生对象装载到新数组中
    		int index = 0;
    		for (int i = 0; i < size; i++) {
        
    			int age = stus[i].getAge();
    			if(age >= startAge && age <= endAge){
        
    				newStus[index++] = stus[i];
    			}
    		}
    		return newStus;
    	}
    
    	@Override
    	public Student[] queryByClassId(String classId) {
        
    		//1.判断学生信息合法性
    		if(!StuInfoUtils.isClassId(classId)){
        
    			return null;
    		}
    		//2.判断符合条件的学生个数
    		int count = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getClassId().equals(classId)){
        
    				count++;
    			}
    		}
    		if(count == 0){
        
    			return null;
    		}
    		//3.创建新数组
    		Student[] newStus = new Student[count];
    		//4.将符合条件的学生对象装载到新数组中
    		int index = 0;
    		for (int i = 0; i < size; i++) {
        
    			if(stus[i].getClassId().equals(classId)){
        
    				newStus[index++] = stus[i];
    			}
    		}
    		return newStus;
    	}
    
    	@Override
    	public void printStu() {
        
    		for (int i = 0; i < size; i++) {
        
    			System.out.println(stus[i]);
    		}
    	}
    }

import java.util.Scanner;
    import com.qf.container.Code.UpdateCode;
    import com.qf.container.Code.AddCode;
    import com.qf.container.Code.DeleteCode;
    import com.qf.pojo.Student;
    import com.qf.sms.impl.StudentManagerSystem;
    
    public class Test {
        
    
    	public static void main(String[] args) {
        
    
    		Scanner scan = new Scanner(System.in);
    
    		StudentManagerSystem sms = new StudentManagerSystem();
    
    		System.out.println("欢迎进入学生管理系统...");
    		boolean flag = true;
    		while(flag){
        
    			System.out.println("请选择以下功能：");
    			System.out.println("1-添加学生");
    			System.out.println("2-删除学生");
    			System.out.println("3-修改学生");
    			System.out.println("4-查询学生");
    			System.out.println("5-打印学生");
    			System.out.println("886-退出");
    			int num = scan.nextInt();
    			switch (num) {
        
    			case 1:
    				addMenu(scan, sms);
    				break;
    			case 2:
    				deleteMenu(scan, sms);
    				break;
    			case 3:
    				updateMenu(scan, sms);
    				break;
    			case 4:
    				queryMenu(scan, sms);
    				break;
    			case 5:
    				sms.printStu();
    				break;
    			case 886:
    				flag = false;
    				System.out.println("正在退出学生管理系统，欢迎下次再来...");
    				break;
    			default:
    				System.out.println("输入错误...");
    				break;
    			}
    			System.out.println("----------------------");
    		}
    
    		scan.close();
    	}
    
    	private static void updateMenu(Scanner scan, StudentManagerSystem sms) {
        
    		System.out.println("请输入班级号：");
    		String classId = scan.next();
    		System.out.println("请输入学号：");
    		String id = scan.next();
    		System.out.println("请选择修改类型：");
    		System.out.println("1 - 修改姓名");
    		System.out.println("2 - 修改性别");
    		System.out.println("3 - 修改年龄");
    		System.out.println("4 - 修改班级号");
    		System.out.println("5 - 修改学号");
    		int type = scan.nextInt();
    		System.out.println("请输入要修改的数据：");
    		UpdateCode update = null;
    		switch (type) {
        
    		case 1:case 4:case 5:
    			String str = scan.next();
    			update = sms.update(classId, id, type, str);
    			break;
    		case 2:
    			char sex = scan.next().toCharArray()[0];
    			update = sms.update(classId, id, type, sex);
    			break;
    		case 3:
    			int age = scan.nextInt();
    			update = sms.update(classId, id, type, age);
    			break;
    		default:
    			System.out.println("修改错误 -- 修改类型错误");
    			break;
    			
    		}
    		System.out.println(update);
    	}
    
    	private static void queryMenu(Scanner scan, StudentManagerSystem sms) {
        
    
    		System.out.println("选择查询条件：");
    		System.out.println("1-通过班级号和学号查询");
    		System.out.println("2-通过姓名");
    		System.out.println("3-通过性别");
    		System.out.println("4-通过年龄段");
    		System.out.println("5-通过班级号");
    		int num = scan.nextInt();
    
    		Student[] stus = null;
    		switch (num) {
        
    		case 1:
    			System.out.println("请输入班级号和学号：");
    			Student student = sms.query(scan.next(), scan.next());
    			System.out.println(student);
    			break;
    		case 2:
    			System.out.println("请输入姓名：");
    			stus = sms.queryByName(scan.next());
    			break;
    		case 3:
    			System.out.println("请输入性别：");
    			stus = sms.queryBySex(scan.next().toCharArray()[0]);
    			break;
    		case 4:
    			System.out.println("请输入年龄段：");
    			stus = sms.queryByAge(scan.nextInt(), scan.nextInt());
    			break;
    		case 5:
    			System.out.println("请输入班级号：");
    			stus = sms.queryByClassId(scan.next());
    			break;
    		default:
    			System.out.println("输入有误...");
    			break;
    		}
    		
    		if(stus != null){
        
    			sms.printStu(stus);
    		}
    	}
    
    	private static void deleteMenu(Scanner scan, StudentManagerSystem sms) {
        
    		System.out.println("请输入要添加的学生班级号：");
    		String classId = scan.next();
    		System.out.println("请输入要添加的学生学号：");
    		String id = scan.next();
    
    		DeleteCode delete = sms.delete(classId, id);
    		System.out.println(delete);
    	}
    
    	//添加功能的菜单
    	private static void addMenu(Scanner scan, StudentManagerSystem sms) {
        
    		System.out.println("请输入要添加的学生姓名：");
    		String name = scan.next();
    		System.out.println("请输入要添加的学生性别：");
    		char sex = scan.next().toCharArray()[0];//"男"->['男']->'男'
    		System.out.println("请输入要添加的学生年龄：");
    		int age = scan.nextInt();
    		System.out.println("请输入要添加的学生班级号：");
    		String classId = scan.next();
    		System.out.println("请输入要添加的学生学号：");
    		String id = scan.next();
    
    		AddCode add = sms.add(new Student(name, sex, age, classId, id));
    		System.out.println(add);
    	}
    }
    	public static void main(String[] args) {
        
    
    		Scanner scan = new Scanner(System.in);
    
    		StudentManagerSystem sms = new StudentManagerSystem();
    
    		System.out.println("欢迎进入学生管理系统...");
    		boolean flag = true;
    		while(flag){
        
    			System.out.println("请选择以下功能：");
    			System.out.println("1-添加学生");
    			System.out.println("2-删除学生");
    			System.out.println("3-修改学生");
    			System.out.println("4-查询学生");
    			System.out.println("5-打印学生");
    			System.out.println("886-退出");
    			int num = scan.nextInt();
    			switch (num) {
        
    			case 1:
    				addMenu(scan, sms);
    				break;
    			case 2:
    				deleteMenu(scan, sms);
    				break;
    			case 3:
    
    				break;
    			case 4:
    				queryMenu(scan, sms);
    				break;
    			case 5:
    				sms.printStu();
    				break;
    			case 886:
    				flag = false;
    				System.out.println("正在退出学生管理系统，欢迎下次再来...");
    				break;
    			default:
    				System.out.println("输入错误...");
    				break;
    			}
    			System.out.println("----------------------");
    		}
    
    		scan.close();
    	}
    
    	private static void queryMenu(Scanner scan, StudentManagerSystem sms) {
        
    
    		System.out.println("选择查询条件：");
    		System.out.println("1-通过班级号和学号查询");
    		System.out.println("2-通过姓名");
    		System.out.println("3-通过性别");
    		System.out.println("4-通过年龄段");
    		System.out.println("5-通过班级号");
    		int num = scan.nextInt();
    
    		Student[] stus = null;
    		switch (num) {
        
    		case 1:
    			System.out.println("请输入班级号和学号：");
    			Student student = sms.query(scan.next(), scan.next());
    			System.out.println(student);
    			break;
    		case 2:
    			System.out.println("请输入姓名：");
    			stus = sms.queryByName(scan.next());
    			break;
    		case 3:
    			System.out.println("请输入性别：");
    			stus = sms.queryBySex(scan.next().toCharArray()[0]);
    			break;
    		case 4:
    			System.out.println("请输入年龄段：");
    			stus = sms.queryByAge(scan.nextInt(), scan.nextInt());
    			break;
    		case 5:
    			System.out.println("请输入班级号：");
    			stus = sms.queryByClassId(scan.next());
    			break;
    		default:
    			System.out.println("输入有误...");
    			break;
    		}
    		
    		if(stus != null){
        
    			sms.printStu(stus);
    		}
    	}
    
    	private static void deleteMenu(Scanner scan, StudentManagerSystem sms) {
        
    		System.out.println("请输入要添加的学生班级号：");
    		String classId = scan.next();
    		System.out.println("请输入要添加的学生学号：");
    		String id = scan.next();
    
    		int delete = sms.delete(classId, id);
    		if(delete == -1){
        
    			System.out.println("删除失败 -- 学生信息不合法");
    		}else if(delete == -2){
        
    			System.out.println("删除失败 -- 没有该学生");
    		}else if(delete == 1){
        
    			System.out.println("删除成功");
    		}
    	}
    
    	//添加功能的菜单
    	private static void addMenu(Scanner scan, StudentManagerSystem sms) {
        
    		System.out.println("请输入要添加的学生姓名：");
    		String name = scan.next();
    		System.out.println("请输入要添加的学生性别：");
    		char sex = scan.next().toCharArray()[0];//"男"->['男']->'男'
    		System.out.println("请输入要添加的学生年龄：");
    		int age = scan.nextInt();
    		System.out.println("请输入要添加的学生班级号：");
    		String classId = scan.next();
    		System.out.println("请输入要添加的学生学号：");
    		String id = scan.next();
    
    		int add = sms.add(new Student(name, sex, age, classId, id));
    		if(add == -1){
        
    			System.out.println("添加失败 -- 学生信息不合法");
    		}else if(add == -2){
        
    			System.out.println("添加失败 -- 学生已存在");
    		}else if(add == 1){
        
    			System.out.println("添加成功");
    		}
    	}
    }

import com.qf.container.Code;
    import com.qf.pojo.Student;
    
    public interface IStudentManagerSystem {
        
    
    	/**
    	 * 添加学生
    	 * @param stu 目标学生
    	 * @return 状态码
    	 */
    	public Code.AddCode add(Student stu);
    	
    	/**
    	 * 扩容
    	 */
    	public void expansion();
    	
    	/**
    	 * 删除学生
    	 * @param classId 班级号
    	 * @param id 学号
    	 * @return 状态码
    	 */
    	public Code.DeleteCode delete(String classId,String id);
    	
    	/**
    	 * 修改学生
    	 * @param classId 班级号
    	 * @param id 学号
    	 * @param type 修改类型：1-姓名 2-性别 3-年龄 4-班级号 5-学号
    	 * @param val 修改的值
    	 * @return 状态码
    	 */
    	public Code.UpdateCode update(String classId,String id,int type,Object val);
    
    	/**
    	 * 获取学生在容器中的下标
    	 * @param classId 班级号
    	 * @param id 学号
    	 * @return 在容器内的下标，如果没有该学生则返回-1
    	 */
    	public int queryToIndex(String classId,String id);
    	
    	/**
    	 * 根据班级号+学号查询出学生对象
    	 * @param classId 班级号
    	 * @param id 学号
    	 * @return 学生对象，如果没有该学生则返回null
    	 */
    	public Student query(String classId,String id);
    	
    	/**
    	 * 根据姓名查询出学生数组
    	 * @param name 姓名
    	 * @return 学生数组
    	 */
    	public Student[] queryByName(String name);
    	
    	/**
    	 * 根据性别查询出学生数组
    	 * @param sex 姓名
    	 * @return 学生数组
    	 */
    	public Student[] queryBySex(char sex);
    	
    	/**
    	 * 根据年龄段查询出学生数组
    	 * @param startAge 开始年龄(包含)
    	 * @param endAge 结束年龄(包含)
    	 * @return 学生数组
    	 */
    	public Student[] queryByAge(int startAge,int endAge);
    	
    	/**
    	 * 根据班级查询出学生数组
    	 * @param classId 班级号
    	 * @return 学生数组
    	 */
    	public Student[] queryByClassId(String classId);
    	
    	/**
    	 * 打印容器中所有的学生
    	 */
    	public void printStu();
    	
    	/**
    	 * 打印学生数组
    	 * @param stus 学生数组
    	 */
    	default void printStu(Student[] stus){
        
    		for (Student stu : stus) {
        
    			System.out.println(stu);
    		}
    	}
    }

public class Student {
        
    	
    	private String name;
    	private char sex;
    	private int age;
    	private String classId;
    	private String id;
    	
    	public Student() {
        
    	}
    	
    	public Student(String classId, String id) {
        
    		this.classId = classId;
    		this.id = id;
    	}
    
    	public Student(String name, char sex, int age, String classId, String id) {
        
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    		this.classId = classId;
    		this.id = id;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	public char getSex() {
        
    		return sex;
    	}
    
    	public void setSex(char sex) {
        
    		this.sex = sex;
    	}
    
    	public int getAge() {
        
    		return age;
    	}
    
    	public void setAge(int age) {
        
    		this.age = age;
    	}
    
    	public String getClassId() {
        
    		return classId;
    	}
    
    	public void setClassId(String classId) {
        
    		this.classId = classId;
    	}
    
    	public String getId() {
        
    		return id;
    	}
    
    	public void setId(String id) {
        
    		this.id = id;
    	}
    	
    	//判断两个学生是否相同（班级号 + 学号）
    	@Override
    	public boolean equals(Object obj) {
        
    		if(this == obj){
        
    			return true;
    		}
    		
    		if(obj instanceof Student){
        
    			Student stu = (Student) obj;
    			if(classId.equals(stu.classId) && id.equals(stu.id)){
        
    				return true;
    			}
    		}
    		
    		return false;
    	}
    
    	@Override
    	public String toString() {
        
    		return name + "\t" + sex + "\t" + age + "\t" + classId + "\t" + id;
    	}
    }

//接口的属性全是静态的
    public interface StuTypeContainer {
        
    
    	int NAME = 1;
    	int SEX = 2;
    	int AGE = 3;
    	int CLASS_ID = 4;
    	int ID = 5;
    }

//组织枚举
    public interface Code {
        
    	
    	enum AddCode {
        
    		
    		A_ERROR(-1,"添加失败 - 学生信息不合法"),
    		B_ERROR(-2,"添加失败 - 已有该学生"),
    		OK(1,"添加成功");
    		
    		private int code;
    		private String message;
    		
    		private AddCode() {
        
    		}
    
    		private AddCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    
    	enum DeleteCode {
        
    		
    		A_ERROR(-1,"删除失败 - 学生信息不合法"),
    		B_ERROR(-2,"删除失败 - 没有该学生"),
    		OK(1,"删除成功");
    		
    		private int code;
    		private String message;
    		
    		private DeleteCode() {
        
    		}
    
    		private DeleteCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    
    	enum UpdateCode {
        
    		
    		A_ERROR(-1,"修改失败 -- 学生信息不合法"),
    		B_ERROR(-2,"修改失败 - 没有该学生"),
    		C_ERROR(-3,"修改失败 - 修改类型错误"),
    		D_ERROR(-4,"修改失败 - 修改类型转换异常"),
    		E_ERROR(-5,"修改失败 - 修改类型不合法"),
    		F_ERROR(-6,"修改失败 - 目标班级上有学生"),
    		G_ERROR(-7,"修改失败 - 目标学号上有学生"),
    		OK(1,"修改成功");
    		
    		private int code;
    		private String message;
    		
    		private UpdateCode() {
        
    		}
    
    		private UpdateCode(int code, String message) {
        
    			this.code = code;
    			this.message = message;
    		}
    
    		public int getCode() {
        
    			return code;
    		}
    
    		public void setCode(int code) {
        
    			this.code = code;
    		}
    
    		public String getMessage() {
        
    			return message;
    		}
    
    		public void setMessage(String message) {
        
    			this.message = message;
    		}
    		
    		@Override
    		public String toString() {
        
    			return code + " -- " + message;
    		}
    	}
    }