程序员最近都爱上了这个网站  程序员们快来瞅瞅吧！  it98k网:it98k.com

文章目录：

一：书写语句完成下面的功能

二：判断下面说法是否正确

三：设计并测试一个名为Retangle的矩形类，包括的属性有矩形的左下角与右上角两个点的坐标，包括的方法有计算矩形的宽度和高度以及矩形的面积

四：编写一个类实现复数的运算

 五：为一个州立大学的学生建立账单系统。州内外的学生收费不同，州内每学分收费￥75，州外为￥200，每个学生的账单上有学校名称、学生姓名、信用卡使用的时间以及账单的总额

六：编写一个类实现银行帐户

七：编写一个学生类Student，包含的属性有学号、姓名、性别、年龄、班号等，方法有getter和setter方法，toString()方法等，定义构造方法初始化所有属性，编写一个班级学生管理程序将所有学生存储在一个数组中

一：书写语句完成下面的功能

(1) 定义一个类，其名称为MyClass，它可以被所有的其他类访问。
public class MyClass{}
(2)将对象obj1的属性field1在屏幕上显示出来。
System.out.print(Object1.field1)；
(3)调用对象obj1的方法method1，把返回值赋值给变量hold。 
Hold=Object1.method1();
(3)定义一个整型属性mine，使得只有这个类本身可以访问它。
Private int Mine；
    (5)为类Class1定义一个整型变量field2，使得所有其他类都可以访问它。
public class Class1{public int field2;}
(6)定义一个无形式参数无返回值的方法method2，使得使用类名Class1作前缀就可以调用它。
static void method2()；
    (7)为类Class2编写构造方法的方法头，该构造函数不接受形式参数。
Class2()；
(8)为类Class2编写构造方法的方法头，该构造函数接受两个整型形式参数。
Class2(int c1，int c2)；
    (9)创建类Class1的一个对象obj1，定义这个类的一个引用ref1，把对象obj1的引用赋给ref1。
    	Class1 obj1=new Class1()	；	 Class1 ref1=obj1；
(10)为类Class1创建一个静态整型变量s_data。
    	 static int s_data；
(11)写出一个空的静态初始化器。
    	static {
			//静态域初始化语句
			}
(12)写出抽象类IamAbstract的类头定义语句。
    	public abstraact class IamAbstract；
(13)定义——个抽象方法abstractMethod，没有形式参数，返回值为布尔型量。
   		public abstract boolean abstractMethod()；
(14)写出定义最终类IamFinal的类头定义语句。
    	Final class IamFinal;
(15)定义浮点常量PIE，其取值为3.1415926。
float PIE 3.1415926；

二：判断下面说法是否正确

    (1) Java程序是由若干类定义组成的，类定义包括定义类头和定义类体。T
    (2)Class1类的属性被private修饰符修饰为私有变量，所以方法不能访问它。F
    (3)类头定义主要说明类的名字、父类名和接口名。T
    (4)一个程序里有且只能有一个公共类，它就是主类。F
    (5)类的修饰符有静态修饰符static、最终修饰符final、易失修饰符volatile和过渡修饰符transient。F
    (6)引用一个类的属性或调用其方法，必须以这个类的对象为前缀。F
    (7)创建新的类对象使用关键字new，回收无用的类对象使用关键字free。F
    (8)对象可以赋值，只要使用赋值号(等号)即可，相当于生成了一个各属性与赋值对象相同的新对象。F
    (9)有的类定义时可以不定义构造函数，所以构造函数不是必需的。F
    (10)类及其属性、方法可以同时有一个以上的修饰符来修饰。T
    (11)没有定义访问控制符的类属性和类方法可以被同一个包中的其他类和对象访问。F
    (12)与未加访问控制符的缺省情况相比，public和protected修饰符扩大了类及其属性和方法的被访问范围，private修饰符则缩小了这种范围。T
    (13)抽象类没有具体对象，所以抽象类没有构造函数。F
    (14)抽象类中的抽象方法必须在该类的子类中具体实现。F
    (15)抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。F
    (16)final类中的属性和方法都必须被final修饰符修饰。F
    (17)最终类不能派生子类，最终方法不能被覆盖。T
    (18)同一个类的对象使用不同的内存字段，但静态成员共享相同的内存空间T
    (19)方法中的形参可以和方法所属类的属性同名。T
    (20) return 语句不能用来返回对象F
    (21) 不管类中是否定义了何种构造方法，创建对象时都可以使用默认的构造方法。F
    (22) 一个程序里有且只能有一个公共类，它就是主类。F

