实验二 Java类编程练习（汽院含答案）

实验二 Java类编程练习

实验目的

1． 掌握类及类的声明 2． 掌握对象的定义和使用 3． 掌握接口的定义与实现

实验导读

继承、封装和多态是Java面向对象的3大特性，它们是面向对象程序开发的重要环节。

继承机制的使用可以复用一些定义好的类，减少重复代码的编写。多态机制可以动态调整对象的调用，降低对象之间的依存关系。同时为了优化继承与多态，一些类除了继承父类还可以使用接口的形式，Java中的类可以同时实现多个接口，接口被用来建立类与类之间关联的标准。

1． 类的继承(extends)

继承可以理解为现实世界中的“是一种(is-a)”关系，实现继承是通过extends关键字在声明类的时候指定其父类，其声明格式如下：

[修饰符] class 类名 extends 父类名 继承某个父类而生成新的子类不但拥有父类的变量与方法，还可以为子类添加新的成员变量和成员方法，以增强父类的功能，也就是所谓的扩展。还可以使用super关键字引用父类的方法，然后再添加新的业务代码。甚至还可以在子类中为父类的某个方法定义多个重载方法，增加该类的灵活性。

2． 访问修饰符

Java中定义了private、public、protected和默认的访问修饰符，这些修饰符控制着对类和类的成员变量以及成员方法的访问规则。另外，还可以辅助static和final关键字定义特殊规则。

访问包位置 修饰符 本类 同包其他类 其他包的类 同包的子类 其他包的子类 Private 可见 不可见 不可见 不可见 不可见 类修饰符 protected 默认修饰符 可见 可见 不可见 可见 可见 可见 可见 不可见 可见 不可见 Public 可见 可见 可见 可见 可见 public是公有类型的权限修饰符，使用public修饰的类、成员变量和成员方法，其他类都可以访问，包括任意包中的任意类以及子类。

private是私有类型的权限修饰符，使用private修饰的成员变量和成员方法，只能在本类中被使用，在子类中是不可见的，并且对其他包的类也是不可见的。

protected是保护级别的权限修饰符，它保护成员不会被其他包或非子类访问。也就是说protected修饰的成员只能被子类和同一包中定义的其他类访问。

当不添加任何权限修饰符时，编译器会使用默认权限修饰符，该修饰符的权限级别

与protected类似，不同之处在于，其他包定义的子类无法访问父类默认权限修饰的成员。

3． 封装(encapsulation)

封装是指把对象的属性隐藏在对象的内部，不允许外部直接访问和修改。Java规范中的设置器和 访问器就是实现封装的标准方法，它们用于设置和获取对象的属性值。

设置器方法的命名一般以set作为方法名的前缀，以属性名作为后缀。

访问器方法的命名一般以get或is作为方法名称的前缀，以属性名作为后缀。对于boolean类型的属性，应该使用is前缀定义访问器 方法。例如：

public class Car {

private String color; private boolean running; public String getColor() { return color; }

public void setColor(String color) { this.color = color; }

public boolean isRunning() { return running; }

public void setRunning(boolean running) { this.running = running; } } 4． Object类

在Java中，所有的类都直接或间接继承了java.lang.Object类，它是所有类的父类。Object类中常用的两个方法为equals()和toString()方法。任何类都可以重写Object类中的方法。

5． 对象的上转型对象

假设B类是A类的子类或间接子类，当我们用子类B创建一个对象，并把这个对象的引用放到A类的对象中时：A a = new B(); 称这个A类对象a是子类对象b的上转型对象。

? 上转对象不能操作子类新增的成员变量（失掉了这部分属性）；不能使用子类新增

的方法（失掉了一些功能）。

? 上转型对象可以操作子类继承或隐藏成员变量，也可以使用子类继承的或重写的方

法。

? 上转型对象操作子类继承或重写的方法时，就是通知对应的子类对象去调用这些方

法。因此，如果子类重写了父类的某个方法后，对象的上转型对象调用这个方法时，一定是调用了这个重写的方法。

? 可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了

子类所有属性和功能。

6． 多态(polymophism)

多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。 当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。那么当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，那么这个上转的对象在调用这个方法时就可能具有多种形态。多态性的实现：通过方法的重载(overloading)、覆盖(overriding)和接口来实现。

? 方法重载是Java实现面向对象的多态性机制的一种方式。同一个类中多个方法有

相同的名字，不同的参数列表，这种情况称为方法重载。返回类型不同并不足以构成方法重载。当重载方法被调用时，编译器根据参数的类型和数量来确定实际调用哪个重载方法的版本。

