7-1 声明图书类，记录图书总册数，利用静态变量赋值。
分数 10
全屏浏览
切换布局
作者 强彦
单位 太原理工大学
声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
输出格式:
请输出每本图书对应的书名，书号，书价以及总图书数。
输出样例:
书名：Java程序设计, 书号：1, 书价：34.5
书名：数据结构, 书号：2, 书价：44.8
书名：C++程序设计, 书号：3, 书价：35.0
图书总册数为：3
import java.util.*;
public class Main{
public static void main(String[] args){
Book a[]=new Book[3];
a[0]=new Book("Java程序设计",34.5);
a[1]=new Book("数据结构",44.8);
a[2]=new Book("C++程序设计",35.0);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}System.out.println("图书总册数为："+Book.count);
}
}class Book{
String name;
static int id;
double price;
int num=0;
static int count=0;
public Book(String name,double price){
this.name=name;
this.price=price;
this.id=num++;
count++;
}public String toString(){
id++;
return "书名："+name+", 书号："+Book.id+", 书价："+price;
}
}7-2 二进制的前导的零
分数 10
全屏浏览
切换布局
作者 翁恺
单位 浙江大学
计算机内部用二进制来表达所有的值。一个十进制的数字，比如24，在一个32位的计算机内部被表达为00000000000000000000000000011000。可以看到，从左边数过来，在第一个1之前，有27个0。我们把这些0称作前导的零。
现在，你的任务是写一个程序，输入一个整数，输出在32位表达下它前导的零的个数。
输入格式:
一个整数，在32位的整数可以表达的范围内。
输出格式:
一个整数，表达输入被表达为一个32位的二进制数时，在第一个1之前的0的数量。
输入样例:
256
输出样例:
23
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String binary=Integer.toBinaryString(n);
String s = String.format("%32s", binary).replace(' ', '0');
int count = 0;
for(int i=0;i<32;i++)
{
if(s.charAt(i)=='0')
count++;
if(s.charAt(i)=='1')
break;
}
System.out.println(count);
}
}
7-3 jmu-Java-01入门-第一个PTA上Java程序
分数 5
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
本题目要求读入若干对整数a和b，然后输出它们的和。
输入格式:
在一行中给出一对整数a和b。
以下输入样例只有两对，实际测试数据可能有多对值。
输出格式:
对每一组输入，如果a的绝对值>1000，输出|a|>1000，否则输出a+b的值。
输入样例:
18 -299
1001 -9
-1001 8
输出样例:
-281
|a|>1000
|a|>1000
import java.util.Scanner;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
while(in.hasNextInt()){
int a = in.nextInt();
int b = in.nextInt();
if (Math.abs(a)>1000)
System.out.println("|a|>1000");
else
System.out.println(a+b);
}
}
}7-4 jmu-Java-02基本语法-03-身份证排序
分数 4
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
- 输入n，然后连续输入n个身份证号。
- 然后根据输入的是sort1还是sort2，执行不同的功能。输入的不是sort1或sort2，则输出
exit并退出。
输入sort1，将每个身份证的年月日抽取出来，按年-月-日格式组装，然后对组装后的年-月-日升序输出。
输入sort2，将所有身份证按照里面的年月日升序输出。
注意：处理输入的时候，全部使用Scanner的nextLine()方法，以免出错。
输入样例:
641042519830930822532020319720611501143122719610803314633022619660505419034080019810819327X320111197112301539sort1sort2e输出样例:
1961-08-031966-05-051971-12-301972-06-111981-08-191983-09-3043122719610803314633022619660505419032011119711230153932020319720611501134080019810819327X410425198309308225exit
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
String[] caridS = new String[n];
for(int i=0;i<n;i++) {
String carIdString = scan.next();
caridS[i] = carIdString;
}
Comparator<String> com = new MyComparator();
Arrays.sort(caridS,com);
boolean loop = true;
while(loop) {
String inputString = scan.next();
switch (inputString) {
case "sort1":
for (String carid : caridS) {
System.out.println(carid.substring(6, 10)+"-"+carid.substring(10, 12)+"-"+carid.substring(12,14));
}
break;
case "sort2":
for (String carid : caridS) {
System.out.println(carid);
}
break;
default:
System.out.println("exit");
loop = false;
break;
}
}
}
}
class MyComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
return o1.substring(6, 15).compareTo(o2.substring(6, 15));
}
}
7-5 jmu-Java-03面向对象基础-01-构造方法与toString
分数 3
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
注意：属性顺序请严格按照上述顺序依次出现。
1.编写无参构造函数：
- 打印"This is constructor"。
- 将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。
3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.
4.对每个属性生成setter/getter方法
5.main方法中
- 首先从屏幕读取n，代表要创建的对象个数。
- 然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
- 然后将刚才创建的所有对象逆序输出。
- 接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]
import java.util.*;
import java.lang.*;
public class Main{
public static void main(String[] args) {
//List <Personn>persons=new ArrayList<Personn>();
Scanner sc = new Scanner(System.in);
int i,j;
int n = sc.nextInt();
Personn[] p = new Personn[n];
for(i=0;i<n;i++) {
p[i] = new Personn(sc.next(),sc.nextInt(),sc.nextBoolean());
}
for(i=n-1;i>=0;i--) {
System.out.println(p[i].toString());
}
System.out.println(new Personn());
}
}
class Personn{
private String name;
private int age;
private boolean gender;
private int id;
public Personn() {
System.out.println("This is constructor");
System.out.println(this.name+","+this.age+","+this.gender+","+this.id);
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean getGender() {
return gender;
}
public int getId() {
return id;
}
public void setName(String name) {
this.name=name;
}
public void setAge(int age) {
this.age=age;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public void setId(int id) {
this.id = id;
}
public Personn(String name,int age,boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}//创建构造类
public String toString() {
return "Person "+
"[name="+name+
", age="+age+
", gender="+gender+
", id="+id+"]";
}
}7-6 jmu-Java-03面向对象基础-02-构造方法与初始化块
分数 5
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
1.定义一个Person类
属性：String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
无参构造函数:Person(), 功能：打印This is constructor 。
有参构造函数:Person(name, gender, age) ，功能：给属性赋值。
建议：使用Eclipse自动生成toString方法
2.定义类的初始化块
为Person类加入初始化块，在初始化块中对id属性赋值，并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is ... 其中...是id的值。
提示：可为Person类定义一个static属性来记录所创建的对象个数。
3.编写静态初始化块
打印This is static initialization block
4.编写main方法
- 首先输入n，代表要创建的对象数量。
- 然后从控制台分别读取n行的
name age gender, 并调用有参构造函数Person(name, age, gender)新建对象 。 - 将创建好的n个对象逆序输出(即输出
toString()方法)。 - 使用无参构造函数新建一个Person对象，然后直接打印该对象。
思考
初始化类与对象有几种方法，构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么？各执行几次。
输入样例:
3a 11 falseb 12 truec 10 false输出样例:
This is static initialization blockThis is initialization block, id is 0This is initialization block, id is 1This is initialization block, id is 2Person [name=c, age=10, gender=false, id=2]Person [name=b, age=12, gender=true, id=1]Person [name=a, age=11, gender=false, id=0]This is initialization block, id is 3This is constructornull,0,false,3Person [name=null, age=0, gender=false, id=3]import java.util.*;
class Person{
private String name;
private int age;
private boolean gender;
private int id;
private static int num=0;
//初始化块
static {
System.out.println("This is static initialization block");
}
public Person(){
id=num;
num++;
System.out.println("This is initialization block, id is "+id);
System.out.println("This is constructor");
System.out.println(name+","+age+","+gender+","+id);
}
public Person(String name,int age,boolean gender){
id=num;
num++;
System.out.println("This is initialization block, id is "+id);
this.name = name;
this.age = age;
this.gender = gender;
}
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 boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
}
}
public class Main{
public static void main(String []args){
Scanner in = new Scanner(System.in);
int n=in.nextInt();
Person a[] = new Person[n];
for(int i=0;i<n;i++){
String name = in.next();
int age = in.nextInt();
boolean gender = in.nextBoolean();
a[i] = new Person(name,age,gender);
}
for(int i=n-1;i>=0;i--) {
System.out.println(a[i].toString());
}
Person b = new Person();
System.out.println(b);
}
}
7-7 jmu-Java-03面向对象基础-03-形状
分数 3
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
1. 定义长方形类与圆形类Circle
长方形类-类名：Rectangle，private属性：int width,length
圆形类-类名：Circle，private属性:int radius
编写构造函数：
带参构造函数:Rectangle(width, length),Circle(radius)
编写方法：public int getPerimeter()，求周长。public int getArea()，求面积。toString方法，使用Eclipse自动生成。
注意：
- 计算圆形的面积与周长，使用
Math.PI。 - 求周长和面积时，应先计算出其值(带小数位)，然后强制转换为
int再返回。
2. main方法
- 输入2行长与宽，创建两个Rectangle对象放入相应的数组。
- 输入2行半径，创建两个Circle对象放入相应的数组。
- 输出1：上面2个数组中的所有对象的周长加总。
- 输出2：上面2个数组中的所有对象的面积加总。
- 最后需使用
Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。
输入样例:
1 23 471输出样例:
69170[Rectangle [width=1, length=2], Rectangle [width=3, length=4]][Circle [radius=7], Circle [radius=1]]import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int area = 0;
int Perimeter = 0;
Rectangle[] r = new Rectangle[2];
for (int i = 0; i < 2; i++) {
int length = sc.nextInt();
int width = sc.nextInt();
r[i] = new Rectangle(length,width);
//计算面积
area+=r[i].getArea();
//计算周长
Perimeter+=r[i].getPerimeter();
}
Circle[] c = new Circle[2];
for (int i = 0; i < 2; i++) {
int radius = sc.nextInt();
c[i] = new Circle(radius);
//计算面积
area+=c[i].getArea();
//计算周长
Perimeter+=c[i].getPerimeter();
}
System.out.println(Perimeter);
System.out.println(area);
System.out.println(Arrays.deepToString(r));
System.out.println(Arrays.deepToString(c));
}
}
class Rectangle{
private int width;
private int length;
public Rectangle() {
}
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
//长方形的求周长方法
public int getPerimeter(){
return (this.length+this.width)*2;
}
//长方形的求面积方法
public int getArea(){
return this.length*this.width;
}
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
}
class Circle{
private int radius;
public Circle() {
}
public Circle(int radius) {
this.radius = radius;
}
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
//圆形的求面积方法
public int getArea(){
return (int)(this.radius*this.radius*Math.PI);
}
//圆形的求周长方法
public int getPerimeter(){
return (int)(this.radius*2*Math.PI);
}
public String toString() {
return "Circle [radius=" + radius + "]";
}
}7-8 jmu-Java-03面向对象基础-04-形状-继承
分数 15
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
- 你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
- 是否应该声明为static?
输入样例:
4rect3 1rect1 5cir1cir2输出样例:
38.8423.700000000000003[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]class Rectangle,class Shapeclass Rectangle,class Shapeclass Circle,class Shapeclass Circle,class Shapeimport java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Shape[] shape = new Shape[n];
double sumArea=0,sumPerimeter=0;
for (int i=0;i<n;i++){
String s = sc.next();
if (s.equals("rect")){//长方形
int width = sc.nextInt();
int length = sc.nextInt();
shape[i] = new Rectangle(width,length);
}
else{
int radius = sc.nextInt();
shape[i] = new Circle(radius);
}
//累加
sumArea +=shape[i].getArea();
sumPerimeter += shape[i].getPerimeter();
}
System.out.println(sumPerimeter);
System.out.println(sumArea);
System.out.print("[");
for (int i=0;i<n;i++){
System.out.print(shape[i].toString());
if (i!=n-1) System.out.print(", ");
}
System.out.println("]");
for (int i=0;i<n;i++){
//获得类名和父类名
System.out.println(shape[i].getClass()+","+shape[i].getClass().getSuperclass());
}
}
}
abstract class Shape{
static double PI = 3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
class Rectangle extends Shape{
int length,width;
double area,perimeter;
public Rectangle(int width,int length){
this.width = width;
this.length = length;
}
@Override
public double getPerimeter() {
perimeter = 2*(width+length);
return perimeter;
}
@Override
public double getArea() {
area = width*length;
return area;
}
public String toString(){
return "Rectangle [width="+width+", length="+length+"]";
}
}
class Circle extends Shape{
int radius;
double area,perimeter;
public Circle (int radius){
this.radius = radius;
}
@Override
public double getPerimeter() {
perimeter = PI*2*radius;
return perimeter;
}
@Override
public double getArea() {
area = PI*radius*radius;
return area;
}
public String toString(){
return "Circle [radius="+radius+"]";
}
}7-9 jmu-Java-03面向对象基础-05-覆盖
分数 3
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。
提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:
13zhang 10 truezhang 10 truezhang 10 false输出样例:
default-1-truezhang-10-truezhang-10-false2[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]import java.util.Arrays;
import java.util.Objects;
import java.util.Scanner;
class PersonOverride{
private String name;
private int age;
private boolean gender;
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public boolean equals(Object obj){
if (this == obj){
return true;
}
if(obj == null)
{
return false;
}
if (this.getClass() != obj.getClass()){
return false;
}
PersonOverride p = (PersonOverride)obj;
boolean b1 = Objects.equals((this.name), p.name);
boolean b2 = (this.age == p.age);
boolean b3 = (this.gender == p.gender);
if(b1 && b2 && b3){
return true;
}
return false;
}
public PersonOverride(String _name, int _age, boolean _gender){
name = _name;
age = _age;
gender = _gender;
}
public PersonOverride(){
this("default",1,true);
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n1 = scanner.nextInt();
PersonOverride[] persons1 = new PersonOverride[n1];
for (int i = 0; i < n1; i++) {
persons1[i] = new PersonOverride();
}
int n2 = scanner.nextInt();
scanner.nextLine();
PersonOverride[] persons2 = new PersonOverride[n2];
for (int i = 0; i < n2; i++) {
String str = scanner.nextLine();
String[] arr = str.split("\\s+");
PersonOverride temp = new PersonOverride(arr[0],Integer.parseInt(arr[1]),Boolean.valueOf(arr[2]));
boolean flag = true;
for (int j = 0; j < n2; j++) {
if(temp.equals(persons2[j])){
flag = false;
}
}
if(flag){
persons2[i] = new PersonOverride(arr[0],Integer.parseInt(arr[1]),Boolean.valueOf(arr[2]));
}
}
for (int i = 0; i < n1; i++) {
System.out.println(persons1[i]);
}
int i,count = 0;
for (i = 0; i < n2; i++) {
if(persons2[i] == null){
continue;
}
count++;
System.out.println(persons2[i]);
}
System.out.println(count);
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}7-10 jmu-Java-04面向对象进阶--02-接口-Comparator
分数 5
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。
1.编写PersonSortable2类
属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString方法：返回格式name-age
2 编写Comparator类
- 编写
NameComparator类，实现对name进行升序排序 - 编写
AgeComparator类，对age进行升序排序
3.main方法中
- 输入n
- 输入n行name age，并创建n个对象放入数组
- 对数组按照name进行升序排序后输出。
- 在3的基础上对数组按照age进行升序排序后输出。
- 最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));输入样例:
5zhang 15zhang 12wang 14Wang 17li 17输出样例:
NameComparator:sortWang-17li-17wang-14zhang-15zhang-12AgeComparator:sortzhang-12wang-14zhang-15Wang-17li-17//最后两行是标识信息
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
PersonSortable2 s[]=new PersonSortable2[n];
for(int i=0;i<n;i++) {
String name=scan.next();
int age=scan.nextInt();
s[i]=new PersonSortable2(name,age);
}
scan.close();
Arrays.sort(s, new NameComparator());
System.out.println("NameComparator:sort");
for(PersonSortable2 i:s) {
System.out.println(i);
}
Arrays.sort(s, new AgeComparator());
System.out.println("AgeComparator:sort");
for(PersonSortable2 i:s) {
System.out.println(i.toString());
}
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
}
}
class PersonSortable2{
public String name;
public int age;
public PersonSortable2(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return name + "-" + age;
}
}
class NameComparator implements Comparator<PersonSortable2>{
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
if(o1.name.compareTo(o2.name)>0)return 1;
else if(o1.name.compareTo(o2.name)<0)return -1;
else return o1.name.compareTo(o2.name);
}
}
class AgeComparator implements Comparator<PersonSortable2>{
@Override
public int compare(PersonSortable2 o1, PersonSortable2 o2) {
if(o1.age<o2.age)return -1;
else return 1;
}
}
7-11 jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
分数 15
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
定义Person抽象类，Student类、Company类，Employee类。
Person类的属性：String name, int age, boolean gender
Person类的方法:
public Person(String name, int age, boolean gender);public String toString(); //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false
Student类继承自Person，属性:String stuNo, String clazz
Student类的方法:
//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);public String toString(); //返回“Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。
Company类属性：String name
Company类方法:
public Company(String name);public String toString(); //直接返回name
public boolean equals(Object obj);//name相同返回true
Employee类继承自Person，属性：Company company, double salary
Employee类方法：
//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);public String toString(); //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数
编写equals方法重要说明：
- 对Employee的company属性的比较。要考虑传入为
null的情况。如果company不为null且传入为null，返回false - 对所有String字符类型比较时，也要考虑
null情况。
提示
- 排序可使用Collections.sort
- equals方法要考虑周全
main方法说明
- 创建若干Student对象、Employee对象。
输入s，然后依次输入name age gender stuNo clazz创建Student对象。
输入e，然后依次输入name age gender salary company创建Employee对象。
然后将创建好的对象放入List<Person> personList。输入其他字符，则结束创建。
创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
- 对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用
Comparable<Person>或Comparator<Person> - 接受输入，如果输入为
exit则return退出程序，否则继续下面步骤。 - 将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。
- 输出字符串
stuList，然后输出stuList中的每个对象。 - 输出字符串
empList，然后输出empList中的每个对象。
1-3为一个测试点4-6为一个测试点
输入样例：
s zhang 23 false 001 net15e wang 18 true 3000.51 IBMs zhang 23 false 001 net15e bo 25 true 5000.51 IBMe bo 25 true 5000.52 IBMe bo 18 true 5000.54 IBMe tan 25 true 5000.56 IBMe tan 25 true 5000.51 IBMs wang 17 false 002 nulls wang 17 false 002 nulle hua 16 false 1000 nulls wang 17 false 002 net16e hua 16 false 1000 nulle hua 18 false 1234 MicroSoft!continue输出样例：
Employee:bo-18-true-IBM-5000.54Employee:bo-25-true-IBM-5000.51Employee:bo-25-true-IBM-5000.52Employee:hua-16-false-null-1000.0Employee:hua-16-false-null-1000.0Employee:hua-18-false-MicroSoft-1234.0Employee:tan-25-true-IBM-5000.56Employee:tan-25-true-IBM-5000.51Student:wang-17-false-002-nullStudent:wang-17-false-002-nullStudent:wang-17-false-002-net16Employee:wang-18-true-IBM-3000.51Student:zhang-23-false-001-net15Student:zhang-23-false-001-net15stuListStudent:wang-17-false-002-nullStudent:wang-17-false-002-net16Student:zhang-23-false-001-net15empListEmployee:bo-18-true-IBM-5000.54Employee:bo-25-true-IBM-5000.51Employee:hua-16-false-null-1000.0Employee:hua-18-false-MicroSoft-1234.0Employee:tan-25-true-IBM-5000.56Employee:tan-25-true-IBM-5000.51Employee:wang-18-true-IBM-3000.51import java.text.DecimalFormat;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//创建集合，存储元素
List<Person> personList = new ArrayList<>();
while(true){
String choice = sc.next();
if("s".equals(choice)){
String name = sc.next();
int age = sc.nextInt();
boolean gender = "true".equals(sc.next());
String stuNo = sc.next();
String clazz = sc.next();
personList.add(new Student(name,age,gender,stuNo,clazz));
}else if("e".equals(choice)){
String name = sc.next();
int age = sc.nextInt();
boolean gender = "true".equals(sc.next());
double salary = sc.nextDouble();
Company company = new Company(sc.next());
personList.add(new Employee(name,age,gender,company,salary));
}else{
break;
}
}
/*
利用Collections工具类里的sort方法，这里我用的是匿名内部类的方式书写的，可以转成lambda表达
式，不过转完之后会让人难以理解，所以我就不转了
*/
Collections.sort(personList, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int i = o1.name.compareTo(o2.name);
i = i==0 ? o1.age-o2.age : i;
return i;
}
});
//增强for对集合进行遍历打印
for (Person person : personList) {
System.out.println(person.toString());
}
String choice = sc.next();
if("exit".equals(choice)){
//手动安全结束虚拟机工作
System.exit(0);
}
//创建两个集合
ArrayList<Student> stuList = new ArrayList<>();
ArrayList<Employee> empList = new ArrayList<>();
for (Person person : personList) {
//用instanceof判断能否转成Student类
if(person instanceof Student){
if(ExistsStu(stuList,person)){
stuList.add((Student)person);
}
}else{
if(ExistsEmp(empList,person)){
empList.add((Employee)person);
}
}
}
System.out.println("stuList");
for (Student student : stuList) {
System.out.println(student.toString());
}
System.out.println("empList");
for (Employee employee : empList) {
System.out.println(employee.toString());
}
}
//判断empList是否存在该元素
private static boolean ExistsEmp(ArrayList<Employee> empList, Person person) {
for (Employee employee : empList) {
if(employee.equals(person)){
return false;
}
}
return true;
}
//判断stuList是否存在该元素
private static boolean ExistsStu(ArrayList<Student> stuList, Person person) {
for (Student student : stuList) {
if(student.equals(person)){
return false;
}
}
return true;
}
}
//抽象类Person
abstract class Person{
String name;
int age;
boolean gender;
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public Person() {
}
@Override
public String toString() {
return name+"-"+age+"-"+gender;
}
@Override
public boolean equals(Object obj) {
Person p1 = (Person)obj;
if(p1==null){
return false;
}
if(p1.name==null){
return false;
}
if(!this.name.equals(p1.name)){
return false;
}
if(!(this.age==p1.age)){
return false;
}
return this.gender == p1.gender;
}
}
//学生类
class Student extends Person{
String stuNo;
String clazz;
public Student(String name, int age, boolean gender, String stuNo, String clazz) {
super(name, age, gender);
this.stuNo = stuNo;
this.clazz = clazz;
}
@Override
public String toString() {
return "Student:"+super.toString()+"-"+stuNo+"-"+clazz;
}
@Override
public boolean equals(Object obj) {
if(!super.equals(obj)){
return false;
}
Student s1 = (Student)obj;
if(s1==null){
return false;
}
if(s1.stuNo==null){
return false;
}
if(!this.stuNo.equals(s1.stuNo)){
return false;
}
if(s1.clazz==null){
return false;
}
return this.clazz.equals(s1.clazz);
}
}
class Company{
String name;
public Company(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
@Override
public boolean equals(Object obj) {
Company c1 = (Company)obj;
if(c1==null){
return false;
}
if(c1.name==null){
return false;
}
return this.name.equals(c1.name);
}
}
//员工类
class Employee extends Person{
Company company;
double salary;
public Employee(String name, int age, boolean gender, Company company, double salary) {
super(name, age, gender);
this.company = company;
this.salary = salary;
}
@Override
public String toString() {
return "Employee:"+super.toString()+"-"+company.toString()+"-"+salary;
}
@Override
public boolean equals(Object obj) {
if(!super.equals(obj)){
return false;
}
Employee e1 = (Employee)obj;
if(e1.company==null){
return false;
}
if(!this.company.name.equals(e1.company.name)){
return false;
}
DecimalFormat df = new DecimalFormat("#.#");
String s1 = df.format(this.salary);
String s2 = df.format(e1.salary);
return s1.equals(s2);
}
}
7-12 jmu-Java-06异常-01-常见异常
分数 5
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
自行编码产生常见异常。
main方法
- 事先定义好一个大小为5的数组。
- 根据屏幕输入产生相应异常。
提示：可以使用System.out.println(e)打印异常对象的信息，其中e为捕获到的异常对象。
输入说明:
arr代表产生访问数组是产生的异常。然后输入下标，如果抛出ArrayIndexOutOfBoundsException异常则显示，如果不抛出异常则不显示。null，产生NullPointerExceptioncast，尝试将String对象强制转化为Integer对象，产生ClassCastException。num，然后输入字符，转化为Integer，如果抛出NumberFormatException异常则显示。- 其他，结束程序。
输入样例：
arr 4nullcastnum 8arr 7num aother输出样例：
java.lang.NullPointerExceptionjava.lang.ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer (java.lang.String and java.lang.Integer are in module java.base of loader 'bootstrap')java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 5java.lang.NumberFormatException: For input string: "a"import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Integer[] arr = new Integer[5];
label:
while(scanner.hasNext()){
String str = scanner.next();
switch (str) {
case "arr":
int index = scanner.nextInt();
try {
Integer test1 = arr[index];
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e);
}
break;
case "null":
try {
String test2 = null;
boolean b = test2.equals("null");
}catch (Exception e){
System.out.println(e);
}
break;
case "cast":
try{
Object test3 = "1";
Integer s = (Integer)test3;
}catch (Exception e){
System.out.println(e);
}
break;
case "num":
String temp = scanner.next();
try{
Integer temp1 = Integer.parseInt(temp);
}catch (NumberFormatException e){
System.out.println(e);
}
break;
default:
break label;
}
}
}
}
7-13 jmu-Java-06异常-02-使用异常机制处理异常输入
分数 5
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
使用异常处理输入机制，让程序变得更健壮。
main方法：
- 输入n，创建大小为n的int数组。
- 输入n个整数，放入数组。输入时，有可能输入的是非整型字符串，这时候需要输出异常信息，然后重新输入。
- 使用
Arrays.toString输出数组中的内容。
输入样例：
512ab453输出样例：
java.lang.NumberFormatException: For input string: "a"java.lang.NumberFormatException: For input string: "b"[1, 2, 4, 5, 3]import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
try{
String str = scanner.next();
arr[i] = Integer.parseInt(str);
}catch (Exception e){
System.out.println(e);
i--;
}
}
System.out.println(Arrays.toString(arr));
}
}
7-14 jmu-Java-06异常-04-自定义异常(综合)
分数 15
全屏浏览
切换布局
作者 郑如滨
单位 集美大学
定义IllegalScoreException异常类，代表分数相加后超出合理范围的异常。该异常是checked exception，即希望该异常一定要被捕获处理。
定义IllegalNameException异常类，代表名字设置不合理的异常。该异常是unchecked exception
定义Student类。
属性:
private String name;
private int score;
方法:
toString //自动生成
setter/getter //自动生成
改造setName //如果姓名首字母为数字则抛出IllegalNameException
public int addScore(int score) //如果加分后分数<0 或>100，则抛出IllegalScoreException，加分不成功。
main方法
- 输入new则新建学生对象。然后输入一行学生数据，格式为姓名 年龄，接着调用setName，addScore。否则跳出循环。
- setName不成功则抛出异常，并打印异常信息，然后继续下一行的处理。
- addScore不成功则抛出异常，并打印异常信息，然后继续下一行的处理。如果2、3都成功，则打印学生信息(toString)
- 如果在解析学生数据行的时候发生其他异常，则打印异常信息，然后继续下一行的处理。
- Scanner也是一种资源，希望程序中不管有没有抛出异常，都要关闭。关闭后，使用System.out.println("scanner closed")打印关闭信息
注意：使用System.out.println(e);打印异常信息，e为所产生的异常。
输入样例：
new
zhang 10
new
wang 101
new
wang30
new
3a 100
new
wang 50
other
输出样例：
Student [name=zhang, score=10]
IllegalScoreException: score out of range, score=101
java.util.NoSuchElementException
IllegalNameException: the first char of name must not be digit, name=3a
Student [name=wang, score=50]
scanner closed
import java.util.Scanner;
class IllegalScoreException extends Exception{
public IllegalScoreException() {
}
public IllegalScoreException(String message) {
super(message);
}
public IllegalScoreException(String message, Throwable cause) {
super(message, cause);
}
public IllegalScoreException(Throwable cause) {
super(cause);
}
}
class IllegalNameException extends Exception{
public IllegalNameException() {
}
public IllegalNameException(String message) {
super(message);
}
public IllegalNameException(String message, Throwable cause) {
super(message, cause);
}
public IllegalNameException(Throwable cause) {
super(cause);
}
}
class Student{
private String name;
private int score;
//一般情况下，需要注意若程序抛出一个异常后，程序停止执行
private int flag=0;
public String getName() {
return name;
}
public int getFlag() {
return flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
public void setName(String name) {
char c=name.charAt(0);
if (c>='0'&&c<='9'){
try {
flag=1;
throw new IllegalNameException();
} catch (IllegalNameException e) {
System.out.println("IllegalNameException: the first char of name must not be digit, name="+name);
}
return;
}
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
if (flag==1){
return;
}
if (score<0||score>100){
try {
flag=1;
throw new IllegalScoreException();
} catch (IllegalScoreException e) {
System.out.println("IllegalScoreException: score out of range, score="+score);
}
}
this.score = score;
}
//如果加分后分数<0 或>100，则抛出IllegalScoreException，加分不成功。
public int addScore(int score) {
return 0;
}
@Override
public String toString() {
return "Student [" +
"name=" + name +
", score=" + score +
']';
}
}
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
while (true){
String str=sc.nextLine();
if (str.equals("new")){
String s=sc.nextLine();
String[] s1 = s.split(" ");
if (s1.length==2){
String name=s1[0];
int score=Integer.valueOf(s1[1]);
Student student = new Student();
student.setName(name);
student.setScore(score);
if (student.getFlag()==0){
System.out.println(student);
}
}else{
System.out.println("java.util.NoSuchElementException");
}
}else {
break;
}
}
sc.close();
System.out.println("scanner closed");
}
}
7-15 伪随机数
分数 10
全屏浏览
切换布局
作者 王从银
单位 吉首大学
在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long。Random的对象有两种构建方式：带种子和不带种子。不带种子的方式将会返回随机的数字，每次运行结果不一样。无论程序运行多少次，带种子方式构建的Random对象会返回一样的结果。
请编写程序，使用第一种方式构建Random对象，并完成下面输入输出要求。
输入格式:
在一行中输入3个不超过10000的正整数n,m,k。
输出格式:
在一行中输出以k为种子建立的Random对象产生的第n个0到m-1之间的伪随机数。
输入样例:
10 100 1000输出样例:
50import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
int k=scan.nextInt();
scan.close();
Random s=new Random(k);
int temp=0;
for(int i=1;i<=n;i++) {
temp=s.nextInt(m);
}
System.out.println(temp);
}
}
7-16 学生类-构造函数
分数 10
全屏浏览
切换布局
作者 黎浩宏
单位 浙江工贸职业技术学院
定义一个有关学生的Student类，内含类成员变量：
String name、String sex、int age，所有的变量必须为私有(private)。
1.编写有参构造函数：
能对name,sex,age赋值。
2.覆盖toString函数：
按照格式：类名 [name=, sex=, age=]输出。使用idea自动生成,然后在修改成该输出格式
3.对每个属性生成setter/getter方法
4.main方法中
•输入1行name age sex , 调用上面的有参构造函数新建对象。
输入样例:
tom 15 male
输出样例:
Student [name='tom', sex='male', age=15]
import java.util.Scanner;
class Student{
private String name;
private String sex;
private int age;
@Override
public String toString() {
String str="Student [name='"+name+"', sex='"+sex+"', age="+age+"]";
return str;
}
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String name=sc.next();
int age=Integer.valueOf(sc.next());
String sx=sc.next();
Student student = new Student(name, sx, age);
System.out.println(student);
}
}
7-17 定义类
分数 5
全屏浏览
切换布局
作者 王从银
单位 吉首大学
请补充以下代码，完成输出要求。（注意：需要提交完整代码）
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a,b,c,d,e;
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
d = in.nextInt();
e = in.nextInt();
RR rr = new RR();
double dd = rr.fun(a,b,c,d,e);
System.out.printf("%.2f",dd);
}
}
class RR{
}
输入格式:
在一行中给出5个不超过1000的正整数。
输出格式:
输出5个整数的平均值，保留小数点后两位。
输入样例:
1 2 3 4 5输出样例:
3.00import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a,b,c,d,e;
a = in.nextInt();
b = in.nextInt();
c = in.nextInt();
d = in.nextInt();
e = in.nextInt();
RR rr = new RR();
double dd = rr.fun(a,b,c,d,e);
System.out.printf("%.2f",dd);
}
}
class RR{
public double fun(int a,int b,int c,int d,int e){
return (a+b+c+d+e)/5;
}
}
7-18 定义类2
分数 5
全屏浏览
切换布局
作者 王从银
单位 吉首大学
请补充以下代码，完成输出要求。（注意：需要提交完整代码）
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double dd = RR.fun();
System.out.printf("%.2f",dd);
}
}
class RR{
}
输入格式:
在一行中给出5个不超过1000的实数。
输出格式:
输出排在中间的那个数，保留小数点后两位。
输入样例:
1 2 5 4 3输出样例:
5.00import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
double dd = RR.fun();
System.out.printf("%.2f", dd);
}
}
class RR {
public static double fun() {
Scanner se=new Scanner(System.in);
double a[]=new double[5];
for(int i=0;i<a.length;i++) {
a[i]=se.nextDouble();
}
return a[2];
}
}
7-19 JAVA-水仙花数
分数 20
全屏浏览
切换布局
作者 老象
单位 贵州师范学院
水仙花数是指一个N位正整数（7≥N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=13+53+33。 要求编写程序，计算所有N位水仙花数。
输入格式:
输入一个正整数N（3≤N≤7）。
输出格式:
按递增顺序输出所有N位水仙花数，每个数字占一行。
输入样例:
在这里给出一组输入。例如：
3输出样例:
在这里给出相应的输出。例如：
153370371407import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int a=(int)Math.pow(10, n-1);
int b=(int)Math.pow(10, n);//在[a,b)这个范围内取值
for (int i = a; i < b; i++) {
int c=i;
int sum=0;//各位上的数之和
for (int j = 0; j < n; j++)//n个位上的数都执行一遍
{
int r=1;
for (int k = 0; k < n; k++) //某个位上数的n次方
{
r=r*(c%10);
}
sum=sum+r;
c=c/10;
}
if(sum==i)
System.out.print(i+"\n");
}
}
}
7-20 作品评分
分数 10
全屏浏览
切换布局
作者 翁恺
单位 浙江大学
全国中小学生Scratch作品大赛拉开了序幕。每个参赛选手可以通过网络直接上传作品。本次比赛人人可做评委。每个网络评委可以通过网络对每一件作品进行打分。评分系统也是请程序高手设计的，能自动去掉一个最高分和一个最低分，求出平均分。
输入格式:
输入数据包括两行: 第一行为n，表示n个评委，n>2。
第二行是n个评委的打分，分数之间有一个空格。打分是可以带有小数部分的。
输出格式:
输出平均分，结果保留两位小数。
输入样例:
610 9 8 7.9 9 9.5输出样例:
8.88import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
in.nextLine();
float sum = 0;
List<Float> nums = new ArrayList<>();
String[] line = in.nextLine().split(" ");
for (String str : line) {
nums.add(Float.valueOf(str));
}
Collections.sort(nums);
nums.remove(0);
nums.remove(nums.size() - 1);
for (double num : nums) {
sum += num;
}
System.out.println(String.format("%.2f", sum / (n - 2)));
}
}
7-21 计算年龄
分数 10
全屏浏览
切换布局
作者 吴恋
单位 贵州师范学院
定义一个Birthday类，其成员变量有3个整形变量（出生的年月日）：year,month,day；提供构造方法对这3个成员变量进行初始化；提供成员变量的get、set方法；成员函数有getAge(),功能是实现计算到2017年12月25日时该Birthday对象的年龄。编写程序测试这个类。
输入格式:
输入出生的年、月、日（注：输入的年月日以换行隔开）
输出格式:
计算得到年龄
输入样例:
在这里给出一组输入。例如：
19951223输出样例:
在这里给出相应的输出。例如：
age=22import java.util.Scanner;
class Birthday{
private int year;
private int month;
private int day;
public Birthday(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public static void getAge(int year,int month,int day){
int age=0;
age = 2017-year;
if(month==12 && day>=25){
age--;
}
System.out.println("age="+age);
}
}
public class Main {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
int year=scan.nextInt();
int month=scan.nextInt();
int day=scan.nextInt();
Birthday.getAge(year,month,day);
}
}
7-22 成绩录入时的及格与不及格人数统计
分数 10
全屏浏览
切换布局
作者 吴恋
单位 贵州师范学院
编写一个程序进行一个班某门课程成绩的录入，能够控制录入成绩总人数，对录入成绩统计其及格人数和不及格人数。设计一个异常类，当输入的成绩小0分或大于100分时，抛出该异常类对象，程序将捕捉这个异常对象，并调用执行该异常类对象的toString（）方法，该方法获取当前无效分数值，并返回一个此分数无效的字符串。
输入格式:
从键盘中输入学生人数n
从键盘中输入第1个学生的成绩
从键盘中输入第2个学生的成绩
...
从键盘中输入第n个学生的成绩
（注：当输入的成绩无效时（即分数为小于0或大于100）可重新输入，且输出端会输出此分数无效的提醒。）
输出格式:
显示及格总人数
显示不及格总人数
输入样例:
在这里给出一组输入。例如：
31003060输出样例:
在这里给出相应的输出。例如：
21输入样例:
在这里给出一组输入。例如：
22006930输出样例:
在这里给出相应的输出。例如：
200invalid!11import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int pass=0;
int n=sc.nextInt();
for (int i = 0; i < n; i++) {
int t = sc.nextInt();
if(t<0 || t>100){
System.out.println(t+"invalid!");
i--;
}else{
if(t>=60&&t<=100)pass++;
}
}
System.out.println(pass+"\n"+(n-pass));
}
}
7-23 求最大值
分数 10
全屏浏览
切换布局
作者 lizf
单位 保定职业技术学院
本题目要求读入2个整数A和B，然后输出两个数的最大值。
输入格式:
输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
对每一组输入，在一行中输出最大值。
输入样例:
在这里给出一组输入。例如：
18 -299输出样例:
在这里给出相应的输出。例如：
18import java.util.Scanner;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int q, w;
do{
q = sc.nextInt(); w = sc.nextInt();
}while(q<-1000||q>1000||w>1000||w<-1000);
System.out.println(q>=w?q:w);
}
}
7-24 接口--四则计算器
分数 10
全屏浏览
切换布局
作者 ami
单位 临沂大学
- 利用接口做参数，写个计算器，能完成加减乘除运算。
- 定义一个接口ICompute含有一个方法int computer(int n, int m)。
- 定义Add类实现接口ICompute，实现computer方法，求m，n之和
- 定义Sub类实现接口ICompute，实现computer方法，求n-m之差
- 定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。
输入格式:
输入在一行中给出2个整数
输出格式:
输出两个数的和、差
输入样例:
在这里给出一组输入。例如：
6 7
输出样例:
在这里给出相应的输出。例如：
13
-1
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
Add l=new Add();
Sub j=new Sub();
System.out.println(l.computer(n, m));
System.out.println(j.computer(n, m));
in.close();
}
}
interface IComputer{
abstract public int computer(int n ,int m);
}
class Add implements IComputer
{
int m,n;
public int computer(int n ,int m) {
return n+m;
}
}
class Sub implements IComputer
{
int m,n;
public int computer(int n ,int m) {
return n-m;
}
}
7-25 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
分数 10
全屏浏览
切换布局
作者 仇丽青
单位 山东科技大学
统计一行字符串中的英文字母个数、空格个数、数字个数、其他字符个数
输入格式:
通过键盘输入一行字符(任意字符）
输出格式:
统计一行字符串中的英文字母个数、空格个数、数字个数、其他字符个数
输入样例:
rwrwewre2345asdJSJQI%^&(& *&sdf YY( 2342-k'输出样例:
字母个数：22
数字个数：8
空格个数：5
其他字符个数：10
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
String a = sc.nextLine();
char [] b=a.toCharArray();
int l=0,d=0,z=0,o=0;
for(int i=0;i<b.length;i++){
if(b[i]>='A'&&b[i]<='Z'||b[i]>='a'&&b[i]<='z'){
l++;
}
else if(b[i]>'0'&&b[i]<'9'){
d++;
}
else if(b[i]==' '){
z++;
}
else{
o++;
}
}
System.out.println("字母个数："+l);
System.out.println("数字个数："+d);
System.out.println("空格个数："+z);
System.out.println("其他字符个数："+o);
}
}
7-26 编程题：统计符合条件元素的个数
分数 8
全屏浏览
切换布局
作者 abc618382
单位 河北科技大学
统计1...n的闭区间中，能够被3整除元素的奇数和偶数的个数
输入格式:
输入值n的范围是 【1..1000】
输出格式:
奇数个数,偶数个数
输入样例:
5输出样例:
1,0import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
int ji = 0;
int ou = 0;
for(int i = 1;i <= num;i++){
if(i%3 == 0){
int t = i % 2 == 0 ? ou++ : ji++;
}
}
System.out.println(ji+","+ou);
}
}
7-27 定义商品类，封装成员变量，输出对象
分数 10
全屏浏览
切换布局
作者 邱颖豫
单位 许昌学院
定义一个商品类。创建对象并按指定格式输出它。
商品类要求：
（1）成员变量：商品编号（String）、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价
测试类要求：
按指定的格式输入商品信息，调用构造方法生成对象，并输出它。
例：输入：WJ002记事本5.5
输出：WJ002,记事本,5.5
输入商品的信息，每个属性值之间用1个空格分隔。
输出 格式，商品的每个属性值之间用逗号分隔。
输入样例:
WJ002记事本5.5
输出样例:
WJ002,记事本,5.5
import java.util.Scanner;
class Product{
private String number;
private String name;
private double price;
Product(String number,String name,double price){
this.number=number;
this.name=name;
this.price=price;
}
public String toString(){
return number+","+name+","+price;
}
public String getNumber(){
return number;
}
public void setNumber(String number){
this.number=number;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public double getPrice(){
return price;
}
public void setPrice(double price){
this.price=price;
}
}
public class Main{
public static void main(String []args){
Scanner sc=new Scanner(System.in);
String number=sc.next();
String name=sc.next();
double price=sc.nextDouble();
Product p1=new Product(number,name,price);
System.out.println(p1.toString());
}
}
7-28 定义类与创建对象
分数 10
全屏浏览
切换布局
作者 su jingfang
单位 河北科技大学
定义一个类Person,定义name和age属性，定义有参的构造方法对name和age进行初始化。在测试类中创建该类的2个对象，姓名、年龄分别为lili、19和lucy、20，在屏幕打印出2个对象的姓名和年龄。
输入格式:
本题目无输入
输出格式:
在一行中输出一个人的姓名和年龄
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
this person is lili,her age is 19this person is lucy,her age is 20public class Main {
public static void main(String[] args){
Person p1=new Person("lili",19);
Person p2=new Person("lucy",20);
System.out.println("this person is "+p1.name+",her age is "+p1.age+"");
System.out.println("this person is "+p2.name+",her age is "+p2.age+"");
}
}
class Person{
int age;
String name;
public Person (String name,int age){
this.name=name;
this.age=age;
}
}
7-29 成绩分级管理
分数 10
全屏浏览
切换布局
作者 殷伟凤
单位 浙江传媒学院
学校进行成绩分级管理，取消分数制，改为成绩分级评定。具体办法是：小于60分为E类；60分至70分（不含70分）为D类；70分至80分（不含）为C类；80分至90分（不含）为B类；90分以上为A类。设计一个程序，对输入的成绩进行等价划分
输入格式:
输入一个整数表示成绩。
输出格式:
根据输入的成绩，输出对应的等级(大写字母）
输入样例:
在这里给出一组输入。例如：
72输出样例:
在这里给出相应的输出。例如：
Cimport java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n = in.nextInt();
if(n < 60)
System.out.println("E");
else if(n >= 60 && n < 70)
System.out.println("D");
else if(n >= 70 && n < 80)
System.out.println("C");
else if(n >= 80 && n < 90)
System.out.println("B");
else if(n >= 90)
System.out.println("A");
}
}
7-30 USB接口的定义
分数 10
全屏浏览
切换布局
作者 AMi
单位 临沂大学
定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：
1.接口名字为USB，里面包括两个抽象方法：
void work（）；描述可以工作
void stop(); 描述停止工作
2.完成类Mouse，实现接口USB，实现两个方法：
work方法输出“我点点点”；
stop方法输出 “我不能点了”；
3.完成类UPan，实现接口USB，实现两个方法：
work方法输出“我存存存”；
stop方法输出 “我走了”；
4测试类Main中，main方法中
定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法
定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。
输入格式:
输出格式:
输出方法调用的结果
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
我点点点我不能点了我存存存我走了我点点点我不能点了public class Main {
public static void main(String[] args) {
Mouse usb1=new Mouse();
usb1.work();
usb1.stop();
USB usbs[]=new USB[2];
usbs[0]=new UPan();
usbs[0].work();
usbs[0].stop();
usbs[1]=new Mouse();
usbs[1].work();
usbs[1].stop();
}
}
interface USB{
void work();
void stop();
}
class Mouse implements USB{
public void work(){//要写public
System.out.println("我点点点");
}
public void stop(){
System.out.println("我不能点了");
}
}
class UPan implements USB{
public void work(){
System.out.println("我存存存");
}
public void stop(){
System.out.println("我走了");
}
}
标签：Java,String,int,age,编程,System,public,name From： https://blog.csdn.net/weixin_57423913/article/details/139649775