R7-12 点
点是最简单的形，是几何图形最基本的组成部分。要求设计一个点类Point类，Point类包括：
- 坐标成员变量 int x,int y
- 成员变量x,y的setter gette方法，以及ToString方法
- 带参无参构造方法
- 重写hashcode和equals方法，判断两个点是否相同
- 实现接口Comparable，可以比较两个点的大小，比较规则是若第一个点x大，则第一个点大，第一个点x小则第一个点小，若相同，比较y，根据y值判断大小。
- 实现方法 int distance(Point p2),求两个点的距离（开平方根使用方法Math.sqrt()）
测试类中main方法中，要求如下：
- 通过键盘输入2个点坐标，创建2个点对象
- 输出第一个点的信息（调用ToString方法），
- 比较他们的大小，如果第一点大于等于第二个点，输出true否则输出false
- 求这两个点的距离并输出。
### 输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
输入两行，每行为一个点的坐标
输入样例:
在这里给出一组输入。例如：
1. 4 6 2. 6 7
1. 4 5 2. 3 2
输出样例:
在这里给出相应的输出。例如：
1. Point [x=4, y=6] 2. false 3. 2
1. Point [x=4, y=5] 2. true 3. 3
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int x1 = cin.nextInt(); int y1 = cin.nextInt(); int x2 = cin.nextInt(); int y2 = cin.nextInt(); System.out.printf("Point [x=%d, y=%d]\n",x1, y1); if (x1 >= x2 && y1 >= y2) System.out.println( "true"); else System.out.println("false"); int x = (x1 - x2); int y = (y1 - y2); System.out.println((int)(Math.sqrt(x * x + y * y))); } }
R7-13 设计一个BankAccount类
设计一个BankAccount类，这个类包括：
（1）一个int型的balance表时账户余额。
（2）一个无参构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。
（4）一个getBlance（）方法，返回账户余额。
（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。
（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。
设计一个Main类进行测试，分别输入账户余额、提取额度以及存款额度，并分别输出账户余额。
输入格式:
依次输入账户余额、提取额度、存款额度
输出格式:
依次输出初始账户余额、提取amount额度后的账户余额、存入amount后的账户余额
输入样例:
在这里给出一组输入。例如：
1. 700 2. 70 3. 7
输出样例:
在这里给出相应的输出。例如：
1. 700 2. 630 3. 637
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int a = cin.nextInt(); int b = cin.nextInt(); int c = cin.nextInt(); BankAccount bankAccount = new BankAccount(a); System.out.println(bankAccount.getBalance()); System.out.println(bankAccount.withdraw(b)); System.out.println(bankAccount.deposit(c)); } } class BankAccount { private int balance; BankAccount() { balance = 0; } public BankAccount(int balance) { super(); this.balance = balance; } public int getBalance() { return balance; } public int withdraw(int amount) { return balance = balance - amount; } public int deposit(int amount) { return balance = balance + amount; } }
R7-14 马里奥赛车
你玩过马里奥游戏吗？你当然有，谁没有？！不管怎么说，马里奥游戏的新版本已经发布了，它是某种卡丁车比赛游戏。你决定写一个程序来找到你完成每一个阶段的最佳策略。
每一条水平轨道可以模拟为一条无限长的直线，在这条直线上的某些特定点上有一些站点。每个站点都有一个整数，表示其在轨道上的位置。你的任务是从第一个站（位置最小的站）到最后一个站（位置最大的站）最小移动次数。
你可以直接在任何两个电台之间移动（你可以去一个不相邻的电台，也可以回到位置较低的电台，如果你愿意的话！）如果你有足够的提升金币来完成这个动作。在每个关卡中，你都有一些可以使用的提升币。每一个推进硬币都有成本和能量价值。你可以为每一步选择硬币的任何一个子集，但是每个硬币每次只能使用一次。硬币是永久性的，你可以在同一级别的其他招式中再次使用硬币。
要移动，你必须选择一个子集的增加硬币，这样他们的成本总和不能超过L，他们的权力值的总和必须完全等于你要移动的两个电台的位置之间的绝对差。如果没有这样的子集，则不能直接进行移动。
现在你得到了一些级别的配置，你需要找到完成每一个级别的最小移动次数，或者说不可能完成这个级别。
输入格式:
您的程序将在一个或多个测试用例上进行测试。输入的第一行将是单个整数 T、 测试用例数（1≤T≤100）。
接下来是测试用例，每个测试用例的第一行包含3个整数，用单个空格N M L（2≤N≤100），（1≤M≤100）和（1≤L≤1000）,表示站点数量、提升硬币数量和最大硬币总数每次行动的成本。
后跟一行，其中包含N个分隔开的唯一正整数按一个空格（不需要排序，每个整数最多1000个），代表位置所有的车站。后面是M行，每行包含2个整数，用一个空格C V（1≤C，V≤100）隔开，分别代表一枚硬币的成本和权力价值。
输出格式:
对于每个测试用例，打印一行包含单个整数的行，如果无法从最左边的工作站转到最右边的工作站，那么这个整数应该是-1，如果可能的话，这个整数应该是最小移动次数。
输入样例:
2 3 2 4 3 1 6 3 2 3 3 3 1 4 1 3 6 3 2
输出样例:
1. 2 2. -1
题意：
一条路上有n个车站，你有m个金币，金币有各自的费用和价值，可以通过金币在车站间移动；
每次移动要选择一些金币，总成本不能超过L，其价值和必须刚好等于abs(i-j)；
问从1号站移动到n号站最少移动多少次？
注意：
在第一个测试用例中，站点位置是[3，1，6]，从1开始，必须在6结束。你会必须做2个移动，
从1->3使用硬币（3，2），从3->6使用硬币（3，3）。你不能直接从1->6使用（3，2）和（3，3），因为硬币的成本总和超出限制4。
R7-15 学生类设计
设计一个类Student，并在Main类中生成Student类对象进行测试
1.对于Student类，设计私有属性name和age，并为每一个成员变量name和age设计其setXXX（）和getXXX（）方法,并对于setAge方法，如果age被赋值为<=6,则age值为7，其他为参数值。
2.对于Student类，设计无参构造方法，在构造方法中为age赋值为7，name赋值为“无名" 并添加语句System.out.println("无参构造方法")；
3.设计方法public void display(),方法中显示该学生的姓名和年龄，显示格式为name：无名，age：8
Main类的main方法中，创建1个学生对象，然后调用display方法显示学生信息，接着通过键盘输入1个学生的姓名和年龄，调用display方法去显示学生信息。
输入格式:
在一行内输入学生的姓名和年龄
输出格式:
对每一组输入，输出学生的姓名和年龄。
输入样例:
在这里给出一组输入。例如：
tom 6
jerry 8
输出样例:
在这里给出相应的输出。例如：
1. 无参构造方法 2. name:无名,age:7 3. name:tom,age:7
无参构造方法 name:无名,age:7 name:jerry,age:8
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); Student stu = new Student(); stu.display(); Student stu1 = new Student(cin.next(), cin.nextInt()); stu1.display(); } } class Student { private String name; private int age; public void setName(String name) { this.name = name; } public String getName() { return name; } public int getAge() { return age; } public void setAge(int age) { if (age <= 6) { this.age = 7; } else { this.age = age; } } public Student() { name = "无名"; age = 7; System.out.println("无参构造方法"); } public Student(String name, int age) { this.name = name; if (age <= 6) { this.age = 7; } else this.age = age; } public void display() { System.out.println("name:" + this.name + ",age:" + this.age); } }
R7-16 物联网感知位置计算
物联网程序设计中，经常用到两个点的地理位置信息。和数学中的坐标系一个，你生活环境的每一个位置都有一个坐标（经度，纬度）可以用以下方式来声明：
double longitude;
double latitude;
A ,B两个点可以用以下方式：
double longitudeA;
double latitudeA;
double longitudeB;
double latitudeB;
然而你每天生活的轨迹并不是只有两个点，为了更好的表示这些点，我们需要申明一个点类：
class GeographicInfo { double latitude; double longitude; }
然后再写出主程序：
public class Main { public static void main(String[] args) { // TODO Auto-generated method stub GeographicInfo G; G = new GeographicInfo(); G.latitude = 35.66; G.longitude = 139.75; System.out.println(G.latitude); System.out.println(G.longitude); } }
假如你的位置信息是从A到B,写一个程序输出你的出行轨迹，注意你的位置用键盘输入语句。
longitudeA;
double latitudeA;
double longitudeB;
double latitudeB;
输入格式:
输入四个double类型变量。
输出格式:
输出这几个变量的位置.
输入样例:
在这里给出一组输入。例如：
35.66 139.75 95.66 939.75
输出样例:
在这里给出相应的输出。例如：
1. (35.66,139.75) 2. (95.66,939.75)
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); GeographicInfo a = new GeographicInfo(); GeographicInfo b = new GeographicInfo(); a.latitude = cin.nextDouble(); a.longitude = cin.nextDouble(); b.latitude = cin.nextDouble(); b.longitude = cin.nextDouble(); System.out.println("(" + a.latitude + "," + a.longitude + ")"); System.out.println("(" + b.latitude + "," + b.longitude + ")"); } } class GeographicInfo { double latitude; double longitude; }
R7-17 物联网远程点灯实验
远程点亮一个LED 灯是物联网最基本的实验，假如灯的位置用一个点的从标来表示，请设计一个点类 ，并针对这个类进行编程实验，当输入位置坐标和开关状态时输出Led灯的 on或off状态。
输入格式:
坐标和开关状态，如x y true
输出格式:
灯的开关状态 on或off
输入样例:
在这里给出一组输入。例如：
1 1 false
输出样例:
在这里给出相应的输出。例如：
off
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int x = cin.nextInt(); int y = cin.nextInt(); boolean state = cin.nextBoolean(); Point point = new Point(x,y,state); } } class Point{ int x,y; boolean state; public Point(){ } public Point(int x,int y,boolean state){ this.x = x; this.y = y; this.state = state; check(); } public void check(){ if(this.state==true){ System.out.println("on"); } else{ System.out.println("off"); } } }
R7-18 两点成线
都说两点确定一条直线，那么设计一个直线类Line，需要通过两个点Point对象来确定。Line类具体要求如下：
1)定义两个Point对象p1，p2；
2)写出有参构造方法，传递两个对象值给p1，p2
3）为p1，p2写出setters，和getters方法
4）为Line写出一个getLength方法求直线中两点的长度
5) 为LIne写一个ToString方法，方法如下所示：
public String toString() { return "Line [p1=" + p1 + ", p2=" + p2 + "]"; }
在Main类的main方法中，定义一个Line数组，数组长度通过键盘给出，然后通过键盘为每线段的两个Point对象的坐标赋值，并生成相应Line对象放入数组中，循环数组，输出每条直线的信息，以及两个点之间的距离。
Point 类如下所示：
public class Point { private int x, y;// x,y为点的坐标 //求两点之间的距离 public double distance(Point p1) { return Math.sqrt((p1.x -this.x)*(p1.x -this.x)+(p1.y-this.y)*(p1.y-this.y)); } public Point(int x, int y) { super(); this.x = x; this.y = y; } public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public Point() { super(); x = y =0; } @Override public String toString() { return "Point [x=" + x + ", y=" + y + "]"; } }
输入格式:
第一行输入数组的长度n
每一行输入一个Line对象的两个点对象的 x y的坐标，中间用空格隔开
输出格式:
循环输出，输出直线的信息，以及每条直线的两个点的距离，保留一位小数。
输入样例:
在这里给出一组输入。例如：
1. 2 2. 0 0 2 3 3. 1 3 2 5
输出样例:
在这里给出相应的输出。例如：
Line [p1=Point [x=0, y=0], p2=Point [x=2, y=3]] 此线段的长度为：3.6 Line [p1=Point [x=1, y=3], p2=Point [x=2, y=5]] 此线段的长度为：2.2
R7-18 两点成线
都说两点确定一条直线，那么设计一个直线类Line，需要通过两个点Point对象来确定。Line类具体要求如下：
1)定义两个Point对象p1，p2；
2)写出有参构造方法，传递两个对象值给p1，p2
3）为p1，p2写出setters，和getters方法
4）为Line写出一个getLength方法求直线中两点的长度
5) 为LIne写一个ToString方法，方法如下所示：
public String toString() { return "Line [p1=" + p1 + ", p2=" + p2 + "]"; }
在Main类的main方法中，定义一个Line数组，数组长度通过键盘给出，然后通过键盘为每线段的两个Point对象的坐标赋值，并生成相应Line对象放入数组中，循环数组，输出每条直线的信息，以及两个点之间的距离。
Point 类如下所示：
public class Point { private int x, y;// x,y为点的坐标 //求两点之间的距离 public double distance(Point p1) { return Math.sqrt((p1.x -this.x)*(p1.x -this.x)+(p1.y-this.y)*(p1.y-this.y)); } public Point(int x, int y) { super(); this.x = x; this.y = y; } public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public Point() { super(); x = y =0; } @Override public String toString() { return "Point [x=" + x + ", y=" + y + "]"; } }
输入格式:
第一行输入数组的长度n
每一行输入一个Line对象的两个点对象的 x y的坐标，中间用空格隔开
输出格式:
循环输出，输出直线的信息，以及每条直线的两个点的距离，保留一位小数。
输入样例:
在这里给出一组输入。例如：
1. 2 2. 0 0 2 3 3. 1 3 2 5
输出样例:
在这里给出相应的输出。例如：
Line [p1=Point [x=0, y=0], p2=Point [x=2, y=3]] 此线段的长度为：3.6 Line [p1=Point [x=1, y=3], p2=Point [x=2, y=5]] 此线段的长度为：2.2
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int n = cin.nextInt(); for (int i = 0; i < n; i++) { int x1 = cin.nextInt(); int y1 = cin.nextInt(); int x2 = cin.nextInt(); int y2 = cin.nextInt(); System.out.printf("Line [p1=Point [x=%d, y=%d], p2=Point [x=%d, y=%d]]\n",x1,y1,x2,y2); System.out.printf("此线段的长度为：%.1f\n",Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))); } } }
R7-19 查询某人
有一个人员数组，要在此数组中查询某个人是否存在，具体要求如下：
1.定义Person类：
a 属性 name和age
b 两个属性的getters 和setters
c 带参数构造方法，为name和age给值 以及无参构造方法，给name赋值为none，age赋值为1
d ToString方法
public String toString() { return "Person [name=" + name + ", age=" + age + "]"; }
2.在main方法中，创建Person数组，数组长度通过键盘输入，数组每一个对象的name和age通过键盘给出，创建数组后，首先显示所有人员的信息，然后输入一个姓名，查询数组中有这个人么？如果有，输出这个人的信息，否则输出not found
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。
输入样例:
在这里给出一组输入。例如：
1. 3 2. tian 3 3. jerry 23 4. sun 22 5. su
3 may 51 sunny 23 lily 32 lily
输出样例:
在这里给出相应的输出。例如：
Person [name=tian, age=3] Person [name=jerry, age=23] Person [name=sun, age=22] not found
Person [name=may, age=51] Person [name=sunny, age=23] Person [name=lily, age=32] 查询结果： Person [name=lily, age=32]
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int n = cin.nextInt(); Persion[] p = new Persion[n]; for (int i = 0; i < n; i++) { p[i] = new Persion(cin.next(), cin.nextInt()); System.out.println(p[i].toString()); } String s = cin.next(); for (int i = 0; i < n; i++) { if (s.equals(p[i].name)) { System.out.println("查询结果："); System.out.println(p[i].toString()); System.exit(0); } } System.out.println("not found"); } } class Persion { String name; int age; public Persion(String name, int age) { this.name = name; this.age = age; } public String toString() { return "Person [name=" + name +", age=" + age + "]"; } }
R7-21 集体评分2
程序填空题。请补充以下代码，完成题目要求。（注意：需要提交完整代码） 有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int[] grade = new int[5]; for(int i=0; i<grade.length; i++){ grade[i] = in.nextInt(); } RR rr = new RT(grade); double dd = rr.mark(); System.out.printf("%.2f",dd); } } interface RR{ double mark(); } class RT implements RR{ int[] grade; public RT(int[] grade){ this.grade = grade; } } ———————————————— 版权声明：本文为CSDN博主「真题OK撒」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_51916951/article/details/125396655
输入格式:
在一行中给出5个不超过10的正整数（从小到大排列）。
输出格式:
输出集体评分，保留小数点后两位。
输入样例:
1 2 4 6 9
输出样例:
4.00
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); String l = cin.nextLine(); String[] str = l.split(" "); int[] a = new int[str.length]; int cnt = 0; for (int i = 0; i < str.length; i++) { // System.out.println(str[i]); a[cnt++] = Integer.parseInt(str[i]); } for (int i = 0; i < a.length; i++) { for (int j = 0; j < a.length; j++) { if (a[i] > a[j]) { int t = a[i]; a[i] = a[j]; a[j] = t; } } } double sum = 0; for (int i = 1; i < a.length -1; i++) { // System.out.println(a[i]); sum += a[i]; } System.out.printf("%.2f",sum / (a.length - 2)); } }
R7-26 设计一个Shape及其子类Oval
编写一个完整的Java Application 程序。包含类Shape、类Oval、类ShapeTest，具体要求如下：
(1)编写一个抽象类Shape表示形状对象，包含以下成员
①属性：
PI：double型常数，值为3.1415926；
②方法：
double area(), 抽象方法；
double perimeter()，抽象方法；
(2)编写一个Shape类的子类Oval，表示椭圆对象，包含以下成员
①属性：
a：私有，double型，长轴半径；
b：私有，double型，短轴半径；
②方法：
Oval(double a，double b), 构造方法,用参数设置椭圆的长轴半径和短轴半径
Oval(),构造方法，将椭圆的长轴半径和短轴半径都初始化为0。
double area()，重写Shape类中的area方法，返回椭圆的面积( )
double perimeter()，重写Shape类中的perimeter方法，返回椭圆的周长( )
public String toString( )，将把当前椭圆对象的转换成字符串形式，例如长轴半径为10.0，短轴半径为5，返回字符串"Oval(a:10.0,b:5.0)"。
（3）编写公共类Main,实现如下功能
输入长轴半径和短轴半径，并创建一个椭圆对象；
分别用area和perimeter方法，求出以上椭圆的面积和宽度并输出，输出过程中要求使用到toString方法，输出格式如下：
输入格式:
输入长轴半径和短轴半径
输出格式:
输出椭圆的面积和周长。
输入样例:
8 6
输出样例:
在这里给出相应的输出。例如：
1. The area of Oval(a:8.0,b:6.0) is 150.79644480000002 2. The perimeterof Oval(a:8.0,b:6.0) is 44.42882862370954
import java.util.*; public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); double a = cin.nextDouble(); double b = cin.nextDouble(); Oval o = new Oval(a ,b); o.area(); o.perimeter(); System.out.println(o.toString()); } } abstract class Shape { protected final double PI = 3.1415926; abstract public double area(); abstract public double perimeter(); } class Oval extends Shape{ private double a; private double b; public Oval() { this(0,0); } public Oval(double a, double b) { super(); this.a = a; this.b = b; } // S=π×a×b public double area(){ return this.PI * a * b; } // L=2πb+4(a-b) public double perimeter() { return 2 * this.PI * Math.sqrt((a * a + b * b) / 2); } public String toString() { return "The area of Oval(a:" + a + ",b:" + b + ") is " + area() + "\n" + "The perimeterof Oval(a:" + a + ",b:" + b + ") is " + perimeter(); } }
R7-27 jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
定义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 personList。输入其他字符，则结束创建。
创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable或Comparator
接受输入，如果输入为exit则return退出程序，否则继续下面步骤。
将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。
输出字符串stuList，然后输出stuList中的每个对象。
输出字符串empList，然后输出empList中的每个对象。
1-3为一个测试点
4-6为一个测试点
输入样例：
s zhang 23 false 001 net15 e wang 18 true 3000.51 IBM s zhang 23 false 001 net15 e bo 25 true 5000.51 IBM e bo 25 true 5000.52 IBM e bo 18 true 5000.54 IBM e tan 25 true 5000.56 IBM e tan 25 true 5000.51 IBM s wang 17 false 002 null s wang 17 false 002 null e hua 16 false 1000 null s wang 17 false 002 net16 e hua 16 false 1000 null e hua 18 false 1234 MicroSoft ! continue
输出样例：
Employee:bo-18-true-IBM-5000.54 Employee:bo-25-true-IBM-5000.51 Employee:bo-25-true-IBM-5000.52 Employee:hua-16-false-null-1000.0 Employee:hua-16-false-null-1000.0 Employee:hua-18-false-MicroSoft-1234.0 Employee:tan-25-true-IBM-5000.56 Employee:tan-25-true-IBM-5000.51 Student:wang-17-false-002-null Student:wang-17-false-002-null Student:wang-17-false-002-net16 Employee:wang-18-true-IBM-3000.51 Student:zhang-23-false-001-net15 Student:zhang-23-false-001-net15 stuList Student:wang-17-false-002-null Student:wang-17-false-002-net16 Student:zhang-23-false-001-net15 empList Employee:bo-18-true-IBM-5000.54 Employee:bo-25-true-IBM-5000.51 Employee:hua-16-false-null-1000.0 Employee:hua-18-false-MicroSoft-1234.0 Employee:tan-25-true-IBM-5000.56 Employee:tan-25-true-IBM-5000.51 Employee:wang-18-true-IBM-3000.51
import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Scanner; import static java.lang.System.exit; /** * * @author 梓叶枫林 * @date 2020/11/01 */ public class Main { public static void main (String [] args) { Scanner sc = new Scanner(System.in); List<Person> personList = new ArrayList<>(); //创建对象并放入personList while (true) { String str = sc.next(); if ("s".equals(str)) { //创建Student对象 Student stu = new Student(sc.next(), sc.nextInt(), sc.nextBoolean(), sc.next(), sc.next()); personList.add(stu); } else if ("e".equals(str)) { //创建Employee对象 Employee emp = new Employee(sc.next(), sc.nextInt(), sc.nextBoolean(), sc.nextDouble(), new Company(sc.next())); personList.add(emp); } else { //结束创建 sc.close(); break; } } //排序 Collections.sort(personList); //输出personList for (Person p : personList) { System.out.println(p.toString()); } //判断是否是接下来的输入是否exit String s = sc.next(); if ("exit".equals(s)) { exit(0); } //分类：将personList中的元素按照类型分别放到stuList与empList List<Student> stuList = new ArrayList<>(); List<Employee> empList = new ArrayList<>(); for (int i = 0; i < personList.size(); i++) { Person currentPerson = personList.get(i); if (currentPerson instanceof Student) { if (stuList.isEmpty()) { stuList.add( (Student) currentPerson); } else if (!stuList.get(stuList.size()-1).equals(currentPerson)){ stuList.add((Student) currentPerson); } } else if (personList.get(i) instanceof Employee) { if (empList.isEmpty()) { empList.add((Employee) currentPerson); } else if (!empList.get(empList.size()-1).equals(currentPerson)) { empList.add((Employee) currentPerson); } } } //输出stuList System.out.println("stuList"); for (Student stu : stuList) { System.out.println(stu.toString()); } //输出empList System.out.println("empList"); for (Employee emp : empList) { System.out.println(emp.toString()); } } } abstract class Person implements Comparable<Person> { String name; int age; boolean gender; public Person(String name, int age, boolean gender) { this.name = name; this.age = age; this.gender = gender; } @Override public String toString() { return name + "-" + age + "-" + gender; } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (obj instanceof Person) { Person p = (Person) obj; return name.equals(p.name) && age == p.age && gender == p.gender; } return false; } @Override public int compareTo (Person p) { int temp = this.name.compareTo(p.name); return temp == 0 ? this.age - p.age : temp; } } 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:" + name + "-" + age + "-" + gender + "-" + stuNo + "-" + clazz; } @Override public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } if (obj instanceof Student) { Student stu = (Student) obj; return stuNo.equals(stu.stuNo) && clazz.equals(stu.clazz); } return false; } } class Company { String name; public Company(String name) { this.name = name; } @Override public String toString() { return name; } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (obj instanceof Company) { Company c = (Company) obj; return name.equals(c.name); } return false; } } class Employee extends Person { Company company; double salary; public Employee(String name, int age, boolean gender, double salary, Company company) { super(name, age, gender); this.salary = salary; this.company = company; } @Override public String toString() { return "Employee:" + name + "-" + age + "-" + gender + "-" + company + "-" + salary; } @Override public boolean equals(Object obj) { if (!super.equals(obj)) { return false; } //salary保留一位小数 DecimalFormat df = new DecimalFormat("#.#"); if (obj instanceof Employee) { Employee employee = (Employee) obj; return company.equals(employee.company) && df.format(salary).equals(df.format(employee.salary)); } return false; } }
R7-29 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类
定义类ArrayUtils，在该类内部创建一个静态嵌套类PairResult，该嵌套类包含：
属性: private double min与private double max，用于存放最小值最大值
方法：toString方法，格式见下面的输出样例。
为ArrayUtils类创建一个静态方法PairResult findMinMax(double[] values)，对传递进来的数组找到其中的最大值和最小值并返回PairResult对象。
main方法说明
- 输入n，创建大小为n的double型数组
- 依次输入n个double型数值放入数组
- 调用findMinMax方法得到结果，并输出。
- 最后使用
System.out.println(ArrayUtils.PairResult.class)打印标识信息
输入样例
5 0 -1 1 1.1 1.1
输出样例
1. PairResult [min=-1.0, max=1.1] 2. \\这里打印标识
import java.util.*; public class Main { public static void main(String[] args) { Scanner in=new Scanner(System.in); int n=in.nextInt(); double s[]=new double[n];//为什么不用ArrayUtils[]s=new ArrayUtils[n];因为是double数组 for(int i=0;i<s.length;i++) { double m=in.nextDouble(); s[i]=m; } ArrayUtils l=new ArrayUtils(); double max=s[0]; double min=s[0]; System.out.println(l.findMinMax(s).toString()); System.out.println(ArrayUtils.PairResult.class); } } class ArrayUtils{ static PairResult findMinMax(double[] s) { PairResult b=new PairResult(); double min=s[0]; double max=s[0]; for(int i=0;i<s.length;i++) { if(s[i]>max) { max=s[i]; } else if(s[i]<min) { min=s[i]; } } b.setMax(max); b.setMin(min); return b; } static class PairResult{ private double min; private double max; @Override public String toString() { return "PairResult [min=" + min + ", max=" + max + "]"; } public void setMin(double min) { this.min = min; } public void setMax(double max) { this.max = max; } } }