? 方法覆盖是Java实现多态性机制的另一种方式。在类层次结构中，如果子类中的

一个方法与父类中的方法有相同的方法名并具有相同数量和类型的参数列表，这种情况称为方法覆盖。当一个覆盖方法通过父类引用被调用，Java根据当前被引用对象的类型来决定执行哪个版本的方法。可以通过super关键字调用直属父类中被覆盖的方法版本。

参考代码：附录一 Java Code之多态。 7． 接口

接口是特殊的类，只有方法的原型，方法的实现在其子类中具体定义。Java不支持多继承性，即一个类只能有一个父类。单继承性使得Java简单，易于管理程序。为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。

一个类通过使用关键字implements 声明自己使用一个或多个接口。如果使用多个接口，用逗号隔开接口名。如：

class A implements Printable,Addable 如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体。接口只关心功能，并不关心功能的具体实现。

接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。那么该接口变量就可以调用被类实现的接口中的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法。

参考代码：附录四 和接口有关的匿名类 8． 内部类

Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。 内部类的外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

参考代码：附录二 内部类的用法 9． 匿名类

? 和类有关的匿名类

当使用类创建对象时，程序允许我们把类体与对象的创建组合在一起，也就是说，类创建对象时，除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体，称作匿名类。匿名类就是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。

匿名类一定是内部类，匿名类可以继承父类的方法也可以重写父类的方法，匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以声明static成员变量和static方法。匿名类的主要用途就是向方法的参数传值。

参考代码：附录三 和类有关的匿名类 ? 和接口有关的匿名类

Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了接口的类去掉类声明后的类体，称作匿名类。

参考代码：附录四 和接口有关的匿名类

实验内容

1. 对象的创建和使用

编写一个圆环类Ring的Java程序。圆环类有3个数据成员，分别是内半径innerRadius，外半径outerRadius和颜色color，这些属性通过get和set方法进行封装。另外，圆环类中的getArea方法可以返回其面积。把程序中的代码补充完整，并查看结果。