三：设计并测试一个名为Retangle的矩形类，包括的属性有矩形的左下角与右上角两个点的坐标，包括的方法有计算矩形的宽度和高度以及矩形的面积

Retangle.java

package work.two.Test3;
 
 
/**
 * 设计并测试一个名为Retangle的矩形类，
 * 包括的属性有矩形的左下角与右上角两个点的坐标，
 * 包括的方法有计算矩形的宽度和高度以及矩形的面积。
 */
public class Retangle {
    private int x1,x2;
    private int y1,y2;
 
    public Retangle() {
    }
 
    public Retangle(int x1, int x2, int y1, int y2) {
        this.x1 = x1;
        this.x2 = x2;
        this.y1 = y1;
        this.y2 = y2;
    }
 
    public int getX1() {
        return x1;
    }
 
    public void setX1(int x1) {
        this.x1 = x1;
    }
 
    public int getX2() {
        return x2;
    }
 
    public void setX2(int x2) {
        this.x2 = x2;
    }
 
    public int getY1() {
        return y1;
    }
 
    public void setY1(int y1) {
        this.y1 = y1;
    }
 
    public int getY2() {
        return y2;
    }
 
    public void setY2(int y2) {
        this.y2 = y2;
    }
 
    @Override
    public String toString() {
        return "Retangle{" +
                "x1=" + x1 +
                ", x2=" + x2 +
                ", y1=" + y1 +
                ", y2=" + y2 +
                '}';
    }
    public int width(){
        return this.x2-this.x1;
    }
    public int height(){
        return this.y1-this.y2;
    }
    public int area(){
        return width()*height();
    }
}
 

main.java

package work.two.Test3;
 
import java.util.Scanner;
 
public class main {
    public static void main(String[] args) {
        Retangle retangle = new Retangle();
        Scanner scanner = new Scanner(System.in);
 
        System.out.print("请输入左上角坐标（x1,y1):");
        retangle.setX1(scanner.nextInt());
        retangle.setY1(scanner.nextInt());
 
        System.out.print("请输入右下角坐标（x2,y2):");
        retangle.setX2(scanner.nextInt());
        retangle.setY2(scanner.nextInt());
 
        System.out.println("你输入的坐标为：("+retangle.getX1()+"，"+retangle.getY1()+")；("+retangle.getX2()+"，"+retangle.getY2()+")");
 
        System.out.println("两个坐标组成的矩形    宽为："+Math.abs(retangle.width())+"\t长为："+Math.abs(retangle.height()));
        System.out.println("组成矩形的面积为："+Math.abs(retangle.area()));
    }
}

四：编写一个类实现复数的运算

复数类ComplexNumber的属性：
     realPart：实部，代表复数的实数部分。
     imaginPart：虚部，代表复数的虚数部分。
  复数类ComplexNumber的方法：
    (1) ComplexNumber()：无参构造方法，初始化实部和虚部为0
    (2)ComplexNumber(double r，double  i)：构造方法，创建复数对象的同时完成复数的实部、虚部的初始化，r为实部的初值，i为虚部的初值 
    (3) getter和setter方法
    (4)complexAdd(ComplexNumberc)：当前复数对象与形式参数复数对象相加，所得的结果也是复数值。
    (5)complexSub(ComplexNumberc)：当前复数对象与形式参数复数对象相减，所得的结果也是复数值。
    (6)complexMulti(ComplexNumber c)：当前复数对象与形式参数复数对象相乘，所得的结果也是复数值。
    (7)complexDivide(ComplexNumber c)：当前复数对象与形式参数复数对象相除，所得的结果也是复数值。
    (8)toString()：把当前复数对象的实部、虚部组合成a+bi的字符串形式，其中a和b分别为实部和虚部的数据。
    编程实现这个类，并验证所编写的类能否正常使用

ComplexNumber.java

package work.two.Test4;
 
public class ComplexNumber {
    public double realPart;
    private double imaginPart;//代表复数的虚数部分
 
