百木园- 期中考试题目总结
（1）总结：期中考试主要考察的是点线面类的设计，之前没有接触过类，或者说对类没有什么很清晰的概念和认知。现在才发现“类”是一个非常强大的工具，可以大大方便我们平时解决问题的过程。期中考试这几道题目难度适中，很适合我们平时拿来练手，不过也需要抓住各种细节，以防出现一些不该出现的错误。
（2）
1、7-1 点与线（类设计）
设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息，格式如下：(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则直接输出Wrong Format
设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息，输出格式如下：
The line\'s color is:颜色值
The line\'s begin point\'s Coordinate is:
(x1,y1)
The line\'s end point\'s Coordinate is:
(x2,y2)
The line\'s length is:长度值
其中，所有数值均保留两位小数，建议可用String.format(\"%.2f\", data)方法。
设计类图如下图所示。
** 题目要求：在主方法中定义一条线段对象，从键盘输入该线段的起点坐标与终点坐标以及颜色，然后调用该线段的display()方法进行输出。**
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
The line\'s color is:颜色值
The line\'s begin point\'s Coordinate is:
(x1,y1)
The line\'s end point\'s Coordinate is:
(x2,y2)
The line\'s length is:长度值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
The line\'s color is:Red
The line\'s begin point\'s Coordinate is:
(5.00,9.40)
The line\'s end point\'s Coordinate is:
(12.30,84.00)
The line\'s length is:74.96
输入样例2:
在这里给出一组输入。例如：
80.2356
352.12
24.5
100
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
我的代码如下：
点击查看代码
package pta.mid_term_examination;
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main1 {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
Point point1=new Point();
double x1=in.nextDouble();
double y1=in.nextDouble();
point1.setX(x1);
point1.setY(y1);
Point point2=new Point();
double x2=in.nextDouble();
double y2=in.nextDouble();
point2.setX(x2);
point2.setY(y2);
//double a=x1*x1-x2*x2;
//double b=y1*y1-y2*y2;
//double dis=Math.sqrt(a+b);
String color=in.next();
Line line=new Line();
line.setPoint1(point1);
line.setPoint2(point2);
line.setColor(color);
if ((x1<=0||x1>200)||(y1<=0||y1>200)||(x2<=0||x2>200)||(y2<=0||y2>200))
System.out.println(\"Wrong Format\");
else line.display();
}
}
class Point{
private double x;//横坐标
private double y;//纵坐标
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public Point() {
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public void display(){
DecimalFormat two=new DecimalFormat(\"0.00\");
System.out.println(\"(\"+two.format(getX())+\",\"+two.format(getY())+\")\");
}
}
class Line{
private Point point1 = new Point();
private Point point2 = new Point();
String color;
public Line(Point point1, Point point2, String color) {
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public Line() {
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance(Point p1,Point p2){
double a=p1.getX()-p2.getX();
double b=p1.getY()-p2.getY();
return Math.sqrt(a*a+b*b);
}
public void display(){
Line line=new Line();
DecimalFormat two=new DecimalFormat(\"0.00\");
System.out.println(\"The line\'s color is:\"+getColor());
System.out.println(\"The line\'s begin point\'s Coordinate is:\");
point1.display();
System.out.println(\"The line\'s end point\'s Coordinate is:\");
point2.display();
System.out.println(\"The line\'s length is:\" + two.format(line.getDistance(point1,point2)));
}
}
本题把我困扰住的地方是Line类里面的getDistance方法
public double getDistance(Point p1,Point p2){
double a=p1.getX()-p2.getX();
double b=p1.getY()-p2.getY();
return Math.sqrt(a*a+b*b);
}
这里一开始我并没有添加函数括号里面的参数，导致后面运行的时候一直显示的不是正确的答案，而是一直显示0.00。
在括号中加上参数并在其它地方做出一些修改，最后的问题才得以解决。
在这里我知道了仔细观察题目和平时基础的重要性，这大大影响了我做题时候的思考方式和速度。
2、7-2 点线面问题重构（继承与多态）
在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。
对题目中的点Point类和线Line类进行进一步抽象，定义一个两个类的共同父类Element（抽象类），将display()方法在该方法中进行声明（抽象方法），将Point类和Line类作为该类的子类。
再定义一个Element类的子类面Plane，该类只有一个私有属性颜色color，除了构造方法和属性的getter、setter方法外，display()方法用于输出面的颜色，输出格式如下：The Plane\'s color is:颜色
在主方法内，定义两个Point（线段的起点和终点）对象、一个Line对象和一个Plane对象，依次从键盘输入两个Point对象的起点、终点坐标和颜色值（Line对象和Plane对象颜色相同），然后定义一个Element类的引用，分别使用该引用调用以上四个对象的display()方法，从而实现多态特性。示例代码如下：
element = p1;//起点Point
element.display();
element = p2;//终点Point
element.display();
element = line;//线段
element.display();
element = plane;//面
element.display();
类结构如下图所示。
其中，所有数值均保留两位小数，建议可用String.format(\"%.2f\", data)方法。
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
(x1,y1)
(x2,y2)
The line\'s color is:颜色值
The line\'s begin point\'s Coordinate is:
(x1,y1)
The line\'s end point\'s Coordinate is:
(x2,y2)
The line\'s length is:长度值
The Plane\'s color is:颜色值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
(5.00,9.40)
(12.30,84.00)
The line\'s color is:Red
The line\'s begin point\'s Coordinate is:
(5.00,9.40)
The line\'s end point\'s Coordinate is:
(12.30,84.00)
The line\'s length is:74.96
The Plane\'s color is:Red
输入样例2:
在这里给出一组输入。例如：
5
9.4
12.3
845
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
以下是我的代码：
点击查看代码
package pta.mid_term_examination;
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
Point1 p1=new Point1();
double x1=in.nextDouble();
double y1=in.nextDouble();
p1.setX(x1);
p1.setY(y1);
Point1 p2=new Point1();
double x2=in.nextDouble();
double y2=in.nextDouble();
p2.setX(x2);
p2.setY(y2);
String color=in.next();
Line1 line=new Line1();
line.setPoint1(p1);
line.setPoint2(p2);
line.setColor(color);
Plane plane=new Plane();
plane.setColor(color);
Element element=new Element() {
@Override
public void display() {
}
};
if ((x1<=0||x1>200)||(y1<=0||y1>200)||(x2<=0||x2>200)||(y2<=0||y2>200))
System.out.println(\"Wrong Format\");
else{
element = p1;//起点Point
element.display();
element = p2;//终点Point
element.display();
element = line;//线段
element.display();
element = plane;//面
element.display();
}
}
}
abstract class Element{
public abstract void display();
}
class Point1 extends Element{
private double x;//横坐标
private double y;//纵坐标
public Point1(double x, double y) {
this.x = x;
this.y = y;
}
public Point1() {
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public void display(){
DecimalFormat two=new DecimalFormat(\"0.00\");
System.out.println(\"(\"+two.format(this.x)+\",\"+two.format(this.y)+\")\");
}
}
class Line1 extends Element{
private Point1 point1 = new Point1();
private Point1 point2 = new Point1();
String color;
public Line1(Point1 point1, Point1 point2, String color) {
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public Line1() {
}
public Point1 getPoint1() {
return point1;
}
public void setPoint1(Point1 point1) {
this.point1 = point1;
}
public Point1 getPoint2() {
return point2;
}
public void setPoint2(Point1 point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance(Point1 p1,Point1 p2){
double a=p1.getX()-p2.getX();
double b=p1.getY()-p2.getY();
return Math.sqrt(a*a+b*b);
}
public void display(){
Line1 line=new Line1();
DecimalFormat two=new DecimalFormat(\"0.00\");
System.out.println(\"The line\'s color is:\"+getColor());
System.out.println(\"The line\'s begin point\'s Coordinate is:\");
point1.display();
System.out.println(\"The line\'s end point\'s Coordinate is:\");
point2.display();
System.out.println(\"The line\'s length is:\" + two.format(line.getDistance(point1,point2)));
}
}
class Plane extends Element{
private String color;
public Plane(String color) {
this.color = color;
}
public Plane() {
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void display(){
System.out.println(\"The Plane\'s color is:\"+this.color);
}
}
第二次作业是在第一次作业的基础上加上了继承与多态的运用，继承和多态是我们Java学习中非常非常非常重要的两个知识点，它们有以下好处：
使用继承的好处是父类的内部细节对子类可见
使用多态可以使程序有良好的扩展，并可以对所有类的对象进行通用处理
使用继承和多态可以增强我们代码的灵活性，接口性，可扩充性，也可以消除类型之间的耦合关系。
第二次作业除了加上了继承和多态等操作，还定义了抽象类，这也是一个新的知识，抽象类加上抽象方法。咋一听很吓人，但是只要我们去仔细阅读题目要求，仔细审题，然后再看，就可以有更多的体会以及解题思路。
3、7-3 点线面问题再重构（容器类）
在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList类型的对象（若不了解泛型，可以不使用）
增加该类的add()方法及remove(int index)方法，其功能分别为向容器中增加对象及删除第index - 1（ArrayList中index>=0）个对象
在主方法中，用户循环输入要进行的操作（choice∈[0,4]），其含义如下：
1：向容器中增加Point对象
2：向容器中增加Line对象
3：向容器中增加Plane对象
4：删除容器中第index - 1个数据，若index数据非法，则无视此操作
0：输入结束
示例代码如下：
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
...
break;
case 2://insert Line object into list
...
break;
case 3://insert Plane object into list
...
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
...
}
choice = input.nextInt();
}
输入结束后，按容器中的对象顺序分别调用每个对象的display()方法进行输出。
类图如下所示：
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
switch(choice) {
case 1://insert Point object into list
输入“点”对象的x，y值
break;
case 2://insert Line object into list
输入“线”对象两个端点的x，y值
break;
case 3://insert Plane object into list
输入“面”对象的颜色值
break;
case 4://delete index - 1 object from list
输入要删除的对象位置（从1开始）
...
}
输出格式:
Point、Line、Plane的输出参考题目2
删除对象时，若输入的index超出合法范围，程序自动忽略该操作
输入样例:
在这里给出一组输入。例如：
1
3.4
5.6
2
4.4
8.0
0.98
23.888
Red
3
Black
1
9.8
7.5
3
Green
4
3
0
输出样例:
在这里给出相应的输出。例如：
(3.40,5.60)
The line\'s color is:Red
The line\'s begin point\'s Coordinate is:
(4.40,8.00)
The line\'s end point\'s Coordinate is:
(0.98,23.89)
The line\'s length is:16.25
(9.80,7.50)
The Plane\'s color is:Green
题目代码如下：
点击查看代码
package pta.mid_term_examination;
import java.util.ArrayList;
import java.util.Scanner;
abstract class Element3 {
public abstract void display();
}
class Plane3 extends Element3 {
private String color;
public Plane3() {
super();
// TODO Auto-generated constructor stub
}
public Plane3(String color) {
super();
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println(\"The Plane\'s color is:\" + this.color);
}
}
class Point3 extends Element3{
private double x,y;
public Point3(){
}
public Point3(double x,double y){
this.x = x;
this.y = y;
}
public double getX(){
return this.x;
}
public void setX(double x){
this.x = x;
}
public double getY(){
return this.y;
}
public void setY(double y){
this.y = y;
}
@Override
public void display(){
System.out.println(\"(\" + String.format(\"%.2f\", x) + \",\" + String.format(\"%.2f\",y) + \")\");
}
}
class Line3 extends Element3{
private Point3 point1,point2;
private String color;
public Line3(){
}
public Line3(Point3 p1,Point3 p2,String color){
this.point1 = p1;
this.point2 = p2;
this.color = color;
}
public Point3 getPoint1() {
return point1;
}
public void setPoint1(Point3 point1) {
this.point1 = point1;
}
public Point3 getPoint2() {
return point2;
}
public void setPoint2(Point3 point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance(){
return Math.sqrt(Math.pow(this.point1.getX() - this.point2.getX(), 2) +
Math.pow(this.getPoint1().getY() - this.getPoint2().getY(), 2));
}
@Override
public void display(){
System.out.println(\"The line\'s color is:\" + this.getColor());
System.out.println(\"The line\'s begin point\'s Coordinate is:\");
this.getPoint1().display();
System.out.println(\"The line\'s end point\'s Coordinate is:\");
this.getPoint2().display();
System.out.println(\"The line\'s length is:\" + String.format(\"%.2f\", this.getDistance()));
}
}
class GeometryObject{
private ArrayList<Element3> list = new ArrayList<>();
public GeometryObject() {
}
public void add(Element3 element) {
list.add(element);
}
public void remove(int index) {
if(index < 1 || index > list.size()) {
return;
}
list.remove(index - 1);
}
public ArrayList<Element3> getList(){
return this.list;
}
}
public class Main3 {
public static void main(String[] args) {
double x1,y1,x2,y2;
String color;
Scanner input = new Scanner(System.in);
int choice = 0,index = 0;
GeometryObject container = new GeometryObject();
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1:
x1 = input.nextDouble();
y1 = input.nextDouble();
container.add(new Point3(x1,y1));
break;
case 2:
x1 = input.nextDouble();
y1 = input.nextDouble();
x2 = input.nextDouble();
y2 = input.nextDouble();
color = input.next();
container.add(new Line3(new Point3(x1,y1),new Point3(x2,y2),color));
break;
case 3:
color = input.next();
container.add(new Plane3(color));
break;
case 4:
index = input.nextInt();
container.remove(index);
break;
}
choice = input.nextInt();
}
for(Element3 element:container.getList()) {
element.display();
}
}
}
第三题是本次期中考试难度最大的一题，因为加上了容器类和泛型的应用，从上面的类图我们也可以发现类图也是明显比前两题要复杂很多。
所以当时考试的时候由于时间问题，这题我并没有解决，后面看了老师发的源码才有了些许体会。
- PTA第4次大作业总结
1、7-1 sdut-String-2 识蛟龙号载人深潜，立科技报国志（II）（正则表达式）
背景简介：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为7000米级，也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用，对于我国开发利用深海的资源有着重要的意义。
中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中，“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘，其中下潜深度超过1000米的仅有12艘，更深的潜水器数量更少，目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外，其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米，因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底，创造了作业类载人潜水器新的世界纪录。
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日，“蛟龙”出征以来，已经连续书写了5个“中国深度”新纪录：6月15日，6671米；6月19日，6965米；6月22日，6963米；6月24日，7020米；6月27日，7062米。下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力，标志着“蛟龙”载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一，标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。
‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备，更代表了一种精神，一种不畏艰险、赶超世界的精神，它是中华民族进军深海的号角。
了解蛟龙号”载人深潜器“的骄人业绩，为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪，小伙伴们与祖国同呼吸、共命运，一定要学好科学文化知识、提高个人能力，增强创新意识，做事精益求精，立科技报国之志！
请编写程序，实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。
提示 若输入为“2012年2月”，则该行的输出为：2014。若干个连续的数字字符作为一个整体，以十进制形式相加。
输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过80个字符。
以\"end\"结束。
输出格式:
与输入行相对应的各个整数之和。
输入样例1:
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日，6671米
6月19日，6965米
6月22日，6963米
6月24日，7020米
6月27日，7062米
下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
9165
6692
6990
6991
7050
7095
7099
输入样例2:
全世界投入使用的各类载人潜水器约90艘，下潜深度超过1000米的仅有12艘，更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米，蛟龙号在马里亚纳海沟海试成功到达7020米海底，创造了新的世界纪录
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
1102
6000
13547
20021
7000
代码如下：
点击查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
while (true){
String str = in.nextLine();
String[] s = str.split(\"\\\\D+\");
// \\\\d表示数字 \\\\D表示所有非数字字符，加上+号表示一个或多个
int sum = 0;//用于计算总和
int count = 0;//用于统计每一行被强制转化的字符串
if (str.equals(\"end\"))
break;
for (int i = 0;i < s.length;i++){
if (!s[i].equals(\"\")){
count = Integer.parseInt(s[i]);
sum += count;
}
}
System.out.println(sum);
}
}
}
踩坑心得：Java spilt方法的使用和next()与nextLine()的区别
String[] s = str.split(\"\\D+\");
// \\d表示数字 \\D表示所有非数字字符，加上+号表示一个或多个
nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
next（）会自动消去有效字符前的空格，只返回输入的字符，不能得到带空格的字符串。
（简单点说，next我只要字，nextLine我啥都要）
2、7-2 点线形系列4-凸四边形的计算
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出\"not a quadrilateral\"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出\"not a quadrilateral\"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出\"The line is coincide with one of the lines\"。若后四个点不符合四边形或三角形的输入，输出\"not a quadrilateral or triangle\"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出\"on the triangle或者on the quadrilateral\"。若后四个点不符合四边形或三角形，输出\"not a quadrilateral or triangle\"。
输入格式:
基本格式：选项+\":\"+坐标x+\",\"+坐标y+\" \"+坐标x+\",\"+坐标y。点的x、y坐标之间以英文\",\"分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出\"Wrong Format\"。
如果符合基本格式，但输入点的数量不符合要求，输出\"wrong number of points\"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出\"points coincide\"。
选项4中，若前两个输入线的点重合，输出\"points coincide\"。
输入样例1:
选项1，点重合。例如：
1:-1,-1 -1,-1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
points coincide
输入样例2:
不符合基本格式。例如：
1:-1,-1 1,2 -1,1 ++1,0
输出样例:
在这里给出相应的输出。例如：
Wrong Format
输入样例3:
选项1，输入点数量不对。例如：
1:-1,-1 -1,2
输出样例:
在这里给出相应的输出。例如：
wrong number of points
输入样例4:
选项1，正确输入判断。例如：
1:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true false
输入样例5:
选项2，输入点不构成四边形。例如：
2:10,10 1,1 0,0 1,20
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例6:
选项2，正方形。例如：
2:0,0 0,80 80,80 80,0
输出样例:
在这里给出相应的输出。例如：
true true true
输入样例7:
选项2。例如：
2:0,0 -10,80 0,160 -10,80
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例8:
选项3，凸四边形。例如：
3:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true 10.472 6.0
输入样例9:
选项3，。例如：
3:0,0 -10,100 0,99 10,100
输出样例:
在这里给出相应的输出。例如：
false 221.097 990.0
我的代码：
点击查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
String str = in.nextLine();
boolean flag = true;
String regStr = \"[\\\\-\\\\+]?\\\\d+(\\\\.\\\\d+)?,[\\\\-\\\\+]?\\\\d+(\\\\.\\\\d+)?(\\\\s[\\\\-\\\\+]?\\\\d+(\\\\.\\\\d+)?,[\\\\-\\\\+]?\\\\d+(\\\\.\\\\d+)?\\\\s?){0,}\";
if (str.length() > 2){
String str1 = str.substring(0,1);
String str2 = str.substring(2,str.length());
if (str2.matches(regStr))
flag = true;
else flag = false;
if (!flag) {
System.out.println(\"Wrong Format\");
return;
}else {
String[] s = str2.split(\",|\\\\s\");
for (int i = 0;i < s.length;i++){
if (s[i].matches(\"0\\\\d+\"))
System.out.println(\"Wrong Format\");
}
Quadrilateral qua = new Quadrilateral(Double.parseDouble(s[0]),Double.parseDouble(s[1]),Double.parseDouble(s[2]),Double.parseDouble(s[3]),Double.parseDouble(s[4]),Double.parseDouble(s[5]),Double.parseDouble(s[6]),Double.parseDouble(s[7]));
if (qua.isCoincide()){
System.out.println(\"points coincide\");
return;
}else System.out.println(qua.isQuadrilateral()+\" \"+qua.isParallelogram());
if (!qua.isQuadrilateral())
System.out.println(\"not a quadrilateral\");
else System.out.println(qua.isDiamond()+\" \"+qua.isRectangle()+\" \"+qua.isSquare());
}
}
}
}
class Quadrilateral{
//定义四边形类
private double x1,y1,x2,y2,x3,y3,x4,y4;
public Quadrilateral(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.x3 = x3;
this.y3 = y3;
this.x4 = x4;
this.y4 = y4;
}
public Quadrilateral() {
super();
}
public double getX1() {
return x1;
}
public void setX1(double x1) {
this.x1 = x1;
}
public double getY1() {
return y1;
}
public void setY1(double y1) {
this.y1 = y1;
}
public double getX2() {
return x2;
}
public void setX2(double x2) {
this.x2 = x2;
}
public double getY2() {
return y2;
}
public void setY2(double y2) {
this.y2 = y2;
}
public double getX3() {
return x3;
}
public void setX3(double x3) {
this.x3 = x3;
}
public double getY3() {
return y3;
}
public void setY3(double y3) {
this.y3 = y3;
}
public double getX4() {
return x4;
}
public void setX4(double x4) {
this.x4 = x4;
}
public double getY4() {
return y4;
}
public void setY4(double y4) {
this.y4 = y4;
}
public boolean isCoincide(){
//判断四边形的点是否重合的函数
if((x1==x2&&y1==y2)||(x2==x3&&y2==y3)||(x3==x4&&y3==y4)||(x4==x1&&y4==y1))
return true;
return false;
}
public boolean isQuadrilateral(){
//判断是否为四边形
Line a1 = new Line(x2,y2,x3,y3,x1,y1,x4,y4);
Line a2 = new Line(x4,y4,x3,y3,x1,y1,x2,y2);
if((x1==x3&&y1==y3)||(x2==x4&&y2==y4)||(x1==x2&&y1==y2)||(x4==x3&&y4==y3)||a1.three()||a2.three())
return false;
else if((x1==x2&&x1==x3)||(x1==x2&&x1==x4)||(x1==x3&&x1==x4)||(x3==x2&&x3==x4))
return false;
else if(Math.abs((y1-y2)/(x1-x2)-(y1-y3)/(x1-x3))<0.01||Math.abs((y1-y2)/(x1-x2)-(y1-y4)/(x1-x4))<0.01||Math.abs((y1-y4)/(x1-x4)-(y1-y3)/(x1-x3))<0.01||Math.abs((y3-y2)/(x3-x2)-(y2-y4)/(x2-x4))<0.01)
return false;
else return true;
}
public boolean isParallelogram() {
//判断是否为平行四边形
if(isQuadrilateral()) {
if((x1==x2&&x3==x4||(y1-y2)/(x1-x2)==(y4-y3)/(x4-x3))&&(x3==x2&&x1==x4||(y3-y2)/(x3-x2)==(y4-y1)/(x4-x1)))
return true;
else return false;
}
else return false;
}
public boolean isDiamond() {
//判断是否为菱形
if(isParallelogram()) {
if(((y1==y3&&x2==x4)||(y2==y4&&x1==x3))||(((y1-y3)/(x1-x3))*((y4-y2)/(x4-x2))==-1)) return true;
else return false;
}
else return false;
}
public boolean isRectangle() {
//判断是否为矩形
if(isParallelogram()) {
if((x1==x2&&y2==y3)||(y1==y2&&x2==x3)||((y1-y2)/(x1-x2))*((y3-y2)/(x3-x2))==-1) return true;
else return false;
}
else return false;
}
public boolean isSquare() {
//判断是否为正方形
if(isRectangle()&&isDiamond()) return true;
else return false;
}
public boolean isBump() {
//判断是否为凸四边形
double x = -((x2-x4)*(x3*y1-x1*y3)-(x1-x3)*(x4*y2-x2*y4))/((y2-y4)*(x1-x3)-(y1-y3)*(x2-x4));
double y = -((y2-y4)*(y3*x1-y1*x3)-(y1-y3)*(y4*x2-y2*x4))/((x2-x4)*(y1-y3)-(x1-x3)*(y2-y4));
if ((((x>=x3&&x<=x1)||(x<=x3&&x>=x1))&&((y>=y3&&y<=y1)||(y<=y3&&y>=y1)))&&(((x>=x2&&x<=x4)||(x<=x2&&x>=x4))&&((y>=y2&&y<=y4)||(y<=y2&&y>=y4))))
return true;
else return false;
}
}
class Line{
//定义直线类
private double x1,y1,x2,y2,x3,y3,x4,y4;
public Line() {
super();
}
public Line(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
super();
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.x3 = x3;
this.y3 = y3;
this.x4 = x4;
this.y4 = y4;
}
public double getX1() {
return x1;
}
public void setX1(double x1) {
this.x1 = x1;
}
public double getY1() {
return y1;
}
public void setY1(double y1) {
this.y1 = y1;
}
public double getX2() {
return x2;
}
public void setX2(double x2) {
this.x2 = x2;
}
public double getY2() {
return y2;
}
public void setY2(double y2) {
this.y2 = y2;
}
public double getX3() {
return x3;
}
public void setX3(double x3) {
this.x3 = x3;
}
public double getY3() {
return y3;
}
public void setY3(double y3) {
this.y3 = y3;
}
public double getX4() {
return x4;
}
public void setX4(double x4) {
this.x4 = x4;
}
public double getY4() {
return y4;
}
public void setY4(double y4) {
this.y4 = y4;
}
public boolean isCoincide(){
if(Math.abs((y4-y3)*x1+(x3-x4)*y1+x4*y3-y4*x3)/Math.sqrt((y4-y3)*(y4-y3)+(x4-x3)*(x4-x3))<0.01&&(Math.abs((y1-y2)/(x1-x2)-(y3-y4)/(x3-x4))<0.01||((x1==x2)&&(x3==x4))))
return true;
else return false;
}
public boolean three(){
//小数点后三位
double x = -((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4));
double y = -((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4));
if(Math.abs((y1-y2)/(x1-x2)-(y3-y4)/(x3-x4))<0.01)
return false;
else if (((x>=x3&&x<=x4)||(x<=x3&&x>=x4))&&((y>=y3&&y<=y4)||(y<=y3&&y>=y4))&&((x>=x1&&x<=x2)||(x<=x1&&x>=x2))&&((y>=y1&&y<=y2)||(y<=y1&&y>=y2)))
return true;
else return false;
}
}
需要注意的地方：小数点的位数以及错误的情况
3、7-3 设计一个银行业务类
编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。
编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额
输出格式:
中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！
输入样例:
在这里给出一组输入。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
张三 123456
123456 1000
654321 2000
123456 2000
123456 500
输出样例:
在这里给出相应的输出。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
中国银行欢迎您的到来！
您的余额有1000.0元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有500.0元。
请收好您的证件和物品，欢迎您下次光临！
我的代码如下：
点击查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
String name = in.next();//账户名
int input = in.nextInt();//密码
BankBusiness bank = new BankBusiness(name,input);
int rightPassword = in.nextInt();//正确密码
double save = in.nextDouble();//存款金额
int wrongPassword = in.nextInt();//错误密码
double withdrawal = in.nextDouble();//取款金额
int right1 = in.nextInt();//取款金额大于余额时的正确密码
double withdrawal1 = in.nextDouble();//取款金额（大于余额）
int right2 = in.nextInt();//取款金额小于余额时的正确密码
double withdrawal2 = in.nextDouble();//取款金额（小于余额）
BankBusiness.welcome();//直接用类名调用静态方法
bank.deposit(rightPassword,save);
bank.withdraw(wrongPassword,withdrawal);
bank.withdraw(right1,withdrawal1);
bank.withdraw(right2,withdrawal2);
BankBusiness.welcomeNext();
}
}
class BankBusiness{
//编写一个银行业务类
public static String bankName = \"中国银行\";//银行名称
private String name;//账户名
private int password;//密码
private double balance;//账户余额
public BankBusiness(String name, int password) {
super();
this.name = name;
this.password = password;
balance =0;
}
public static void welcome(){
System.out.println(bankName + \"欢迎您的到来！\");
}
public static void welcomeNext() {
System.out.println(\"请收好您的证件和物品，欢迎您下次光临！\");
}
public void deposit(int input,double save){
//参数是用户输入的密码和存款
if (input != password)
System.out.println(\"您的密码错误！\");
else {
balance = balance + save;
System.out.println(\"您的余额有\" + balance + \"元。\");
}
}
public void withdraw(int input,double withdrawal){
//参数是用户输入的密码和取款
if (input != password)
System.out.println(\"您的密码错误！\");
else{
if (balance < withdrawal)
System.out.println(\"您的余额不足！\");
else {
balance = balance - withdrawal;
System.out.println(\"请取走钞票，您的余额还有\" + balance + \"元。\");
}
}
}
}
本题比较简单，我们需要提高代码的效率。
3.PTA第5次大作业总结
1、7-1 点线形系列5-凸五边形的计算-1
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入五个点坐标，判断是否是五边形，判断结果输出true/false。
2：输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形，输出\"not a pentagon\"
3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形相交的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，输出\"The line is coincide with one of the lines\"。若后五个点不符合五边形输入，若前两点重合，输出\"points coincide\"。
以上3选项中，若输入的点无法构成多边形，则输出\"not a polygon\"。输入的五个点坐标可能存在冗余，假设多边形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z不与xy都相邻，如：z x y s、x z s y、x s z y
输入格式:
基本格式：选项+\":\"+坐标x+\",\"+坐标y+\" \"+坐标x+\",\"+坐标y。点的x、y坐标之间以英文\",\"分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出\"Wrong Format\"。
如果符合基本格式，但输入点的数量不符合要求，输出\"wrong number of points\"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
输入样例1:
选项1，点重合。例如：
1:-1,-1 1,2 -1,1 1,0
输出样例:
在这里给出相应的输出。例如：
wrong number of points
点击查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
String str = in.nextLine();
String[] s = str.split(\" \");//将字符串按照空格分开，便于后面判断格式合法的坐标点数量
boolean flag = true;
String regStr = \"([\\\\+\\\\-]?([0]|[1-9]+))(\\\\.\\\\d+)?\\\\,([\\\\+\\\\-]?([0]|[1-9]+))(\\\\.\\\\d+)?(\\\\s([\\\\+\\\\-]?([0]|[1-9]+))(\\\\.\\\\d+)?\\\\,([+\\\\-]?([0]|[1-9]+))(\\\\.\\\\d+)?)+\";
if (str.matches(regStr))
flag = true;
else flag = false;
if (!flag){
System.out.println(\"Wrong Format\");
return;
}else {
if (s.length != 2)
System.out.println(\"wrong number of points\");
else {
String[] s1 = s[0].split(\",\");
String[] s2 = s[1].split(\",\");
double x1 = Double.parseDouble(s1[0]);
double y1 = Double.parseDouble(s1[1]);
double x2 = Double.parseDouble(s2[0]);
double y2 = Double.parseDouble(s2[1]);
//double x1 = Double.parseDouble(String.valueOf(str.charAt(0)));//取出字符串第一个字符强制转化为double
//double y1 = str.charAt(2);
//double x2 = str.charAt(5);
//double y2 = str.charAt(7);
double a = x1 - x2;
double b = y1 - y2;
//System.out.println(x1);
System.out.println(Math.sqrt(a*a+b*b));
}
}
}
}
本次作业难度很大，超出了我的能力范围。
来源：https://www.cnblogs.com/zsl-236236/p/16276465.html
本站部分图文来源于网络，如有侵权请联系删除。