public class Ring {

private double innerRadius; private double outerRadius; public String color;

public Ring(double iRadius, double oRadius, String c) {

//初始化数据成员 【补充代码…】 }

//用get和set方法封装数据成员 【补充代码…】

public double getArea() {

【补充代码…】 }

public static void main(String[] args) { Ring ring = new Ring(5,8,\

System.out.println(\圆环的内半径: \+ ring.getInnerRadius( ));

System.out.println(\圆环的外半径: \+ ring.getOuterRadius( ));

System.out.println(\圆环的颜色: \

System.out.println(\圆环的面积: \

ring.setInnerRadius(4);

【补充代码】 //设置圆环ring的外半径为6 ring.setColor(\

System.out.println(\圆环的内半径: \+ ring.getInnerRadius( ));

System.out.println(\圆环的外半径: \+ ring.getOuterRadius( ));

System.out.println(\圆环的颜色: \

System.out.println(\圆环的面积: \ } } 思考：

1) 将程序中的语句Ring ring = new Ring(5,8,\改成Ring ring = new

Ring();修改后编译运行，此时有错误发生吗？分析错误的原因。

2) 接着为程序添加一个如下所示的默认构造函数，观察程序运行是否还有上述错误发生？

public Ring() {

innerRadius = 1.0; outerRadius = 2.0; color = \ }

3) 如果在输出圆环的面积时要求保留两位小数，程序如何修改？

4) 请为圆环类Ring在添两个方法以便能返回内圆和外圆的周长，然后在主函数

main（）中分别创建两个对象ring1，ring2以显示周长。

//答案： public class Ring{ private double innerRadius; private double outerRadius; public String color; public Ring(double iRadius, double oRadius, String c) { innerRadius = iRadius; outerRadius =oRadius; //初始化外半径 color = c; } public double getInnerRadius( ) { return innerRadius; //返回内半径 } public double getOuterRadius( ) { return outerRadius; //返回外半径 } public void setInnerRadius(double iRadius) { innerRadius = iRadius; }

public void setOuterRadius(double oRadius) { outerRadius = oRadius; } public void setColor(String c) { color=c;//设置颜色 } public double getArea() { return (outerRadius * outerRadius - innerRadius * innerRadius) * 3.1415; } public static void main(String[] args) { Ring ring = new Ring(5,8,\); System.out.println(\圆环的内半径: \ + ring.getInnerRadius( )); System.out.println(\圆环的外半径: \ + ring.getOuterRadius( )); System.out.println(\圆环的颜色: \ + ring.color); System.out.println(\圆环的面积: \ + ring.getArea() + \); ring.setInnerRadius(4); ring.setOuterRadius(6); //设置圆环ring的外半径为6 ring.setColor(\); System.out.println(\圆环的内半径: \ + ring.getInnerRadius( )); System.out.println(\圆环的外半径: \ + ring.getOuterRadius( )); System.out.println(\圆环的颜色: \ + ring.color); System.out.println(\圆环的面积: \ + ring.getArea()); } }

2. 使用类来封装对象的属性和功能

编写一个Java程序，该程序中有3个类：Trangle、Lader和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。具体要求如下：

Trangle类具有类型为double的三个边(sideA,sideB,sideC)，以及周长(length)、面积(area)属性，Trangle类具有返回周长(getLength)、面积(getArea)以及修改三个边(setABC)的功能。另外还有一个boolean型的属性(boo)，该属性用来判断三个数是否构成一个三角形。

Lader类具有类型为double的上底(above)、下底(bottom)、高(height)、面积(area)属性，具有返回面积(getArea)的功能。

Circle类具有类型为double的半径(radius)、周长(length)和面积(area)属性，具有返回周长(getLength)、面积(getArea)的功能。

把程序中的代码补充完整，并查看结果。 // Trangle .java class Trangle {

double sideA,sideB,sideC,area,length; boolean boo;

public Trangle(double a,double b,double c) {

//带参数的构造方法 setABC(a,b,c); }

double getLength() {

//方法体，要求计算出length的值并返回

【补充代码…仿照getArea()方法编写】

}

public double getArea() {

if(boo) {

double p=(sideA+sideB+sideC)/2.0;

area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ; return area; } else {

System.out.println(\不是一个三角形,不能计算面积\ return 0; } }

public void setABC(double a,double b,double c) {

//参数a,b,c分别赋值给sideA,sideB,sideC 【补充代码…】

if(【补充代码】) //a,b,c构成三角形的条件表达式 {

【补充代码】 //给boo赋值。 } else {

【补充代码】 //给boo赋值。 } } }

// Lader.java class Lader {

double above,bottom,height,area; Lader(double a,double b,double h) {

//带参数的构造方法，将参数a,b,h分别赋值给above,bottom,height 【补充代码…】 }

double getArea() {

//方法体，,要求计算出area返回 【补充代码…】 } }

// Circle.java class Circle {

double radius,area, length; Circle(double r) {

//带参数的构造方法 【补充代码】 }

double getArea() {

//方法体，要求计算出area返回 【补充代码…】 }

double getLength() { //getArea方法体的代码,要求计算出length返回 【补充代码…】 }

void setRadius(double newRadius) {

radius=newRadius; }

double getRadius() {

return radius; } }

// AreaAndLength.java

public class AreaAndLength {

public static void main(String args[]) {

double length,area; Circle circle = null; Trangle trangle = null; Lader lader = null;

【补充代码】 //创建对象circle(半径为5)

【补充代码】 //创建对象trangle(边长分别为3,4,5) 【补充代码】 //创建对象lader

【补充代码】 // circle调用方法返回周长并赋值给length System.out.println(\圆的周长:\

【补充代码】 // circle调用方法返回面积并赋值给area System.out.println(\圆的面积:\

【补充代码】 // trangle调用方法返回周长并赋值给length System.out.println(\三角形的周长:\

【补充代码】 // trangle调用方法返回面积并赋值给area System.out.println(\三角形的面积:\

【补充代码】 // lader调用方法返回面积并赋值给area System.out.println(\梯形的面积:\

【补充代码】 // trangle调用方法设置三个边，要求将三个边修改为12,34,1。

【补充代码】 // trangle调用方法返回面积并赋值给area System.out.println(\三角形的面积:\

【补充代码】 // trangle调用方法返回周长并赋值给length System.out.println(\三角形的周长:\ } } //答案： class Trangle { double sideA, sideB, sideC, area, length; boolean boo; public Trangle(double a, double b, double c) { sideA = a; sideB = b; sideC = c; // 参数a,b,c分别赋值给sideA,sideB,sideC if ((a + b) > c && (b + c) > a && (a + c) > b) // a,b,c构成三角形的条件表达式 { boo = true;// 给boo赋值。 } else { boo = false;// 给boo赋值。 } } double getLength() { length = sideA + sideB + sideC; return length;// 方法体，要求计算出length的值并返回 } public double getArea() { if (boo) { double p = (sideA + sideB + sideC) / 2.0; area = Math.sqrt(p * (p - sideA) * (p - sideB) * (p - sideC)); return area; } else { System.out.println(\不是一个三角形,不能计算面积\); return 0; } } public void setABC(double a, double b, double c) { sideA=a; sideB=b; sideC=c;// 参数a,b,c分别赋值给sideA,sideB,sideC if ((a + b) > c && (b + c) > a && (a + c) > b) // a,b,c构成三角形的条件表达式 { boo = true;// 给boo赋值。 } else { boo = false;// 给boo赋值。 } } } class Lader { double above, bottom, height, area; Lader(double a, double b, double c) { above=a; bottom=b; height=c;// 方法体，将参数a,b,c分别赋值给above,bottom,height }

double getArea() { area = (above + bottom) * height / 2.0; return area;// 方法体，,要求计算出area返回 } } class Circle { double radius, area; Circle(double r) { radius=r;// 方法体 } double getArea() { area = 3.14 * radius * radius; return area;// 方法体，要求计算出area返回 } double getLength() { double length; length = 2 * 3.14 * radius; return length;// getArea方法体的代码,要求计算出length返回 } void setRadius(double newRadius) { radius = newRadius; } double getRadius() { return radius; } } public class AreaAndLength { public static void main(String args[]) { double length , area; Circle circle = null; Trangle trangle; Lader lader; circle = new Circle(5);// 创建对象circle trangle = new Trangle(3, 4, 5);// 创建对象trangle。 lader = new Lader(6, 8, 10);// 创建对象lader length=circle.getLength();// circle调用方法返回周长并赋值给length System.out.println(\圆的周长:\ + length); area=circle.getArea();// circle调用方法返回面积并赋值给area System.out.println(\圆的面积:\ + area); length=trangle.getLength();// trangle调用方法返回周长并赋值给length System.out.println(\三角形的周长:\ + length); area=trangle.getArea();// trangle调用方法返回面积并赋值给area System.out.println(\三角形的面积:\ + area); area=lader.getArea();// lader调用方法返回面积并赋值给area System.out.println(\梯形的面积:\ + area); trangle.setABC(12, 34, 1);// trangle调用方法设置三个边，要求将三个边修改为12,34,1。 area=trangle.getArea();// trangle调用方法返回面积并赋值给area System.out.println(\三角形的面积:\ + area); length=trangle.getLength();// trangle调用方法返回周长并赋值给length System.out.println(\三角形的周长:\ + length); } }

3. 掌握上转型对象的使用，多态的特性

定义一个抽象(abstract)类，类名为Employee。 Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年领取薪水(每年10万)，MonthWorker对象按月领取薪水(每月1万)，WeekWorker对象按周领取薪水(每周0.5万，设定一个月4周)。Employee类有一个抽象(abstract)方法： public abstract double earnings();

子类必须重写父类的earnings()方法，给出各自领取每年报酬的具体方式。 有一个Company类，该类用Employee数组作为成员，Employee数组的单元可以是YearWorker对象、MonthWorker对象、WeekWorker对象的上转型对象。程序能输出Company对象一年需要支付的薪水总额。

请按模版要求，将代码补充完整。 abstract class Employee {

public abstract double earnings(); }

class YearWorker extends Employee {

【补充代码…】 //重写earnings()方法 }

class MonthWorker extends Employee {

【补充代码…】 //重写earnings()方法

}

class WeekWorker extends Employee {

【补充代码…】 //重写earnings()方法 }

class Company {

Employee[] employees; double salaries = 0;

Company(Employee[] employees) { this.employees = employees; }

public double salariesPay() { salaries = 0;

【补充代码…】 //计算salaries return salaries; } }

public class HardWork {

public static void main(String[] args) { Employee[] employees = new Employee[20];

for (int i = 0; i < employees.length; i++) { if(i%3==0)

employees[i] = new WeekWorker(); else if(i%3==1)

employees[i] = new MonthWorker(); else if(i%3==2)

employees[i] = new YearWorker(); }

Company company = new Company(employees); System.out.println(\公司年工资总额:\ + company.salariesPay()); } }

abstract class Employee { public abstract double earnings(); } class YearWorker extends Employee { public double earnings() { return 100000.00; } } class MonthWorker extends Employee { public double earnings() { return 10000.00*12; } } class WeekWorker extends Employee { public double earnings() { return 5000.00*4*12; } } class Company { Employee[] employee; double salaries=0; Company(Employee[] employee) { this.employee=employee; } public double salariesPay() { salaries=0; for(int i=0;i

4. 掌握嵌套类和内部类的概念和用法

编写一个程序要求定义一个外部类Outer，然后在Outer类中定义一个内部类Inner和局部类Local，内部类Inner和局部类Local的任务都是显示出外部类中的数组元素，然后求出这些数组元素的平均值。

请按模版要求，将代码补充完整。 class Outer {

private int data[]; Outer(int x[]) { data = x; }

void checkInner() {

Inner innerObj = new Inner();

【补充代码】 // 调用Inner对象的show（）方法 System.out.println(\内部类计算的平均值: \ + innerObj.average()); }

void checkLocal() { class Local { void show() {

System.out.print(\从局部类显示数组元素:\); for (int i = 0; i < data.length; i++) { System.out.print(data[i] + \); }

System.out.println(); }

int average() { int sum = 0;

for (int i = 1; i < data.length; i++) {

static void updateStudent(Student stu, Scanner scanner) { System.out.println(\请输入要更新的学生的姓名:\); stu.setSname(scanner.next());

System.out.println(\请输入要更新的学生的系部:\); stu.setSdept(scanner.next()); }

/**

* 主函数

* @param args */

public static void main(String[] args) { String sno;

int menuChoice;

Scanner scanner = new Scanner(System.in);

StudentDAOImpl studentDAOImpl = new StudentDAOImpl(); do {

menuChoice = menu_select(scanner); switch (menuChoice) { // 插入学生信息记录 case 1:

Student newStu = new Student(); inputStudent(newStu, scanner);

studentDAOImpl.insertStudent(newStu); break;

// 删除学生信息记录 case 2:

System.out.println(\请输入要删除学生信息的学号：\); sno = scanner.next();

studentDAOImpl.deleteStudent(sno); break;

// 更新学生信息记录 case 3:

System.out.println(\请输入要更新学生信息的学号：\); sno = scanner.next(); Student updateStu =

studentDAOImpl.findStudentBySno(sno); if (updateStu != null) {

System.out.println(\要更新的学生信息显示如下:\);

studentDAOImpl.displayStudentBySno(updateStu.getSno());

updateStudent(updateStu, scanner);

studentDAOImpl.updateStudent(updateStu);

} else {

System.out.println(\要更新的学生信息不存在!\); }

break;

// 显示所有学生信息记录 case 4:

studentDAOImpl.displayAllStudent(); break;

// 按学号查询指定学生信息 case 5:

System.out.println(\请输入查询学生信息的学号：\); sno = scanner.next();

studentDAOImpl.displayStudentBySno(sno); break; case 0: break; default:

System.out.println(\对不起，您输入的功能编号有错!请重新输入!!!\);

break; }

} while (menuChoice != 0); scanner.close(); } } IStudentDAO.java interface IStudentDAO{ public void insertStudent(Student stu); // 删除指定学号学生信息记录 public void deleteStudent(String sno); // 更新指定学生信息记录 public void updateStudent(Student stu); // 按学号查询指定学生信息记录 public Student findStudentBySno(String sno); // 显示指定学号学生信息记录 public void displayStudentBySno(String sno); // 显示所有学生信息记录 public void displayAllStudent(); } Student.java class Student{ public String sno; public String sname; public String sdept; public String getSno() { return sno; } public void setSno(String sno) { this.sno=sno; } public String getSname() { return sname; } public void setSname(String sname) { this.sname=sname; } public String getSdept() { return sdept; } public void setSdept(String sdept) { this.sdept=sdept; } } StudentDAOImpl.java import java.util.*; public class StudentDAOImpl implements IStudentDAO{ static List students=new ArrayList(); Scanner scanner=new Scanner(System.in); public void insertStudent(Student stu){ if(students.add(stu)){ System.out.println(\操作成功！\); }else{ System.out.println(\操作失败！\); } } // 删除指定学号学生信息记录 public void deleteStudent(String sno){ if(students.size()>0){ Iterator it=students.iterator(); while(it.hasNext()) { Student stu=it.next(); if (stu.getSno().equals(sno)) { if(students.remove(stu)){ System.out.println(\操作成功！\); }else{ System.out.println(\操作失败！\); } return; } } System.out.println(\对不起，要删除的学生不存在！\); }else{ System.out.println(\数据库中无学生记录!\); } } // 更新指定学生信息记录 public void updateStudent(Student stu){ if(students.size()>0){ Iterator it=students.iterator(); while(it.hasNext()) { Student student=it.next(); if (student.getSno().equals(stu.sno)) { student.sname=stu.sname; student.sdept=stu.sdept; System.out.println(\操作成功！\); return; } } }else{ System.out.println(\数据库中无学生记录!\); } } // 按学号查询指定学生信息记录 public Student findStudentBySno(String sno){ if(students.size()>0){ Iterator it=students.iterator(); while(it.hasNext()) { Student stu=it.next(); if (stu.getSno().equals(sno)) { return stu; } } }else{ System.out.println(\数据库中无学生记录!\); } return null; } // 显示指定学号学生信息记录 public void displayStudentBySno(String sno){ Iterator it=students.iterator(); while(it.hasNext()) { Student stu=it.next(); if (stu.getSno().equals(sno)) { System.out.println(\学号: \ + stu.getSno() + \姓名: \ + stu.getSname() + \系部: \ + stu.getSdept()); return; } } System.out.println(\对不起，该学生不存在！\); } // 显示所有学生信息记录 public void displayAllStudent(){ if (students.size() > 0) { for (Student stu : students) { System.out.println(\学号: \ + stu.getSno() + \姓名: \ + stu.getSname() + \系部: \ + stu.getSdept()); } }else { System.out.println(\数据库中无学生记录!\); } } } MainClass.java import java.util.Scanner; public class MainClass { Scanner scanner=new Scanner(System.in); static int menu_select(Scanner scanner) {

} int menuchoice = -1; System.out.printf(\); System.out.printf(\学生信息管理系统功能菜单 \\n\); System.out.printf(\作者：齐心 \\n\); System.out.printf(\ \\n\); System.out.printf(\插入学生信息记录 \\n\); System.out.printf(\删除学生信息记录 \\n\); System.out.printf(\更新学生信息记录 \\n\); System.out.printf(\显示所有学生信息记录 \\n\); System.out.printf(\按学号查询指定学生信息 \\n\); System.out.printf(\结束程序 \\n\); System.out.printf(\ \\n\); System.out.printf(\请输入您的选择： \\n\); menuchoice = scanner.nextInt(); return menuchoice; /** * 输入学生信息 * @param stu * @param scanner */ static void inputStudent(Student stu, Scanner scanner) { System.out.println(\请输入学生的学号:\); stu.setSno(scanner.next()); System.out.println(\请输入学生的姓名:\); stu.setSname(scanner.next()); System.out.println(\请输入学生的系部:\); stu.setSdept(scanner.next()); } /** * 更新学生信息 * @param stu * @param scanner */ static void updateStudent(Student stu, Scanner scanner) { System.out.println(\请输入要更新的学生的姓名:\); stu.setSname(scanner.next()); System.out.println(\请输入要更新的学生的系部:\); stu.setSdept(scanner.next()); } /** * 主函数 * @param args */ public static void main(String[] args) { String sno; int menuChoice; Scanner scanner = new Scanner(System.in); StudentDAOImpl studentDAOImpl = new StudentDAOImpl(); do { menuChoice = menu_select(scanner); switch (menuChoice) { // 插入学生信息记录 case 1: Student newStu = new Student(); inputStudent(newStu, scanner); studentDAOImpl.insertStudent(newStu); break; // 删除学生信息记录 case 2: System.out.println(\请输入要删除学生信息的学号：\); sno = scanner.next(); studentDAOImpl.deleteStudent(sno); break; // 更新学生信息记录 case 3: System.out.println(\请输入要更新学生信息的学号：\); sno = scanner.next(); Student updateStu = studentDAOImpl.findStudentBySno(sno); if (updateStu != null) { System.out.println(\要更新的学生信息显示如下:\); studentDAOImpl.displayStudentBySno(updateStu.getSno()); updateStudent(updateStu, scanner); studentDAOImpl.updateStudent(updateStu); } else { System.out.println(\要更新的学生信息不存在!\); } break; // 显示所有学生信息记录 case 4: studentDAOImpl.displayAllStudent(); break; // 按学号查询指定学生信息 case 5: System.out.println(\请输入查询学生信息的学号：\); sno = scanner.next(); studentDAOImpl.displayStudentBySno(sno); break; case 0: break; default: System.out.println(\对不起，您输入的功能编号有错!请重新输入!!!\); break; } } while (menuChoice != 0); scanner.close(); } }

实验总结

请书写你对本次实验有哪些实质性的收获和体会，以及对本次实验有何良好的建议？

本文来源：https://www.bwwdw.com/article/4uxp.html