    // 无参构造方法，初始化实部和虚部为0
  public ComplexNumber() {
        this.realPart=0;
        this.imaginPart=0;
    }
 
 
    //构造方法，创建复数对象的同时完成复数的实部、虚部的初始化，r为实部的初值，i为虚部的初值
    public ComplexNumber(double r, double i) {
        this.realPart = r;
        this.imaginPart = i;
    }
    // getter和setter方法
    public double getRealPart() {
        return realPart;
    }
 
    public void setRealPart(double realPart) {
        this.realPart = realPart;
    }
 
    public double getImaginPart() {
        return imaginPart;
    }
 
    public void setImaginPart(double imaginPart) {
        this.imaginPart = imaginPart;
    }
    //当前复数对象与形式参数复数对象相加，所得的结果也是复数值
    public ComplexNumber complexAdd(ComplexNumber c){
        ComplexNumber add=new ComplexNumber();
        add.setRealPart(this.realPart+c.realPart);
        add.setImaginPart(this.imaginPart+c.imaginPart);
        return add;
    }
    //当前复数对象与形式参数复数对象相减，所得的结果也是复数值
    public ComplexNumber complexSub(ComplexNumber c){
        ComplexNumber sub=new ComplexNumber();
 
        sub.setRealPart(this.realPart-c.realPart);
        sub.setImaginPart(this.imaginPart-c.imaginPart);
        return sub;
    }
    //当前复数对象与形式参数复数对象相乘，所得的结果也是复数值
    public ComplexNumber complexMulti(ComplexNumber c){
        ComplexNumber multi=new ComplexNumber();
        multi.setRealPart(this.realPart*c.realPart);
        multi.setImaginPart(this.imaginPart*c.imaginPart);
        return multi;
    }
    //当前复数对象与形式参数复数对象相除，所得的结果也是复数值
    public ComplexNumber complexDivide(ComplexNumber c){
        ComplexNumber divide=new ComplexNumber();
        divide.setRealPart(this.realPart/c.realPart);
        divide.setImaginPart(this.imaginPart/c.imaginPart);
        return divide;
    }
    //把当前复数对象的实部、虚部组合成a+bi的字符串形式，其中a和b分别为实部和虚部的数据
    @Override
    public String toString() {
        return "a+bi={" + realPart +"+" + imaginPart +"i}";
    }
}
 

main.java

package work.two.Test4;
 
public class main {
    public static void main(String[] args) {
        ComplexNumber complexNumber=new ComplexNumber(3,3);
 
        ComplexNumber c1=complexNumber.complexAdd(new ComplexNumber(6,6));
        System.out.println("相加后   实部："+c1.getRealPart()+"\t虚部："+c1.getImaginPart());
 
        ComplexNumber c2=complexNumber.complexSub(new ComplexNumber(6,6));
        System.out.println("相减后   实部："+c2.getRealPart()+"\t虚部："+c2.getImaginPart());
 
        ComplexNumber c3=complexNumber.complexMulti(new ComplexNumber(6,6));
        System.out.println("相乘后   实部："+c3.getRealPart()+"\t虚部："+c3.getImaginPart());
 
        ComplexNumber c4=complexNumber.complexDivide(new ComplexNumber(6,6));
        System.out.println("相除后   实部："+c4.getRealPart()+"\t虚部："+c4.getImaginPart());
 
        System.out.println(complexNumber.toString());
    }
}

 五：为一个州立大学的学生建立账单系统。州内外的学生收费不同，州内每学分收费￥75，州外为￥200，每个学生的账单上有学校名称、学生姓名、信用卡使用的时间以及账单的总额

Zhangdansystem.java

package work.two.Test5;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
/**
 * 为一个州立大学的学生建立账单系统。
 * 州内外的学生收费不同，州内每学分收费￥75，州外为￥200，
 * 每个学生的账单上有学校名称、学生姓名、信用卡使用的时间以及账单的总额。
 */
//每个学生的账单上有学校名称、学生姓名、信用卡使用的时间以及账单的总额
public class Zhangdansystem {
    private String SchoolName;
    private String StudentName;
    private Date CreditCardTime;
    private double bill=0;//账单的总额
    private boolean flag;//是否为州内学生
 
    public Zhangdansystem() {
    }
 
    public Zhangdansystem(String schoolName, String studentName, Date creditCardTime, double bill, boolean flag) {
        SchoolName = schoolName;
        StudentName = studentName;
        CreditCardTime = creditCardTime;
        this.bill = bill;
        this.flag = flag;
    }
 
