目录
一、java语言基础训练
7-1 计算钱币
编写程序，读取用户输入的代表总金额的double值，打印表示该金额所需的最少纸币张数和硬币个数，打印从最大金额开始。纸币的种类有十元、五元、一元，硬币的种类有五角、一角、贰分、壹分。
输入格式:
47.63
输出格式:
4 张十元 1 张五元 2 张一元 1 个五角 1 个一角 1 个贰分 1 个壹分
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
double n=sc.nextDouble();
System.out.println((int)n/10+" 张十元");
n%=10;
System.out.println((int)n/5+" 张五元");
n%=5;
System.out.println((int)n+" 张一元");
double t=n*100%100/10;
System.out.println((int)t/5+" 个五角");
t%=5;
System.out.println((int)t+" 个一角");
double p=n*100%100%10;
System.out.println((int)p/2+" 个贰分");
p%=2;
System.out.println((int)p+" 个壹分");
}
}7-2 sdut-温度转换
输入一个华氏温度，输出摄氏温度，其转换公式为：C=5(F-32)/9。
输入格式:
输入数据只有一个实数，即华氏温度。
输出格式:
输出数据只有一个，即摄氏温度，保留2位小数。
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
double n=sc.nextDouble();
System.out.printf("%.2f",5*(n-32)/9);
}
}7-3 输入半径计算圆的面积
从控制台输入半径，计算圆的半径。其中PI=3.14159
输入格式:
输入圆的半径
输出格式:
输出一行面积信息
输入样例:
10输出样例:
The area for the circle of radius 10.0 is 314.159
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
double r=sc.nextDouble();
double s=r*r*3.14159;
System.out.printf("The area for the circle of radius %.1f is %.3f\n",r,s);
}
}7-4 求一个三位正整数各位数字之和
求一个三位正整数各位数字之和
输入格式:
输入一个三位的正整数
输出格式:
输出百十个位上各位数字的和
输入样例:
678输出样例:
21
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int sum=0;
while(n>0)
{
sum+=n%10;
n/=10;
}
System.out.print(sum);
}
}二、程序流程控制结构
6-2 数字校验
本题要求实现一个函数，校验一个13位正整数号码是否正确。13位号码的最后一位是校验码。通过对前12位数字的加减乘除运算得到一个一位数字，如果和第13位数字相同，表示正确的号码。
1、从最右边第12位开始间隔一位个位数相加，然后乘7。
2、剩下的其余数字相加，然后乘2 。
3、再把两者加起来，除以10取余数
4、和第13位相校验，匹配就正确，不匹配则错误。
输入样例1：
在这里给出一组输入。例如：
1234567890126输出样例1：
在这里给出相应的输出。例如：
The checksum of 1234567890126 is correct
public static boolean checksum(long code)
{
int s1=0,s2=0,cnt=12;
long ck=code%10l;
code/=10;
while(cnt>0)
{
if(cnt%2==0) s1+=code%10;
else s2+=code%10;
cnt--;
code/=10;
}
s1*=7;
s2*=2;
int s=(s1+s2)%10;
if(s==ck) return true;
return false;
}7-1 闰年判断
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
- 年份是4的倍数而不是100的倍数；
- 年份是400的倍数。
其他的年份都不是闰年。输入格式:
输入包含一个整数y，表示当前的年份。数据规模与约定 1990 <= y <= 2050。
输出格式:
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。输入样例:
在这里给出一组输入。例如：
2013输出样例:
在这里给出相应的输出。例如：
no
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int y=sc.nextInt();
boolean f=false;
if((y%4==0&&y%100!=0)||y%400==0) f=true;
if(f) System.out.print("yes");
else System.out.print("no");
}
}7-2 身体质量指数（BMI）测算
输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
double w=sc.nextDouble(),h=sc.nextDouble();
double bmi=w/(h*h);
if(w<=0||w>727||h<=0||h>2.72) System.out.println("input out of range");
else
{
if(bmi<18.5) System.out.print("thin");
else if(bmi<24) System.out.print("fit");
else if(bmi<28) System.out.print("overweight");
else System.out.print("fat");
}
}
}7-3 倒顺数字串
输入正整数n，输出它的倒顺数字串。如n=6时，输出
1 2 3 4 5 6 5 4 3 2 1输入格式:
输入一个正整数n，n的范围是[1,50]。
输出格式:
n的倒顺数字串，每两个数字之间只用一个空格隔开。
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
for(int i=1;i<=n;i++)
{
if(i!=1) System.out.print(" ");
System.out.print(i);
}
for(int i=n-1;i>0;i--)
System.out.print(" "+i);
}
}三、类与对象
1、在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为（ 重载 ）。
重载：方法名相同，参数列表里的参数类型、个数、顺序不同；并且与返回值无关，即返回值可以相同也可以不同。
重写：方法名相同，参数列表相同，连返回值类型都相同
2、以下关于构造函数的描述错误的是（ A ）。
A.构造函数的返回类型只能是void型。 // 构造方法的类型不可指定
B.构造函数是类的一种特殊函数，它的方法名必须与类名相同。
C.构造函数的主要作用是完成对类的对象的初始化工作。
D.一般在创建新对象时，系统会自动调用构造函数。
3、关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ C ）
A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问
4、在Java中用什么关键字修饰的方法可以直接通过类名来调用？（ A ）
A.static
B.final
C.private
D.void
5、下面关于缺省构造方法的描述中正确的是（ A ）。
A.当类中没有定义任何构造方法时，Java编译器将为这个类创建缺省构造方法
B.缺省构造方法可以初始化其他方法中定义的变量
C.Java编译器会为所有的类创建缺省构造方法。
D.如果在一个类中定义的构造方法都声明了参数，Java编译器将为这个类创建一个缺省构造方法
6、对于类与对象的关系，以下说法错误的是（ D ）。
A.类是对象的类型
B.对象由类来创建
C.类是同类对象的抽象
D.对象是创建类的模板
7、Java程序默认引用的包是（ C ）。
A.java.text包
B.java.awt包
C.java.lang包
D.java.util包
8、有一个类A，以下为其构造方法的声明，其中正确的是（ B ）。
A.void A(int x){...}
B.A(int x){...} // 构造方法方法名=类名 构造方法的类型不能指定
C.a(int x){...}
D.void a(int x){...}
9、访问修饰符作用范围由大到小是 D
A.private-default-protected-public
B.public-default-protected-private
C.private-protected-default-public
D.public-protected-default-private
6-1 设计一个矩形类Rectangle
设计一个名为Rectangle的类表示矩形。这个类包括：
两个名为width和height的double型数据域，它们分别表示矩形的宽和高。width和height的默认值都为1.
一个无参构造方法。
一个为width和height指定值的矩形构造方法。
一个名为getArea()的方法返回这个矩形的面积。
一个名为getPerimeter()的方法返回这个矩形的周长。类名为：
Rectangle裁判测试程序样例：
import java.util.Scanner; /* 你的代码将被嵌入到这里 */ public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); double w = input.nextDouble(); double h = input.nextDouble(); Rectangle myRectangle = new Rectangle(w, h); System.out.println(myRectangle.getArea()); System.out.println(myRectangle.getPerimeter()); input.close(); } }输入样例：
3.14 2.78输出样例：
8.7292 11.84
class Rectangle
{
double w,h;
Rectangle() //无参构造方法
{
w=1;
h=1;
}
Rectangle(double w,double h) //构造方法
{
this.w=w;
this.h=h;
}
double getArea()
{
return w*h;
}
public double getPerimeter()
{
return (w+h)*2;
}
}6-2 Person类
构造Person类。包括姓名(name)，性别(sex)和年龄(age)。提供所有属性的set和get函数，提供print函数打印其信息
输入描述：
姓名(name)，性别(sex)和年龄(age)
输出描述：
用户信息
裁判测试程序样例：
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner scan = new Scanner(System.in); String name = scan.next(); String sex = scan.next(); int age = scan.nextInt(); Person p = new Person(); p.setName(name); p.setSex(sex); p.setAge(age); p.print(); scan.close(); } } /* 你的代码被嵌在这里 */输入样例：
在这里给出一组输入。例如：
Lucy male 23输出样例：
在这里给出相应的输出。例如：
name:Lucy; sex:male; age:23
class Person
{
String name;
String sex;
int age;
public void setName(String name)
{
this.name=name;
}
public void setSex(String sex)
{
this.sex=sex;
}
public void setAge(int age)
{
this.age=age;
}
public void print()
{
System.out.printf("name:%s; sex:%s; age:%d",name,sex,age);
}
}6-3 定义游客类
定义游客类(其测试类已给出)，要求如下：
一个景区根据游人的年龄收取不同价格的门票。请编写游客类，根据年龄段决定能够购买的门票价格并输出
- 当输入的年龄小于18或者大于60（不包括18,60）时，程序输出：
- 年龄为：XX，免费
- 当输入的年龄在18与60之间时，程序输出
- 年龄为：XX，价格为20元
输入样例1：
18输出样例1：
年龄为：18，价格为20元输入样例2：
15输出样例2：
年龄为：15，免费
class Tourist
{
int age;
public void show()
{
if(age<18||age>60) System.out.printf("年龄为：%d，免费",age);
else System.out.printf("年龄为：%d，价格为20元",age);
}
}6-4 设计Student类
定义一个Student类，表示学生信息。Student类有学号（id，整型）、姓名（name，字符串）、性别（sex，字符型，m表示男性，f表示女性）三个私有数据域；有参构造方法将学号、姓名、性别设置为给定的参数；成员方法display显示学生的信息。
注意，Student类的定义应该这样开始：
class Student {
也就是说，Student类的class前面不要有public。输入
输入学号、姓名、性别。
输出
输出学号、姓名、性别。
输入样例：
1000 Tan m输出样例：
1000 Tan m
class Student{
int id;
String name;
char sex;
Student(int id,String name,char sex)
{
this.id=id;
this.name=name;
this.sex=sex;
}
void display()
{
System.out.println(id);
System.out.println(name);
System.out.println(sex);
}
}四、继承与多态
1、输出结果为 10.0
class A { double f(double x, double y) { return x * y; } } class B extends A { double f(double x, double y) { return x + y; } } public class Test { public static void main(String args[]) { A obj = new B(); System.out.println(obj.f(4, 6)); } }成员方法的覆盖——子类让父类的成员方法不复存在
2、 输出结果是：eat something
abstract class Person { public abstract void eat(); } public class Main { public static void main(String[] a) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } }
3、以下关于继承的叙述正确的是（ A ）。
A.在Java中类只允许单一继承
B.在Java中,一个类只能实现一个接口
C.在Java中，一个类
不能可以同时继承一个类和实现一个接口D.在Java中，接口也具有单继承性
4、父类的引用指向自己子类的对象是（ C ）的一种体现形式。
A.封装
B.继承
C.多态
5、 可以用于在子类中调用被重写父类方法的关键字是( D )
A.this
B.implements
C.extends
D.super
6、在使用super 和this关键字时，以下描述正确的是 A
A.在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B.this（）和super（）可以同时出现在一个构造函数中
C.super（）和this（）不一定要放在构造方法内第一行
D.this（）和super（）可以在static环境中使用，包括static方法和static语句块
7、关于下面的类，哪句是最正确的？ B
class A { private int i; protected int j; } class B extends A { private int k; protected int m; }A.B的对象包含数据域 i, j, k, m。
B.B的对象包含数据域 j, k, m。 //子类不能继承父类的private
C.B的对象包含数据域 j, m。
D.B的对象包含数据域k, m。
6-1 长方形长方体类
定义一个长方形类Rectangle，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方体类，拥有长、宽、高属性，提供构造函数，getPerimeter函数计算所有边的周长，getArea函数计算表面积，新增getVolume函数，计算体积
在main函数中，分别构造长方形类和长方体类的对象，并输出他们的周长、面积、体积，保留两位小数输入描述：
长方形类的长、宽
长方体类的长、宽、高输出描述：
长方形的周长和面积
长方体的周长，表面积，体积
class Rectangle
{
double w,h;
Rectangle(double w,double h)
{
this.w=w;
this.h=h;
}
public double getPerimeter()
{
return (w+h)*2;
}
public double getArea()
{
return w*h;
}
}
class Cuboid
{
double a,b,c;
Cuboid(double a,double b,double c)
{
this.a=a;
this.b=b;
this.c=c;
}
public double getPerimeter()
{
return (a+b+c)*4;
}
public double getArea()
{
return (a*b+a*c+b*c)*2;
}
public double getVolume()
{
return a*b*c;
}
}7-1 sdut-oop-6 计算各种图形的周长（多态）
定义接口或类 Shape，定义求周长的方法length()。
定义如下类，实现接口Shape或父类Shape的方法。
（1）三角形类Triangle （2）长方形类Rectangle （3）圆形类Circle等。
定义测试类ShapeTest，用Shape接口（或类）定义变量shape，用其指向不同类形的对象，输出各种图形的周长。并为其他的Shape接口实现类提供良好的扩展性。
提示： 计算圆周长时PI取3.14。
输入格式:
输入多组数值型数据（double）；
一行中若有1个数，表示圆的半径；
一行中若有2个数（中间用空格间隔），表示长方形的长度、宽度。
一行中若有3个数（中间用空格间隔），表示三角形的三边的长度。（需要判断三个边长是否能构成三角形）
若输入数据中有0或负数，则不表示任何图形，周长为0。
输出格式:
行数与输入相对应，数值为根据每行输入数据求得的图形的周长。
输入样例:
在这里给出一组输入。例如：
1 2 3 4 5 6 2 -2 -2 -3输出样例:
在这里给出相应的输出。例如：
6.28 10.00 15.00 12.56 0.00 0.00
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
while(sc.hasNext())
{
String str=sc.nextLine();
String[] a=str.split(" ");
if(a.length==1)
{
double r=Double.parseDouble(a[0]); //Double.parseDouble();把数据转化为double型
Shape x=new Circle(r);
System.out.printf("%.2f\n",x.getlength());
}else if(a.length==2)
{
double h=Double.parseDouble(a[0]);
double w=Double.parseDouble(a[1]);
Shape x=new Rectangle(w,h);
System.out.printf("%.2f\n",x.getlength());
}else if(a.length==3)
{
double d=Double.parseDouble(a[0]);
double b=Double.parseDouble(a[1]);
double c=Double.parseDouble(a[2]);
Shape x=new Triangle(d,b,c);
System.out.printf("%.2f\n",x.getlength());
}
}
}
}
interface Shape
{
public abstract double getlength();
}
class Triangle implements Shape
{
public double a,b,c;
Triangle(double a,double b,double c)
{
this.a=a;
this.b=b;
this.c=c;
}
public double getlength()
{
if(a<=0||b<=0||c<=0||a+b<=c||a+c<=b||b+c<=a) return 0;
return a+b+c;
}
}
class Rectangle implements Shape
{
public double w,h;
Rectangle(double w,double h)
{
this.w=w;
this.h=h;
}
public double getlength()//类在实现方法时 必须显式地使用public
{
if(w<=0||h<=0) return 0;
return (w+h)*2;
}
}
class Circle implements Shape
{
public double r;
Circle(double r)
{
this.r=r;
}
public double getlength()
{
if(r<=0) return 0;
return 3.14*2*r;
}
}
五、集合类
1、下列程序代码运行结果是：（2）。
import java.util.*; public class Test { public int hashCode() { return 1; } public boolean equals(Object b) { return true; } public static void main(String args[]) { Set set = new HashSet(); set.add(new Test()); set.add(new String("ABC")); set.add(new Test()); System.out.println(set.size()); } }set存不重复元素 也就是new Test和"ABC" 2个
2、Java中，要对一个类实现for( : )形式的遍历，则该类必须实现下列哪一个接口?
A.Cloneable
B.Comparable
C.Iterator
D.Iterable
7-1 重复数据问题
在一大堆数据中找出重复的是一件经常要做的事情。现在要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“yes”这三个字母；如果没有，则输出“no”。输入格式:
程序会读到n个整数的字符串【1<=n<=10000】，以空格分开，这些整数的范围是[1,10000]。
输出格式:
如果这些整数中存在重复的，就输出：
yes否则，就输出：
no输入样例:
在这里给出一组输入。例如：
1 2 3 1 4输出样例:
在这里给出相应的输出。例如：
yes
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Set<String> s=new HashSet<>();
String[] num=sc.nextLine().split(" ");
for(String x:num) s.add(x);
if(s.size()<num.length) System.out.print("yes");
else System.out.print("no");
}
}7-2 阅读程序，按照题目需求修改程序
import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args)
{
Collection c=new ArrayList<Employee>();
for (int i = 0; i < 3; i++)
{
Scanner sc = new Scanner(System.in);
String employeeName = sc.next();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it=c.iterator();
//3、遍历
while (it.hasNext())
{
//4、集合中对象未知，向下转型
Employee e =(Employee)it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
六、数组与字符串
1、有语句String s=”hello world”; 以下操作哪个是不合法的？（ B ）
A.int i=s.length();
B.s>>>=3;
C.String ts=s.trim(); trim()去掉首位空格
D.String t=s+”!”;
2、 有如下程序代码， 程序运行的结果是（ ）。
String s1 = "中国";
String s2 = "我爱 " + s1;
String s3 = "我爱 " + s1;
System.out.print(s2 == s3);
System.out.println(" "+s2.equals(s3));false true
7-1 超市贴花
某超市有一种促销手段，购买金额超过一定阈值就随机给一个贴花。贴花有不同种类的，种类以编号表示，编号是一个1到100之间的数字。当收集到连续编号的三张贴花时，就可以换一个小礼物。
小明经常去某超市购物，积攒了不少贴花，你帮他看看，能换多少小礼物。
输入格式:
首先是一个正整数N(1<N<100)，表示小明手上的贴花的数量。
然后是N个正整数Pi(1⩽Pi⩽1000，每个数字表示一张贴花的编号。输出格式:
输出一个数字，表示小明可以换的小礼物的数量。如果不能换小礼物，就输出
0。输入样例:
6 3 2 4 6 6 4输出样例:
12 3 4是一个组合，之后剩下的4 6 6不是连续的编号
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] a=new int[n];
for(int i=0;i<n;i++) a[i]=sc.nextInt();
Arrays.sort(a);
int cnt=0;
for(int i=2;i<n;)
if(check(a[i-2],a[i-1],a[i]))
{
cnt++;
i+=3;
}else i++;
System.out.print(cnt);
}
static boolean check(int a,int b,int c)
{
if(a==b-1&&c==b+1) return true;
return false;
}
}7-2 矩阵相加
import java.util.Scanner;//矩阵相加 C = A + B //写出方法调用
public class Main
{
public static Scanner scan = new Scanner(System.in);
public static void main(String[] args)
{
int m = scan.nextInt();//矩阵的行
int n = scan.nextInt();//矩阵的列
//创建二维数组a 行m，列n
int[][] a=new int[m][n];
//调用方法 为a输入数据
inputData(a);
//创建二维数组b 行m，列n
int[][] b=new int[m][n];
//调用方法，为b输入数据
inputData(b);
//调用方法 求 a+b
int[][] c=addMatrix(a,b);
//输出结果
showResult(c);
}
public static void inputData(int[][] arr)
{
for(int i =0;i<arr.length;i++)
for(int j=0;j<arr[i].length;j++)
arr[i][j] =scan.nextInt();
}
public static int[][] addMatrix(int[][]arr1,int[][]arr2)
{
int [][] c = new int[arr1.length][arr1[0].length];
for(int i =0;i<arr1.length;i++)
for(int j =0;j<arr1[i].length;j++)
c[i][j] = arr1[i][j] + arr2[i][j];
return c;
}
public static void showResult(int[][] arr)
{
for(int i =0;i<arr.length;i++)
{
for(int j =0;j<arr[i].length;j++)
System.out.print(" "+arr[i][j]);
System.out.println();
}
}
}
7-3 学号识别
学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号
输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入输出格式:
学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03注意：如非法输入，输出“Wrong Format"
输入样例:
在这里给出一组输入。例如：
18011103输出样例:
在这里给出相应的输出。例如：
入学年份：2018年 学院：材料学院 班级：11 学号：03输入样例1:
在这里给出一组输入。例如：
18013输出样例1:
在这里给出相应的输出。例如：
Wrong Format
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
String s=sc.next();
String[] a=new String[4];
if(s.length()!=8)
{
System.out.print("Wrong Format");
return;
}
int cnt=0;
for(int i=2;i<=s.length();i+=2)
a[cnt++]=s.substring(i-2,i);
if(a[1].equals("01")||a[1].equals("02")||a[1].equals("03")||a[1].equals("20"))
{
System.out.println("入学年份：20"+a[0]+"年");
if(a[1].equals("01")) System.out.println("学院：材料学院");
else if(a[1].equals("02")) System.out.println("学院：机械学院");
else if(a[1].equals("03")) System.out.println("学院：外语学院");
else System.out.println("学院：软件学院");
System.out.println("班级："+a[2]);
System.out.println("学号："+a[3]);
return;
}
System.out.print("Wrong Format");
}
}
848
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