    public String getSchoolName() {
        return SchoolName;
    }
 
    public void setSchoolName(String schoolName) {
        SchoolName = schoolName;
    }
 
    public String getStudentName() {
        return StudentName;
    }
 
    public void setStudentName(String studentName) {
        StudentName = studentName;
    }
 
    public String getCreditCardTime() {
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm");
        return sdf2.format(this.CreditCardTime);
    }
 
    public void setCreditCardTime(Date creditCardTime) {
        CreditCardTime = creditCardTime;
    }
 
    public double getBill() {
        return bill;
    }
 
    public void setBill(double bill) {
        this.bill = bill;
    }
 
    public boolean isFlag() {
        return flag;
    }
 
    //州内每学分收费￥75，州外为￥200
    public void setFlag(boolean flag)
    {
        this.flag = flag;
 
        if (isFlag()){
            this.bill=75;
        }else {
            this.bill=200;
        }
    }
 
    @Override
    public String toString() {
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm");
        return "StudentBill{" +
                "SchoolName='" + SchoolName + '\'' +
                ", StudentName='" + StudentName + '\'' +
                ", CreditCardTime=" + sdf2.format(this.CreditCardTime) +
                ", bill=" + bill +
                ", flag=" + flag +
                '}';
    }
}

main.java

package work.two.Test5;
 
import java.text.ParseException;
import java.util.Date;
 
public class main {
    public static void main(String[] args) throws ParseException {
        Zhangdansystem student1=new Zhangdansystem();
        student1.setSchoolName("州内大学");
        student1.setStudentName("刘鑫磊");
        student1.setCreditCardTime(new Date());
        student1.setFlag(true);
 
            System.out.println
                    (
                    "姓名："+student1.getStudentName()+
                            "\n学校："+student1.getSchoolName()+
                            "\n信用卡使用时间："+student1.getCreditCardTime()+
                            "\n账单总额："+student1.getBill()+
                            "\n是否为州内学生："+student1.isFlag()
                     );
 
 
        System.out.println("********************************");
 
 
        Zhangdansystem student2=new Zhangdansystem();
        student2.setSchoolName("州外大学");
        student2.setStudentName("刘鑫");
        student2.setCreditCardTime(new Date());
        student2.setFlag(false);
                System.out.println
                        (
                        "姓名："+student2.getStudentName()+
                                "\n学校："+student2.getSchoolName()+
                                "\n信用卡使用时间："+student2.getCreditCardTime()+
                                "\n账单总额："+student2.getBill()+
                                "\n是否为州内学生："+student2.isFlag()
                         );
    }
}

六：编写一个类实现银行帐户

    (1)设置的属性有“帐号”、“储尸姓名”、“地址”、“存款余额”，
    (2)设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”等。
    (3)给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法。
    (4)给类增加一个静态属性“活期利息”和封装这个数据的相应方法。
   完成整个程序的测试

Account.java

package work.two.Test6;
 
 
/**
 * 编写一个类实现银行帐户。
 * (1)设置的属性有“帐号”、“储尸姓名”、“地址”、“存款余额”，
 * (2)设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”等。
 * (3)给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法。
 * (4)给类增加一个静态属性“活期利息”和封装这个数据的相应方法。
 * 完成整个程序的测试
 */
public class Account {
    //设置的属性有“帐号”、“储尸姓名”、“地址”、“存款余额”
    private String AccountNumber;
    private String UserName;
    private String Address;
    private double Deposit;
    private static double MinDeposit=10;//给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法
    private static double CurrentInterest=0.05;//给类增加一个静态属性“活期利息”和封装这个数据的相应方法
 
    public Account() {
    }
 
    public Account(String accountNumber, String userName, String address, double deposit) {
        AccountNumber = accountNumber;
        UserName = userName;
        Address = address;
        Deposit = deposit;
    }
 
    public static void setMinDeposit(double minDeposit) {
        MinDeposit = minDeposit;
    }
 
    public static double getCurrentInterest() {
        return CurrentInterest;
    }
 
    public static void setCurrentInterest(double currentInterest) {
        CurrentInterest = currentInterest;
    }
 
    public String getAccountNumber() {
        return AccountNumber;
    }
 
    public void setAccountNumber(String accountNumber) {
        AccountNumber = accountNumber;
    }
 
    public String getUserName() {
        return UserName;
    }
 
    public void setUserName(String userName) {
        UserName = userName;
    }
 
    public String getAddress() {
        return Address;
    }
 
    public void setAddress(String address) {
        Address = address;
    }
 
    public double getDeposit() {
        return Deposit;
    }
 
    public void setDeposit(double deposit) {
        Deposit = deposit;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "AccountNumber=" + AccountNumber +
                ", UserName='" + UserName + '\'' +
                ", Address='" + Address + '\'' +
                ", Deposit=" + Deposit +
                '}';
    }
 
  //设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”等
    /**
     * 存款方法
     * @param money
     */
    public void deposit(double money){
        this.Deposit+=money;
        System.out.println("本次存入"+money+"元，当前余额为："+Deposit+"元");
    }
 
    /**
     * 取款方法
     * @param money
     */
    public void withdraw(double money){
        this.Deposit-=money;
        System.out.println("本次取出"+money+"元，当前余额为："+Deposit+"元");
    }
 
   //基本信息
    public void base(){
        System.out.println(
                        "账号："+this.AccountNumber+
                        "\n姓名："+this.UserName+
                        "\n地址："+this.Address+
                        "\n余额："+this.Deposit+"元");
    }
 
    /**
     * 计算利息
     * @return
     */
    public double interest(){
        double interest=this.Deposit*CurrentInterest;
        return interest;
    }
    /**
     * 累加利息
     */
    public void calculation(){
        System.out.println("本次增加利息为："+interest()+"元");
        Deposit+=interest();
        System.out.println("当前余额为："+Deposit+"元");
    }
 
}
 

mian.java

package work.two.Test6;
 
public class main {
    public static void main(String[] args) {
        Account liu = new Account();
        liu.setAccountNumber("3320180993322");
        liu.setUserName("刘鑫磊");
        liu.setAddress("西华大学");
        liu.setDeposit(300);//存款余额
        liu.base();//基本信息
 
        liu.deposit(300);//存款
        liu.withdraw(400);//取款
        liu.calculation();//累加利息
    }
}

七：编写一个学生类Student，包含的属性有学号、姓名、性别、年龄、班号等，方法有getter和setter方法，toString()方法等，定义构造方法初始化所有属性，编写一个班级学生管理程序将所有学生存储在一个数组中

实现如下管理操作：
   (1)增加一个学生；
   (2) 根据学号删除某个学生；
   (3) 将所有学生年龄增加一岁；
   (4) 将某个学生转到另一个班；
   (5) 输入班号、列出该班所有学生

Student.java

package work.two.Test7;
 
import java.util.Scanner;
 
/**
 * 编写一个学生类Student，
 * 包含的属性有学号、姓名、性别、年龄、班号等，
 * 方法有getter和setter方法，toString()方法等，
 */
public class Student {
    private String StdNumber;
    private String Name;
    private String Gender;
    private int age;
    private int ClassNumber;
 
    public Student() {
    }
 
    public Student(String stdNumber, String name, String gender, int age, int classNumber) {
        StdNumber = stdNumber;
        Name = name;
        Gender = gender;
        this.age = age;
        ClassNumber = classNumber;
    }
 
    public String getStdNumber() {
        return StdNumber;
    }
 
    public void setStdNumber(String stdNumber) {
        StdNumber = stdNumber;
    }
 
    public String getName() {
        return Name;
    }
 
    public void setName(String name) {
        Name = name;
    }
 
    public String getGender() {
        return Gender;
    }
 
    public void setGender(String gender) {
        Gender = gender;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getClassNumber() {
        return ClassNumber;
    }
 
    public void setClassNumber(int classNumber) {
        ClassNumber = classNumber;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "StdNumber='" + StdNumber + '\'' +
                ", Name='" + Name + '\'' +
                ", Gender='" + Gender + '\'' +
                ", age=" + age +
                ", ClassNumber=" + ClassNumber +
                '}';
    }
 
//下面开始实现各种方法
    /**
     * 查询所有学生信息
     *
     * @param students
     */
    public void find(Student students[]) {
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null)
            {
                System.out.print("学号：" + students[i].getStdNumber());
                System.out.print("\t姓名：" + students[i].getName());
                System.out.print("\t性别：" + students[i].getGender());
                System.out.print("\t年龄：" + students[i].getAge());
                System.out.println("\t班号：" + students[i].getClassNumber());
            }
        }
    }
 
    /**
     * 增加学生信息
     *
     * @param students
     */
    public void addStudent(Student students[]) {
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < students.length; i++) {
            if (students[i] == null) {
                students[i] = new Student();
 
                System.out.print("请输入要增加的学生学号：");
                students[i].setStdNumber(scanner.next());
 
                System.out.print("请输入要增加的学生姓名：");
                students[i].setName(scanner.next());
 
                System.out.print("请输入要增加的学生性别：");
                students[i].setGender(scanner.next());
 
                System.out.print("请输入要增加的学生年龄：");
                students[i].setAge(scanner.nextInt());
 
                System.out.print("请输入要增加的学生班号：");
                students[i].setClassNumber(scanner.nextInt());
                break;
            }
        }
 
    }
 
    /**
     * 删除学生信息
     *
     * @param students
     */
    public void delete(Student students[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要删除的学生学号：");
        String num = scanner.next();
 
        boolean flag = true;
 
        for (int i = 0; i < students.length; i++) {
            if (students[i].getStdNumber().equals(num)) {
                flag = false;
                students[i] = null;
            }
        }
        if (flag) {
            System.out.print("您输入的学号不存在！请重新输入！");
            delete(students);
        }
    }
 
    /**
     * 所有学生年龄增加一岁
     *
     * @param students
     */
    public void addAllAge(Student students[]) {
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null) {
                students[i].setAge(students[i].getAge() + 1);
            }
        }
    }
 
    /**
     * 某个学生转到另一个班
     *
     * @param students
     */
    public void move(Student students[]) {
        Scanner scanner = new Scanner(System.in);
 
        System.out.print("请输入要转班的学生学号:");
        String num = scanner.next();
 
        System.out.print("请输入要转入的班号:");
        int clsnum = scanner.nextInt();
 
        boolean flag = true;
 
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null) {
                if (students[i].getStdNumber().equals(num)) {
                    flag = false;
                    students[i].setClassNumber(clsnum);
                }
            }
        }
        if (flag) {
            System.out.print("您输入的学号不存在！请重新输入！");
            move(students);
        }
    }
 
    /**
     * 输入班号、列出该班所有学生
     *
     * @param students
     */
    public void numStudent(Student students[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入班号：");
        int classNum = scanner.nextInt();
 
        for (int i = 0; i < students.length; i++) {
            if (students[i] != null) {
                if (students[i].getClassNumber() == classNum) {
                    System.out.print("学号：" + students[i].getStdNumber());
                    System.out.print("\t姓名：" + students[i].getName());
                    System.out.print("\t性别：" + students[i].getGender());
                    System.out.print("\t年龄：" + students[i].getAge());
                    System.out.println("\t班号：" + students[i].getClassNumber());
                }
            }
        }
    }
}

mian.java

package work.two.Test7;
 
/**
 * 定义构造方法初始化所有属性，编写一个班级学生管理程序将所有学生存储在一个数组中，实现如下管理操作：
 * (1)增加一个学生；
 * (2)根据学号删除某个学生；
 * (3)将所有学生年龄增加一岁；
 * (4)将某个学生转到另一个班；
 * (5)输入班号、列出该班所有学生
 */
public class main {
    public static void main(String[] args) {
 
        Student []students=new Student[6];
        students[0]=new Student("001","刘鑫磊","男",20,1);
        students[1]=new Student("002","刘鑫","女",19,1);
        students[2]=new Student("003","刘磊","男",18,2);
        students[3]=new Student("004","鑫磊","女",17,2);
        students[4]=new Student("005","雨花石","女",16,3);
 
        Student student = new Student();
        student.find(students);//先全部输出来
 
        System.out.println("***********增加学生信息***************");
        student.addStudent(students);
        student.find(students);
 
        System.out.println("***********删除学生信息***************");
        student.delete(students);
        student.find(students);
 
        System.out.println("*********所有学生年龄增加一岁**********");
        student.addAllAge(students);
        student.find(students);
 
        System.out.println("*********某个学生转到另一个班**********");
        student.move(students);
        student.find(students);
 
        System.out.println("*******输入班号列出该班所有学生********");
        student.numStudent(students);
    }
}

原文链接:https://blog.csdn.net/liu17234050/article/details/117687912