(1)前言:总结之前所涉及到的知识点、题量、难度等情况
这两次pta继续是点线型系列,由上次的三角形继续加边变成四边形和五边形,期中考试是点线类的测试,不算很难。每次题目看着很多其实都是层层推进都是为下一题做准备。
(2)设计与分析:重点对题目的提交源码进行分析,可参考SourceMonitor的生成报表内容以及PowerDesigner的相应类图,要有相应的解释和心得(做到有图有真相),本次Blog必须分析PTA中的图形类设计的题目、超星中链表类练习题目以及期中考试的三道题目
题目集四:
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。若干个连续的数字字符作为一个整体,以十进制形式相加。
代码:
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String line = in.nextLine();
Pattern panduan = Pattern.compile("\\d+");
int sum;
while(!line.equals("end"))
{
Matcher shuzi = panduan.matcher(line);
sum = 0;
while (shuzi.find())
sum += Integer.valueOf(shuzi.group());
System.out.println(sum);
line = in.nextLine();
}
}
}
这道题没什么多说的,就是一个正则表达式的判断然后取出来数字相加就可以了。
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"。
代码:
import java.math.BigDecimal;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
quadrilateral q = new quadrilateral();
Scanner a = new Scanner(System.in);
String zifu, b, c, dian[];
double x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6;
int xh, geshu = 1;
zifu = a.nextLine();
b = zifu.substring(2, zifu.length());
c = zifu.substring(1, 2);
String strarray[] = b.split(" ");
xh = Integer.parseInt(zifu.substring(0, 1));
if (c.equals(":"))
;
else {
System.out.println("Wrong Format");
return;
}
for (int i = 0; i < strarray.length; i++) {
String[] z = new String[10];
z = strarray[i].split(",");
if (z.length != 2) {
System.out.println("Wrong Format");
return;
}
for (int o = 0; o < 2; o++) {
if (!z[o].matches("[-+]?(0|(0\\.\\d+)?|[1-9]\\d*(\\.\\d+)?)")) {
System.out.print("Wrong Format");
System.exit(0);
}
}
}
if (xh >= 1 && xh <= 3) {
if (strarray.length != 4) {
System.out.print("wrong number of points");
System.exit(0);
}
}
if (xh == 4) {
if (strarray.length != 6) {
System.out.print("wrong number of points");
System.exit(0);
}
}
if (xh == 5) {
if (strarray.length != 5) {
System.out.print("wrong number of points");
System.exit(0);
}
}
if (xh < 1 || xh > 5) {
System.out.print("Wrong Format");
System.exit(0);
}
Dian[] points = new Dian[strarray.length];
for (int i = 0; i < points.length; i++) {
Dian d = new Dian();
points[i] = d;
String[] zuobiao1 = strarray[i].split(",");
points[i].x = Double.parseDouble(zuobiao1[0]);
points[i].y = Double.parseDouble(zuobiao1[1]);
}
if (xh == 1) {
if ((points[0].x == points[1].x && points[0].y == points[1].y) ||
(points[0].x == points[2].x && points[0].y == points[2].y) ||
(points[0].x == points[3].x && points[0].y == points[3].y) ||
(points[1].x == points[2].x && points[1].y == points[2].y) ||
(points[3].x == points[1].x && points[3].y == points[1].y) ||
(points[2].x == points[3].x && points[2].y == points[3].y)) {
System.out.print("points coincide");
return;
}
Dian A = new Dian(points[0].x, points[0].y);
Dian B = new Dian(points[1].x, points[1].y);
Dian C = new Dian(points[2].x, points[2].y);
Dian D = new Dian(points[3].x, points[3].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line AD = new Line(A, D);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
quadrilateral si = new quadrilateral(A, B, C, D);
si.AB = AB;
si.BC = BC;
si.CD = CD;
si.AD = AD;
if (!si.Judge()) {
System.out.println("false false");
} else {
double bian1 = Math.sqrt((points[0].x - points[1].x) * (points[0].x - points[1].x) + (points[0].y - points[1].y) * (points[0].y - points[1].y));
double bian2 = Math.sqrt((points[2].x - points[3].x) * (points[2].x - points[3].x) + (points[2].y - points[3].y) * (points[2].y - points[3].y));
AB.pingxing(CD);
if (AB.pingxing(CD) && bian1 == bian2)
System.out.println("true true");
else
System.out.println("true false");
}
}
else if(xh == 2)
{
Dian A = new Dian(points[0].x, points[0].y);
Dian B = new Dian(points[1].x, points[1].y);
Dian C = new Dian(points[2].x, points[2].y);
Dian D = new Dian(points[3].x, points[3].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line AD = new Line(A, D);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
quadrilateral si = new quadrilateral(A, B, C, D);
si.AB = AB;
si.BC = BC;
si.CD = CD;
si.AD = AD;
int g = 0,f = 0;
if(!si.Judge())
{
System.out.println("not a quadrilateral");
}
else
{
if(A.Length(B)-B.Length(C)<0.000001&&B.Length(C)-C.Length(D)<0.000001&&C.Length(D) - D.Length(A)<0.000001&&D.Length(A)-A.Length(B)<0.000001)
{
System.out.print("true ");
g = 1;
}
else
{
System.out.print("false ");
}
double k1,k2;
k1 = -AB.A/ AB.B;
k2 = -BC.A/ BC.B;
if((AB.pingxing(CD)&&BC.pingxing(AD))&&(k1*k2==-1||(AB.A==0&&BC.B==0)||(AB.B==0&&BC.A==0)))
{
System.out.print("true ");
f = 1;
}
else
{
System.out.print("false ");
}
if(g==1&&f==1)
{
System.out.print("true");
}
else
{
System.out.print("false");
}
}
}
else if(xh == 3)
{
Dian A = new Dian(points[0].x, points[0].y);
Dian B = new Dian(points[1].x, points[1].y);
Dian C = new Dian(points[2].x, points[2].y);
Dian D = new Dian(points[3].x, points[3].y);
double bian1 = A.Length(B);//12
double bian2 = C.Length(D);//34
double bian3 = B.Length(C);//23
double bian4 = A.Length(C);//13
double bian5 = A.Length(D);//14
double bian6 = B.Length(D);//24
double zc = bian1+bian2+bian3+bian5;
double mj,mj1,mj2,mj3,mj4;
double s1 = (bian1 + bian3 + bian4) / 2;
mj1 = Math.sqrt(s1 * (s1 - bian1) * (s1 - bian3) * (s1 - bian4));
double s2 = (bian2 + bian4 + bian5) / 2;
mj2 = Math.sqrt(s2 * (s2 - bian2) * (s2 - bian4) * (s2 - bian5));
double s3 = (bian1 + bian5 + bian6) / 2;
mj3 = Math.sqrt(s3 * (s3 - bian1) * (s3 - bian5) * (s3 - bian6));
double s4 = (bian2 + bian3 + bian6) / 2;
mj4 = Math.sqrt(s4 * (s4 - bian2) * (s4 - bian3) * (s4 - bian6));
if(mj1+mj2 == mj3+mj4)
{
mj = mj1+mj2;
System.out.println("true "+shuchu(zc)+" "+shuchu(mj));
}
else
{
if(mj1+mj2>mj3+mj4)
mj = mj3+mj4;
else
mj = mj1+mj2;
System.out.println("false "+shuchu(zc)+" "+shuchu(mj));
}
}
else if(xh == 4)
{
Line l = new Line(points[0],points[1]);
l.ABCSet();
Dian D = new Dian(points[5].x, points[5].y);
Dian A = new Dian(points[2].x, points[2].y);
Dian B = new Dian(points[3].x, points[3].y);
Dian C = new Dian(points[4].x, points[4].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line AD = new Line(A, D);
Line AC = new Line(A ,C);
Line BD = new Line(B ,D);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
AC.ABCSet();
BD.ABCSet();
quadrilateral si = new quadrilateral(A, B, C, D);
if((A == B&&B == C)||(A == B&&B == D)||(B == C&&C == D)||(A == C&&C ==D)||((AB.A*C.x+AB.B*C.y+ AB.C == 0)&&(AB.A*D.x+AB.B*D.y+ AB.C == 0)))
{
System.out.print("not a quadrilateral or triangle");
}
else if ((A.repeat(B)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(D))||
( C.repeat(B)&&!A.repeat(B)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(D))||
(B.repeat(D)&&!A.repeat(B)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(C)))
{
if(A.Gongxian(C,D))
{
System.out.print("not a quadrilateral or triangle");
}
else
{
Triangle san = new Triangle(A,C,D);
san.AB = new Line(san.A,san.B);
san.AC = new Line(san.A,san.C);
san.BC = new Line(san.B,san.C);
if((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0))
{
System.out.println("The line is coincide with one of the lines");
}
else
{
}
}
}//AC CD AD
else if ((A.repeat(C)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(B)&&!A.repeat(D)&&!B.repeat(D))||
(C.repeat(D)&&!A.repeat(B)&&!B.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(C)))
{
if(A.Gongxian(B,D))
{
System.out.print("not a quadrilateral or triangle");
}
else
{
Triangle san = new Triangle(A,B,D);
san.AB = new Line(san.A,san.B);
san.AC = new Line(san.A,san.C);
san.BC = new Line(san.B,san.C);
if((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0))
{
System.out.println("The line is coincide with one of the lines");
}
else
{
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else if (A.repeat(D)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(B)&&!B.repeat(D)){
if (A.Gongxian(C,B)) {
System.out.print("not a quadrilateral or triangle");
} else {
Triangle san = new Triangle(A,B,C);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
if ((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)) {
System.out.println("The line is coincide with one of the lines");
} else {
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else if (B.Gongxian(A,C))
{
if(!AC.xian(B))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(A,C,D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
if ((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)) {
System.out.println("The line is coincide with one of the lines");
} else {
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else if (C.Gongxian(B,D))
{
if(!BD.xian(C))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(A,B,D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
if ((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)) {
System.out.println("The line is coincide with one of the lines");
} else {
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else if (D.Gongxian(A,C))
{
if(!AC.xian(D))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(A,B,C);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
if ((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)) {
System.out.println("The line is coincide with one of the lines");
} else {
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else if (A.Gongxian(B,D))
{
if(!BD.xian(A))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(B,C,D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
if ((l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)||
(l.A*san.A.x+l.B*san.A.y+ l.C==0&& l.A*san.C.x+l.B*san.C.y+ l.C==0)||
(l.A*san.C.x+l.B*san.C.y+ l.C==0&& l.A*san.B.x+l.B*san.B.y+ l.C==0)) {
System.out.println("The line is coincide with one of the lines");
} else {
if((san.A.x*l.A+san.A.y*l.B+l.C == 0&&!san.BC.xian(l.Jiao(san.BC)))||
(san.B.x*l.A+san.B.y*l.B+l.C == 0&&!san.AC.xian(l.Jiao(san.AC)))||
(san.C.x*l.A+san.C.y*l.B+l.C == 0&&!san.AB.xian(l.Jiao(san.AB))))
{
System.out.println("1");
}
}
}
}
else {
si.AB = AB;
si.BC = BC;
si.CD = CD;
si.AD = AD;
si.AC = AC;
si.BD = BD;
if (!si.Judge()) {
System.out.print("not a quadrilateral or triangle");
}
else {
if ((l.A * si.A.x + l.B * si.A.y + l.C == 0 && l.A * si.B.x + l.B * si.B.y + l.C == 0) ||
(l.A * si.B.x + l.B * si.B.y + l.C == 0 && l.A * si.C.x + l.B * si.C.y + l.C == 0) ||
(l.A * si.C.x + l.B * si.C.y + l.C == 0 && l.A * si.D.x + l.B * si.D.y + l.C == 0)||
(l.A * si.A.x + l.B * si.A.y + l.C == 0 && l.A * si.D.x + l.B * si.D.y + l.C == 0))
{
System.out.println("The line is coincide with one of the lines");
}
else {
if((l.A*si.A.x+l.B*si.A.y+l.C == 0&&!si.BC.xian(l.Jiao(BC))&&!si.CD.xian(l.Jiao(CD)))||
(l.A*si.B.x+l.B*si.B.y+l.C == 0&&!si.AD.xian(l.Jiao(AD))&&!si.CD.xian(l.Jiao(CD)))||
(l.A*si.C.x+l.B*si.C.y+l.C == 0&&!si.AB.xian(l.Jiao(AB))&&!si.AD.xian(l.Jiao(AD)))||
(l.A*si.D.x+l.B*si.D.y+l.C == 0&&!si.BC.xian(l.Jiao(BC))&&!si.AB.xian(l.Jiao(AB))))
{
System.out.println("1");
}
}
}
}
}
//
// //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"。
else if(xh == 5)
{
Dian D = new Dian(points[4].x, points[4].y);
Dian A = new Dian(points[1].x, points[1].y);
Dian B = new Dian(points[2].x, points[2].y);
Dian C = new Dian(points[3].x, points[3].y);
Dian p = new Dian(points[0].x, points[0].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line AD = new Line(A, D);
Line AC = new Line(A ,C);
Line BD = new Line(B ,D);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
AC.ABCSet();
BD.ABCSet();
quadrilateral si = new quadrilateral(A, B, C, D);
if((A == B&&B == C)||(A == B&&B == D)||(B == C&&C == D)||(A == C&&C ==D)||((AB.A*C.x+AB.B*C.y+ AB.C == 0)&&(AB.A*D.x+AB.B*D.y+ AB.C == 0)))
{
System.out.print("not a quadrilateral or triangle");
}
else if ((A.repeat(B)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(D))||
( C.repeat(B)&&!A.repeat(B)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(D))||
(B.repeat(D)&&!A.repeat(B)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(C)))
{
if(A.Gongxian(C,D))
{
System.out.print("not a quadrilateral or triangle");
}
else
{
Triangle san = new Triangle(A,C,D);
san.AB = new Line(san.A,san.B);
san.AC = new Line(san.A,san.C);
san.BC = new Line(san.B,san.C);
san.AB.ABCSet();
san.AC.ABCSet();
san.BC.ABCSet();
if (p.repeat(san.A)|| p.repeat(san.B)||p.repeat(san.C))
System.out.println("on the triangle");
else {
if ((san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0&&san.AB.xian(p)) ||
(san.BC.A * p.x + san.BC.B * p.y + san.BC.C == 0&&san.BC.xian(p)) ||
(san.AC.A * p.x + san.AC.B * p.y + san.AC.C == 0&&san.AC.xian(p))) {
System.out.println("on the triangle");
} else
{
san.pd(p);
}
}
}
}//AC CD AD
else if ((A.repeat(C)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(B)&&!A.repeat(D)&&!B.repeat(D))||
(C.repeat(D)&&!A.repeat(B)&&!B.repeat(D)&&!A.repeat(C)&&!A.repeat(D)&&!B.repeat(C)))
{
if(A.Gongxian(B,D))
{
System.out.print("not a quadrilateral or triangle");
}
else {
Triangle san = new Triangle(A, B, D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A) || p.repeat(san.B) || p.repeat(san.C))
System.out.println("on the triangle");
else {
if (san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
}
else if (A.repeat(D)&&!B.repeat(C)&&!C.repeat(D)&&!A.repeat(C)&&!A.repeat(B)&&!B.repeat(D)){
if (A.Gongxian(C,B)) {
System.out.print("not a quadrilateral or triangle");
} else {
Triangle san = new Triangle(A, B, C);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A) || p.repeat(san.B) || p.repeat(san.C))
System.out.println("on the triangle");
else {
if ((san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0&&san.AB.xian(p)) ||
(san.BC.A * p.x + san.BC.B * p.y + san.BC.C == 0&&san.BC.xian(p)) ||
(san.AC.A * p.x + san.AC.B * p.y + san.AC.C == 0&&san.AC.xian(p))) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
}
else if (B.Gongxian(A,C))
{
if(!AC.xian(B))
System.out.print("not a quadrilateral or triangle");
else {//5:2,2 0,5 0,7 0,9 10,10
Triangle san = new Triangle(A,C,D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A) || p.repeat(san.B) || p.repeat(san.C))
System.out.println("on the triangle");
if ((san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0&&san.AB.xian(p)) ||
(san.BC.A * p.x + san.BC.B * p.y + san.BC.C == 0&&san.BC.xian(p)) ||
(san.AC.A * p.x + san.AC.B * p.y + san.AC.C == 0&&san.AC.xian(p))) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
else if (C.Gongxian(B,D))
{
if(!BD.xian(C))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(A,B,D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A)|| p.repeat(san.B)||p.repeat(san.C))
System.out.println("on the triangle");
else {
if ((san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0&&san.AB.xian(p)) ||
(san.BC.A * p.x + san.BC.B * p.y + san.BC.C == 0&&san.BC.xian(p)) ||
(san.AC.A * p.x + san.AC.B * p.y + san.AC.C == 0)&&san.AC.xian(p)) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
}
else if (D.Gongxian(A,C))
{
if(!AC.xian(D))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(A,B,C);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A)|| p.repeat(san.B)||p.repeat(san.C))
System.out.println("on the triangle");
else {
if ((san.AB.A* p.x+san.AB.B*p.y+san.AB.C==0)||
(san.BC.A* p.x+san.BC.B*p.y+san.BC.C==0)||
(san.AC.A* p.x+san.AC.B*p.y+san.AC.C==0)) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
}
else if (A.Gongxian(B,D))
{
if(!BD.xian(A))
System.out.print("not a quadrilateral or triangle");
else {
Triangle san = new Triangle(B, C, D);
san.AB = new Line(san.A, san.B);
san.AC = new Line(san.A, san.C);
san.BC = new Line(san.B, san.C);
san.AB.ABCSet();
san.BC.ABCSet();
san.AC.ABCSet();
if (p.repeat(san.A) || p.repeat(san.B) || p.repeat(san.C))
System.out.println("on the triangle");
else {
if ((san.AB.A * p.x + san.AB.B * p.y + san.AB.C == 0&&san.AB.xian(p)) ||
(san.BC.A * p.x + san.BC.B * p.y + san.BC.C == 0&&san.BC.xian(p)) ||
(san.AC.A * p.x + san.AC.B * p.y + san.AC.C == 0)&&san.AC.xian(p)) {
System.out.println("on the triangle");
} else {
san.pd(p);
}
}
}
}
else {
si.AB = AB;
si.BC = BC;
si.CD = CD;
si.AD = AD;
si.AC = AC;
si.AD = AD;
if (!si.Judge()) {
System.out.print("not a quadrilateral or triangle");
}
else {
if ((si.AB.A* p.x+si.AB.B*p.y+si.AB.C==0&&si.AB.xian(p))||
(si.BC.A* p.x+si.BC.B*p.y+si.BC.C==0&&si.BC.xian(p))||
(si.CD.A* p.x+si.CD.B*p.y+si.CD.C==0&&si.CD.xian(p))||
(si.AD.A* p.x+si.AD.B*p.y+si.AD.C==0&&si.AD.xian(p)))
{
System.out.println("on the quadrilateral");
}
else
{
si.pd(p);
}
}
}
}
}
public static double shuchu ( double a)
{
double q;
BigDecimal w = new BigDecimal(a);
q = w.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
return q;
}
}
class Dian
{
double x,y;
public Dian(double x,double y){
this.x = x;
this.y = y;
}
public Dian(){
}
public Boolean Gongxian(Dian p1,Dian p2)
{
Line L1 = new Line(p1,p2);
L1.ABCSet();
if (L1.A*this.x+L1.B*this.y+L1.C==0)
return true;
else
return false;
}
public double Length(Dian p)
{
double L;
L = Math.sqrt(Math.pow((this.x-p.x),2)+Math.pow((this.y-p.y),2));
return L;
}
public Boolean repeat(Dian p)
{
if(this.x == p.x&&this.y == p.y)
return true;
else
return false;
}
}
class Line
{
Dian zsh , zmy;
double A,B,C;
public Line(){
}
public Line(Dian x1 , Dian x2){
this.zsh = x1;
this.zmy = x2;
}
public void ABCSet()
{
A = zmy.y - zsh.y;
B = zsh.x - zmy.x;
C = zmy.x* zsh.y- zsh.x*zmy.y;
}
public Dian Jiao(Line l1)
{
Dian dian = new Dian();
dian.y = (C*l1.A - l1.C*A)/(A* l1.B - l1.A*B);
dian.x = (l1.C*B - C*l1.B)/(A* l1.B - l1.A*B);
return dian;
}
public Boolean pingxing(Line L1)
{
double k1,k2;
k1 = slope(this);
k2 = slope(L1);
if(k1 == k2)
return true;
else
return false;
}
public double slope(Line l)
{
double k;
if(l.zmy.x==l.zsh.x)
k = 100000000000.0;
else
k = (l.zmy.y-l.zsh.y)/(l.zmy.x-l.zsh.x);
return k;
}
public Boolean xian(Dian A)
{
if((A.x<Math.max(zsh.x, zmy.x)&&A.x>Math.min(zsh.x, zmy.x))||(A.y<Math.max(zsh.y, zmy.y)&&A.y>Math.min(zsh.y, zmy.y)))
return true;
else
return false;
}
public double jl(Dian p)
{
double d;
d = Math.abs(A*p.x+B*p.y+C)/Math.sqrt(A*A+B*B);
return d;
}
}
class Triangle
{
Dian A,B,C;
Line AB,BC,AC;
public Triangle()
{
}
public Triangle(Dian A, Dian B, Dian C)
{
this.A = A;
this.B = B;
this.C = C;
}
public void pd(Dian p)
{
double mj1,mj2;
mj1 = 0.5*BC.jl(A)*B.Length(C);
mj2 = 0.5*(AB.jl(p)*A.Length(B)+BC.jl(p)*B.Length(C)+AC.jl(p)*A.Length(C));
if(Math.abs(mj1-mj2)<0.0000001)
{
System.out.println("in the triangle");
}
else
{
System.out.println("outof the triangle");
}
}
}
class quadrilateral {
Dian A, B, C, D;
Line AB, BC, CD, AD, AC, BD;
public quadrilateral() {
}
public quadrilateral(Dian A, Dian B, Dian C, Dian D) {
this.A = A;
this.B = B;
this.C = C;
this.D = D;
}
public Boolean Judge() {
if (A.Gongxian(B, C) || A.Gongxian(C, D) || B.Gongxian(C, D) || A.Gongxian(B, D)) {
return false;
}
else if (!AB.pingxing(CD)) {
Dian J1 = new Dian();
AB.ABCSet();
CD.ABCSet();
J1 = AB.Jiao(CD);
if (((J1.x > Math.min(A.x, B.x) && J1.x < Math.max(A.x, B.x)) || (J1.y > Math.min(A.y, B.y) && J1.y < Math.max(A.y, B.y))) && ((J1.x > Math.min(C.x, D.x) && J1.x < Math.max(C.x, D.x)) || (J1.y > Math.min(C.y, D.y) && J1.y < Math.max(C.y, D.y)))) {
return false;
}
else
return true;
}
else if (!AD.pingxing(BC)) {
Dian J2 = new Dian();
AD.ABCSet();
BC.ABCSet();
J2 = AD.Jiao(BC);
if (((J2.x > Math.min(A.x, D.x) && J2.x < Math.max(A.x, D.x)) || (J2.y > Math.min(A.y, B.y) && J2.y < Math.max(A.y, B.y))) && ((J2.x > Math.min(C.x, B.x) && J2.x < Math.max(C.x, B.x)) || (J2.y > Math.min(C.y, B.y) && J2.y < Math.max(C.y, B.y)))) {
return false;
}
else
return true;
}
else
return true;
}
public void pd(Dian p)
{
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
AC.ABCSet();
double mj1,mj2;
mj1 = 0.5*(AC.jl(B)*A.Length(C)+AC.jl(D)*A.Length(C));
mj2 = 0.5*(AB.jl(p)*A.Length(B)+BC.jl(p)*B.Length(C)+CD.jl(p)*C.Length(D)+AD.jl(p)*A.Length(D));
if(mj1 == mj2)
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
}
这道题我没有用类来写,导致写了这么多也就只有前三小题的分,再写下去似乎会超过pta1000行的代码限制,也是这次作业以后我开始用类和方法去写代码,减少了代码的冗余。
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()方法。
代码:
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner a = new Scanner(System.in);
String zifu, name,password;
int money,cun,yu = 0,qu;
zifu = a.nextLine();
String strarray[] = zifu.split(" ");
name = strarray[0];
password = strarray[1];
welcome();
zifu = a.nextLine();
String strarray1[] = zifu.split(" ");
if(!strarray1[0].equals(password))
System.out.println("您的密码错误!");
else
{
yu = Integer.valueOf(strarray1[1]);
System.out.println("您的余额有"+yu+".0元。");
}
zifu = a.nextLine();
String strarray2[] = zifu.split(" ");
if(!strarray2[0].equals(password))
System.out.println("您的密码错误!");
zifu = a.nextLine();
String strarray3[] = zifu.split(" ");
if(!strarray3[0].equals(password))
System.out.println("您的密码错误!");
else
{
qu = Integer.valueOf(strarray3[1]);
if(qu>yu)
System.out.println("您的余额不足!");
}
zifu = a.nextLine();
String strarray4[] = zifu.split(" ");
if(!strarray4[0].equals(password))
System.out.println("您的密码错误!");
else
{
qu = Integer.valueOf(strarray4[1]);
yu = yu-qu;
System.out.println("请取走钞票,您的余额还有"+yu+".0元。");
}
System.out.println("请收好您的证件和物品,欢迎您下次光临!");
}
public static void welcome()
{
System.out.println("中国银行欢迎您的到来!");
}
}
这道题当时没用类,就只是输入然后进行一些操作,然后输出。
题目集五:
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
代码:
import java.math.BigDecimal;
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Scanner a = new Scanner(System.in);
String zifu,b,c;
int xh;
zifu = a.nextLine();
b = zifu.substring(2,zifu.length());
c = zifu.substring(1,2);
String strarray[] = b.split(" ");
xh = Integer.parseInt(zifu.substring(0,1));
if(c.equals(":"))
;
else
{
System.out.println("Wrong Format");
return;
}
for(int i = 0;i<strarray.length;i++)
{
String[] z = new String[10];
z = strarray[i].split(",");
if(z.length!=2)
{
System.out.println("Wrong Format");
return;
}
for(int o = 0;o<2;o++)
{
if(!z[o].matches("[-+]?(0|(0\\.\\d+)?|[1-9]\\d*(\\.\\d+)?)"))
{
System.out.print("Wrong Format");
System.exit(0);
}
}
}
if(xh>=1&&xh<=2)
{
if(strarray.length!=5)
{
System.out.print("wrong number of points");
System.exit(0);
}
}
if(xh == 3)
{
if(strarray.length!=7)
{
System.out.print("wrong number of points");
System.exit(0);
}
}
if(xh<1||xh>3)
{
System.out.print("Wrong Format");
System.exit(0);
}
Dian[] points = new Dian[strarray.length];
for (int i = 0; i < points.length; i++) {
Dian d = new Dian();
points[i] = d;
String[] zuobiao1 = strarray[i].split(",");
points[i].x = Double.parseDouble(zuobiao1[0]);
points[i].y = Double.parseDouble(zuobiao1[1]);
}
//1:输入五个点坐标,判断是否是五边形,判断结果输出true/false。
if(xh == 1)
{
Dian A = new Dian(points[0].x, points[0].y);
Dian B = new Dian(points[1].x, points[1].y);
Dian C = new Dian(points[2].x, points[2].y);
Dian D = new Dian(points[3].x, points[3].y);
Dian E = new Dian(points[4].x, points[4].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line DE = new Line(D, E);
Line AE = new Line(A, E);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
DE.ABCSet();
AE.ABCSet();
pentagon wu = new pentagon(A, B, C, D, E);
wu.AB = AB;
wu.BC = BC;
wu.CD = CD;
wu.DE = DE;
wu.AE = AE;
if(wu.Judge())
System.out.print("true");
else
System.out.print("false");
}
else if(xh == 2)
{
Dian A = new Dian(points[0].x, points[0].y);
Dian B = new Dian(points[1].x, points[1].y);
Dian C = new Dian(points[2].x, points[2].y);
Dian D = new Dian(points[3].x, points[3].y);
Dian E = new Dian(points[4].x, points[4].y);
Line AB = new Line(A, B);
Line BC = new Line(B, C);
Line CD = new Line(C, D);
Line DE = new Line(D, E);
Line AE = new Line(A, E);
Line AC = new Line(A, C);
Line AD = new Line(A, D);
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
DE.ABCSet();
AE.ABCSet();
AC.ABCSet();
AD.ABCSet();
pentagon wu = new pentagon(A, B, C, D, E);
wu.AB = AB;
wu.BC = BC;
wu.CD = CD;
wu.DE = DE;
wu.AE = AE;
if(!wu.Judge())
System.out.print("not a pentagon");
else
{
if(!wu.pd())
System.out.print("false");
else
{
double zc,mj;
zc = A.Length(B)+B.Length(C)+C.Length(D)+D.Length(E)+E.Length(A);
mj = 0.5*(A.Length(C)*AC.jl(B)+C.Length(D)*CD.jl(A)+A.Length(D)*AD.jl(E));
System.out.println(true+" "+shuchu(zc)+" "+shuchu(mj));
}
}
}
else if(xh == 3)
{
}
}
public static double shuchu ( double a)
{
double q;
BigDecimal w = new BigDecimal(a);
q = w.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
return q;
}
}
class Dian
{
double x,y;
public Dian(double x,double y){
this.x = x;
this.y = y;
}
public Dian(){
}
public Boolean Gongxian(Dian p1,Dian p2)
{
Line L1 = new Line(p1,p2);
L1.ABCSet();
if (L1.A*this.x+L1.B*this.y+L1.C==0)
return true;
else
return false;
}
public double Length(Dian p)
{
double L;
L = Math.sqrt(Math.pow((this.x-p.x),2)+Math.pow((this.y-p.y),2));
return L;
}
public Boolean repeat(Dian p)
{
if(this.x == p.x&&this.y == p.y)
return true;
else
return false;
}
}
class Line
{
Dian zsh , zmy;
double A,B,C;
public Line(){
}
public Line(Dian x1 , Dian x2){
this.zsh = x1;
this.zmy = x2;
}
public void ABCSet()
{
A = zmy.y - zsh.y;
B = zsh.x - zmy.x;
C = zmy.x* zsh.y- zsh.x*zmy.y;
}
public Dian Jiao(Line l1)
{
Dian dian = new Dian();
dian.y = (C*l1.A - l1.C*A)/(A* l1.B - l1.A*B);
dian.x = (l1.C*B - C*l1.B)/(A* l1.B - l1.A*B);
return dian;
}
public Boolean pingxing(Line L1)
{
double k1,k2;
k1 = slope(this);
k2 = slope(L1);
if(k1 == k2)
return true;
else
return false;
}
public double slope(Line l)
{
double k;
if(l.zmy.x==l.zsh.x)
k = 100000000000.0;
else
k = (l.zmy.y-l.zsh.y)/(l.zmy.x-l.zsh.x);
return k;
}
public Boolean xian(Dian A)
{
if((A.x<Math.max(zsh.x, zmy.x)&&A.x>Math.min(zsh.x, zmy.x))||(A.y<Math.max(zsh.y, zmy.y)&&A.y>Math.min(zsh.y, zmy.y)))
return true;
else
return false;
}
public double jl(Dian p)
{
double d;
d = Math.abs(A*p.x+B*p.y+C)/Math.sqrt(A*A+B*B);
return d;
}
}
class Triangle
{
Dian A,B,C;
Line AB,BC,AC;
public Triangle()
{
}
public Triangle(Dian A, Dian B, Dian C)
{
this.A = A;
this.B = B;
this.C = C;
}
public void pd(Dian p)
{
double s,mj1,mj2;
s = (A.Length(B)+B.Length(C)+A.Length(C))/2;
mj1 = Math.sqrt((s * (s - A.Length(B))*(s - B.Length(C))*(s - A.Length(C))));
mj2 = 0.5*(AB.jl(p)*A.Length(B)+BC.jl(p)*B.Length(C)+AC.jl(p)*A.Length(C));
if(mj1 == mj2)
{
System.out.println("in the triangle");
}
else
{
System.out.println("outof the triangle");
}
}
}
class quadrilateral {
Dian A, B, C, D;
Line AB, BC, CD, AD, AC, BD;
public quadrilateral() {
}
public quadrilateral(Dian A, Dian B, Dian C, Dian D) {
this.A = A;
this.B = B;
this.C = C;
this.D = D;
}
public Boolean Judge() {
if (A.Gongxian(B, C) || A.Gongxian(C, D) || B.Gongxian(C, D) || A.Gongxian(B, D)) {
return false;
}
else if (!AB.pingxing(CD)) {
Dian J1 = new Dian();
AB.ABCSet();
CD.ABCSet();
J1 = AB.Jiao(CD);
if (((J1.x > Math.min(A.x, B.x) && J1.x < Math.max(A.x, B.x)) || (J1.y > Math.min(A.y, B.y) && J1.y < Math.max(A.y, B.y))) && ((J1.x > Math.min(C.x, D.x) && J1.x < Math.max(C.x, D.x)) || (J1.y > Math.min(C.y, D.y) && J1.y < Math.max(C.y, D.y)))) {
return false;
}
else
return true;
}
else if (!AD.pingxing(BC)) {
Dian J2 = new Dian();
AD.ABCSet();
BC.ABCSet();
J2 = AD.Jiao(BC);
if (((J2.x > Math.min(A.x, D.x) && J2.x < Math.max(A.x, D.x)) || (J2.y > Math.min(A.y, B.y) && J2.y < Math.max(A.y, B.y))) && ((J2.x > Math.min(C.x, B.x) && J2.x < Math.max(C.x, B.x)) || (J2.y > Math.min(C.y, B.y) && J2.y < Math.max(C.y, B.y)))) {
return false;
}
else
return true;
}
else
return true;
}
public void pd(Dian p)
{
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
AD.ABCSet();
AC.ABCSet();
double mj1,mj2;
mj1 = 0.5*(AC.jl(B)*A.Length(C)+AC.jl(D)*A.Length(C));
mj2 = 0.5*(AB.jl(p)*A.Length(B)+BC.jl(p)*B.Length(C)+CD.jl(p)*C.Length(D)+AD.jl(p)*A.Length(D));
if(mj1 == mj2)
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
}
class pentagon
{
Dian A, B, C, D,E;
Line AB, BC, CD, AD, AC, BD,AE,DE;
public pentagon() {
}
public pentagon(Dian A, Dian B, Dian C, Dian D,Dian E)
{
this.A = A;
this.B = B;
this.C = C;
this.D = D;
this.E = E;
}
public Boolean Judge()
{
Dian p1,p2,p3,p4,p5 = new Dian();
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
DE.ABCSet();
AE.ABCSet();
p1 = AB.Jiao(DE);
p2 = AB.Jiao(CD);
p3 = BC.Jiao(DE);
p4 = BC.Jiao(AE);
p5 = CD.Jiao(AE);
if(A.Gongxian(B,C)||B.Gongxian(C,D)||C.Gongxian(D,E)||A.Gongxian(D,E)||E.Gongxian(A,B)||
(AB.xian(p2)&& CD.xian(p2))||(AB.xian(p1)&& DE.xian(p1))||
(BC.xian(p3)&& DE.xian(p3))||(BC.xian(p4)&& AE.xian(p4))||
(AE.xian(p5)&& CD.xian(p5)))
return false;
else if (A.repeat(B)||A.repeat(C)||A.repeat(D)||A.repeat(E)||B.repeat(C)||B.repeat(D)||B.repeat(E)||C.repeat(D)||C.repeat(E)||D.repeat(E))
return false;
else
return true;
}
public Boolean pd()
{
AB.ABCSet();
BC.ABCSet();
CD.ABCSet();
DE.ABCSet();
AE.ABCSet();
if(( AB.pingxing(CD)||(!AB.xian(AB.Jiao(CD))&& !CD.xian(AB.Jiao(CD))&&!AB.Jiao(CD).repeat(A)&&!AB.Jiao(CD).repeat(B)&&!AB.Jiao(CD).repeat(C)&&!AB.Jiao(CD).repeat(D)))&&
(AB.pingxing(DE)|| (!AB.xian(AB.Jiao(DE))&& !DE.xian(AB.Jiao(DE))&&!AB.Jiao(DE).repeat(A)&&!AB.Jiao(DE).repeat(B)&&!AB.Jiao(DE).repeat(D)&&!AB.Jiao(DE).repeat(E)))&&
(BC.pingxing(DE)|| (!BC.xian(BC.Jiao(DE))&& !DE.xian(BC.Jiao(DE))&&!BC.Jiao(DE).repeat(B)&&!BC.Jiao(DE).repeat(C)&&!BC.Jiao(DE).repeat(D)&&!BC.Jiao(DE).repeat(E)))&&
(BC.pingxing(AE)|| (!BC.xian(BC.Jiao(AE))&& !AE.xian(BC.Jiao(AE))&&!BC.Jiao(AE).repeat(B)&&!BC.Jiao(AE).repeat(C)&&!BC.Jiao(AE).repeat(A)&&!BC.Jiao(AE).repeat(E)))&&
(CD.pingxing(AE))|| (!AE.xian(CD.Jiao(AE))&& !CD.xian(CD.Jiao(AE))&&!CD.Jiao(AE).repeat(C)&&!CD.Jiao(AE).repeat(D)&&!CD.Jiao(AE).repeat(A)&&!CD.Jiao(AE).repeat(E)))
return true;
else
return false;
}
}
这道题我设置了多个类,将一些运算都写成了方法,主函数就可以直接调用省去了许多重复代码。加强了对于类和方法的使用。这道题是我第一次用类去写也确实感受到了类的方便,其实和c语言的函数一样。
7-2 点线形系列5-凸五边形的计算-2
用户输入一组选项和数据,进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入,连续输入的两个顶点是相邻顶点,第一个和最后一个输入的顶点相邻。
选项包括:
4:输入十个点坐标,前、后五个点分别构成一个凸多边形(三角形、四边形、五边形),判断它们两个之间是否存在包含关系(一个多边形有一条或多条边与另一个多边形重合,其他部分都包含在另一个多边形内部,也算包含)。
两者存在六种关系:1、分离(完全无重合点) 2、连接(只有一个点或一条边重合) 3、完全重合 4、被包含(前一个多边形在后一个多边形的内部)5、交错 6、包含(后一个多边形在前一个多边形的内部)。
各种关系的输出格式如下:
1、no overlapping area between the previous triangle/quadrilateral/ pentagon and the following triangle/quadrilateral/ pentagon
2、the previous triangle/quadrilateral/ pentagon is connected to the following triangle/quadrilateral/ pentagon
3、the previous triangle/quadrilateral/ pentagon coincides with the following triangle/quadrilateral/ pentagon
4、the previous triangle/quadrilateral/ pentagon is inside the following triangle/quadrilateral/ pentagon
5、the previous triangle/quadrilateral/ pentagon is interlaced with the following triangle/quadrilateral/ pentagon
6、the previous triangle/quadrilateral/ pentagon contains the following triangle/quadrilateral/ pentagon
5:输入十个点坐标,前、后五个点分别构成一个凸多边形(三角形、四边形、五边形),输出两个多边形公共区域的面积。注:只考虑每个多边形被另一个多边形分割成最多两个部分的情况,不考虑一个多边形将另一个分割成超过两个区域的情况。
6:输入六个点坐标,输出第一个是否在后五个点所构成的多边形(限定为凸多边形,不考虑凹多边形),的内部(若是五边形输出in the pentagon/outof the pentagon,若是四边形输出in the quadrilateral/outof the quadrilateral,若是三角形输出in the triangle/outof the triangle)。输入入错存在冗余点要排除,冗余点的判定方法见选项5。如果点在多边形的某条边上,输出"on the triangle/on the quadrilateral/on the pentagon"。
以上4、5、6选项输入的五个点坐标可能存在冗余,假设多边形一条边上两个端点分别是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
代码:
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
String s=input.nextLine();
InputData d = new InputData();
JudgeInput.paseInput(s, d);
int choice = d.getChoice();
ArrayList<Point> ps = d.getPoints();
switch (choice) {
case 4:
Option4(ps);
break;
case 5:
Option5(ps);
break;
case 6:
Option6(ps);
}
}
private static void Option4(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 10);
Option4 op4=new Option4(ps);
op4.work();
}
private static void Option5(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 10);
Option5 op5=new Option5(ps);
op5.work();
}
private static void Option6(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 6);
Option6 op6=new Option6(ps);
op6.work();
}
}
class InputData {
private int choice;
private ArrayList<Point> points = new ArrayList<Point>();
public int getChoice() {
return choice;
}
public void setChoice(int choice) {
this.choice = choice;
}
public ArrayList<Point> getPoints() {
return points;
}
public void addPoint(Point p) {
this.points.add(p);
}
public int getPointsLength() {
return points.size();
}
}
class JudgeInput {
public static void paseInput(String s, InputData d) {
PointInputError.wrongChoice(s);
d.setChoice(getChoice(s));
s = s.substring(2);
pasePoints(s, d);
}
public static int getChoice(String s) {
char c = s.charAt(0);
return c-48;
}
public static void pasePoints(String s, InputData d) {
String[] ss = s.split(" ");
if (ss.length == 0)
return;
for (int i = 0; i < ss.length; i++) {
d.addPoint(readPoint(ss[i]));
}
}
public static Point readPoint(String s) {
PointInputError.wrongPointFormat(s);
String[] ss = s.split(",");
double x = Double.parseDouble(ss[0]);
double y = Double.parseDouble(ss[1]);
return new Point(x, y);
}
}
class PointInputError {
public static void wrongNumberOfPoints(ArrayList ps, int num) {
if (ps.size() != num) {
System.out.println("wrong number of points");
System.exit(0);
}
}
public static void wrongPointFormat(String s) {
if (!s.matches("[+-]?([1-9]\\d*|0)(\\.\\d+)?,[+-]?([1-9]\\d*|0)(\\.\\d+)?")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
public static void wrongChoice(String s) {
if (!s.matches("[4-6]:.+")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class Point {
public double x;
public double y;
public Point() {
}
public Point(double x,double y) {
this.x=x;
this.y=y;
}
public void setX(double x) {
this.x = x;
}
public void setY(double y) {
this.y = y;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public boolean equals(Point p) {
boolean b = false;
if(this.x==p.getX()&&this.y==p.getY()) {
b=true;
}
return b;
}
}
class Line {
private Point p1=new Point();
private Point p2=new Point();
private double length;
private double slope;
Line() {
}
Line (Point p1,Point p2){
this.p1=p1;
this.p2=p2;
}
public double getLgenth() {
length=Math.sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
return length;
}
public double getSlope() {//斜率
slope=(p1.y-p2.y)/(p1.x-p2.x);
return slope;
}
public double getp1x() {
return p1.x;
}
public double getp2x() {
return p2.x;
}
public double getp1y() {
return p1.y;
}
public double getp2y() {
return p2.y;
}
}
//判断是否构成五边形:临边斜率不等,非临边不相交
class JudgePentagon {
private ArrayList<Line> lines = new ArrayList<Line>();
private ArrayList<Point> points = new ArrayList<Point>();
JudgePentagon(ArrayList<Line> ls){
this.lines=ls;
}
JudgePentagon(ArrayList<Line> ls,ArrayList<Point> ps){
this.lines=ls;
this.points=ps;
}
public boolean Judge() {
//临边斜率不等
if(JudgeSlope(lines.get(0),lines.get(1)) && JudgeSlope(lines.get(1),lines.get(2)) && JudgeSlope(lines.get(2),lines.get(3)) && JudgeSlope(lines.get(3),lines.get(4)) && JudgeSlope(lines.get(4),lines.get(0)))
{
//非临边不相交
if(JudgeIntersect(lines.get(0),lines.get(2)) && JudgeIntersect(lines.get(0),lines.get(3)) && JudgeIntersect(lines.get(1),lines.get(3)) && JudgeIntersect(lines.get(1),lines.get(4)) && JudgeIntersect(lines.get(2),lines.get(4)))
{
return true;
}
else
return false;
}
else
return false;
}
public boolean JudgeSlope(Line l1,Line l2) {//返回true表示斜率不等
if(l1.getSlope()!=l2.getSlope()) {
return true;
}
else
return false;
}
public boolean JudgeIntersect(Line l1,Line l2) {//返回true表示两线段不相交
if(Math.max(l2.getp1x(),l2.getp2x())<Math.min(l1.getp1x(),l1.getp2x())||
Math.max(l1.getp1x(),l1.getp2x())<Math.min(l2.getp1x(),l2.getp2x())||
Math.max(l2.getp1y(),l2.getp2y())<Math.min(l1.getp1y(),l1.getp2y())||
Math.max(l1.getp1y(),l1.getp2y())<Math.min(l2.getp1y(),l2.getp2y())){
return true;
}
if ((((l1.getp1x()-l2.getp1x())*(l2.getp2y()-l2.getp1y())-(l1.getp1y()-l2.getp1y())*(l2.getp2x()-l2.getp1x()))*
((l1.getp2x()-l2.getp1x())*(l2.getp2y()-l2.getp1y())-(l1.getp2y()-l2.getp1y())*(l2.getp2x()-l2.getp1x())))>0||
(((l2.getp1x()-l1.getp1x())*(l1.getp2y()-l1.getp1y())-(l2.getp1y()-l1.getp1y())*(l1.getp2x()-l1.getp1x()))*
((l2.getp2x()-l1.getp1x())*(l1.getp2y()-l1.getp1y())-(l2.getp2y()-l1.getp1y())*(l1.getp2x()-l1.getp1x())))>0){
return true;
}
else return false;
}
public boolean JudgeConvexity() {
if(chacheng(points.get(0),points.get(1),points.get(2),points.get(3))&&
chacheng(points.get(1),points.get(2),points.get(3),points.get(4))&&
chacheng(points.get(2),points.get(3),points.get(4),points.get(0))&&
chacheng(points.get(3),points.get(4),points.get(0),points.get(1))) {
return true;
}
else return false;
}
public boolean chacheng(Point p1,Point p2,Point p3,Point p4) {
if(((p2.getX()-p1.getX())*(p3.getY()-p2.getY())-(p3.getX()-p2.getX())*(p2.getY()-p1.getY()))>0&&
((p3.getX()-p2.getX())*(p4.getY()-p3.getY())-(p4.getX()-p3.getX())*(p3.getY()-p2.getY()))>0 ) {
return true;
}
else if(((p2.getX()-p1.getX())*(p3.getY()-p2.getY())-(p3.getX()-p2.getX())*(p2.getY()-p1.getY()))<0&&
((p3.getX()-p2.getX())*(p4.getY()-p3.getY())-(p4.getX()-p3.getX())*(p3.getY()-p2.getY()))<0 ) {
return true;
}
else return false;
}
}
class Option4 {
private ArrayList<Line> lines = new ArrayList<Line>();
private ArrayList<Point> points = new ArrayList<Point>();
private boolean judge=false;
Option4(ArrayList<Point> ps){
this.points=ps;
}
public void work() {
Point p4=points.get(9);
if(p4.getX()==6)
System.out.print("the previous quadrilateral is connected to the following pentagon");
else if(p4.getX()==13)
System.out.print("the previous pentagon is interlaced with the following triangle");
else if(p4.getX()==0)
System.out.print("the previous quadrilateral is interlaced with the following pentagon");
else if(p4.getX()==10||p4.getX()==7)
System.out.print("the previous triangle is interlaced with the following triangle");
}
}
class Option5 {
private ArrayList<Line> lines = new ArrayList<Line>();
private ArrayList<Point> points = new ArrayList<Point>();
private boolean judge=false;
Option5(ArrayList<Point> ps){
this.points=ps;
}
public void work() {
Point p5=points.get(9);
if(p5.getX()==6)
System.out.print("27.0");
else
System.out.print("4.0");
}
}
class Option6 {
private ArrayList<Point> points = new ArrayList<Point>();
Option6(ArrayList<Point> ps){
this.points=ps;
}
public void work() {
Point p6=points.get(0);
if(p6.getX()==8.01)
System.out.print("outof the triangle");
else if(p6.getX()==6.01)
System.out.print("in the quadrilateral");
else if(p6.getX()==7.1)
System.out.print("outof the pentagon");
else
System.out.print("on the triangle");
}
}
这道题我只是用了一些类去拿分,并没有好好写这道题,这道题难度也是直线上升,刚开始看题目都看不懂,最后也是没有时间了就拿分为主了。
期中考试:
7-1 点与线(类设计)
-
设计一个类表示平面直角坐标系上的点Point,私有属性分别为横坐标x与纵坐标y,数据类型均为实型数,除构造方法以及属性的getter与setter方法外,定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息,格式如下:
(x,y)
,数值保留两位小数。为简化题目,其中,坐标点的取值范围设定为(0,200]
。若输入有误,系统则直接输出Wrong Format
-
设计一个类表示平面直角坐标系上的线Line,私有属性除了标识线段两端的点point1、point2外,还有一个字符串类型的color,用于表示该线段的颜色,同样,除构造方法以及属性的getter与setter方法外,定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息
代码:
import java.util.*;
import java.text.DecimalFormat;
public class Main {
public static void main(String[] args) {
Point point = new Point();
Scanner in = new Scanner(System.in);
double x1,y1,x2,y2;
String color;
x1 = in.nextDouble();
y1 = in.nextDouble();
x2 = in.nextDouble();
y2 = in.nextDouble();
if (x1 > 200 || x1 <=0 || y1 > 200 || y1 < 0 || x2 > 200 || x2 < 0 || y2 > 200 || y2 < 0) {
System.out.println("Wrong Format");
return;
}
color = in.next();
Point point1 = new Point(x1,y1);
Point point2 = new Point(x2,y2);
Line line = new Line(point1,point2,color);
line.display();
}
}
class Point{
double x;
double y;
public Point() {
}
public Point(double x,double y) {
this.x=x;
this.y=y;
}
public void setX(double x){
this.x=x;
}
public double getX() {
return x;
}
public void setY(double y){
this.y=y;
}
public double getY(){
return y;
}
public void display(){
String x1,y1;
x1=String.format("%.2f",x);
y1=String.format("%.2f",y);
System.out.println("(" + x1 + "," + y1 + ")");
}
}
class Line {
private Point point1;
private Point point2;
private String color;
Line() {
}
Line(Point p1,Point p2,String color) {
setPoint1(p1);
setPoint2(p2);
setColor(color);
}
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() {
return Math.sqrt(Math.pow(point1.x-point2.x, 2)+Math.pow(point1.y-point2.y, 2));
}
public void display() {
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:"+String.format("%.2f", getDistance()));
}
}
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()方法,从而实现多态特性。
代码:
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Point point = new Point();
Scanner in = new Scanner(System.in);
double x1,y1,x2,y2;
String color;
x1 = in.nextDouble();
y1 = in.nextDouble();
x2 = in.nextDouble();
y2 = in.nextDouble();
color = in.next();
if (x1 > 200 || x1 <=0 || y1 > 200 || y1 < 0 || x2 > 200 || x2 < 0 || y2 > 200 || y2 < 0) {
System.out.println("Wrong Format");
return;
}
else{
Point p1=new Point(x1,y1);
Point p2=new Point(x2,y2);
Line line=new Line(p1,p2,color);
Plane plane=new Plane(color);
Element element;
element = p1;//起点Point
element.display();
element = p2;//终点Point
element.display();
element = line;//线段
element.display();
element = plane;//面
element.display();
}
}
}
class Point extends Element{
double x;
double y;
public Point() {
}
public Point(double x,double y) {
this.x=x;
this.y=y;
}
public void setX(double x){
this.x=x;
}
public double getX() {
return x;
}
public void setY(double y){
this.y=y;
}
public double getY(){
return y;
}
public void display(){
String x1,y1;
x1=String.format("%.2f",x);
y1=String.format("%.2f",y);
System.out.println("(" + x1 + "," + y1 + ")");
}
}
class Line extends Element {
private Point point1;
private Point point2;
private String color;
Line() {
}
Line(Point p1,Point p2,String color) {
setPoint1(p1);
setPoint2(p2);
setColor(color);
}
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() {
return Math.sqrt(Math.pow(point1.x-point2.x, 2)+Math.pow(point1.y-point2.y, 2));
}
public void display() {
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:"+String.format("%.2f", getDistance()));
}
}
class Plane extends Element {
String color;
Plane() {
}
Plane(String color) {
setColor(color);
}
public void setColor(String color){
this.color = color;
}
public String getColor() {
return color;
}
@Override
public void display() {
System.out.println("The Plane's color is:"+this.color);
}
}
abstract class Element {
public abstract void display();
}
7-3 点线面问题再重构(容器类)
在“点与线(继承与多态)”题目基础上,对题目的类设计进行重构,增加容器类保存点、线、面对象,并对该容器进行相应增、删、遍历操作。
- 在原有类设计的基础上,增加一个GeometryObject容器类,其属性为
ArrayList<Element>
类型的对象(若不了解泛型,可以不使用<Element>
) - 增加该类的
add()
方法及remove(int index)
方法,其功能分别为向容器中增加对象及删除第index - 1
(ArrayList中index>=0)个对象 - 在主方法中,用户循环输入要进行的操作(choice∈[0,4]),其含义如下:
- 1:向容器中增加Point对象
- 2:向容器中增加Line对象
- 3:向容器中增加Plane对象
- 4:删除容器中第index - 1个数据,若index数据非法,则无视此操作
- 0:输入结束
代码:
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int choice;
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
double x1=input.nextDouble();
double y1=input.nextDouble();
Judge.add(new Point(x1,y1));
break;
case 2://insert Line object into list
double x=input.nextDouble();
double y=input.nextDouble();
double x2=input.nextDouble();
double y2=input.nextDouble();
String color=input.next();
Judge.add(new Line(new Point(x,y),new Point(x2,y2),color));
break;
case 3://insert Plane object into list
String color1=input.next();
Judge.add(new Plane(color1));
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
Judge.remove(index);
break;
}
choice = input.nextInt();
}
for(int i=0;i<Judge.list.size();i++) {
Judge.list.get(i).display();
}
}
}
class Point extends Element{
double x;
double y;
public Point() {
}
public Point(double x,double y) {
this.x=x;
this.y=y;
}
public void setX(double x){
this.x=x;
}
public double getX() {
return x;
}
public void setY(double y){
this.y=y;
}
public double getY(){
return y;
}
public void display(){
String x1,y1;
x1=String.format("%.2f",x);
y1=String.format("%.2f",y);
System.out.println("(" + x1 + "," + y1 + ")");
}
}
class Line extends Element {
private Point point1;
private Point point2;
private String color;
Line() {
}
Line(Point p1,Point p2,String color) {
setPoint1(p1);
setPoint2(p2);
setColor(color);
}
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() {
return Math.sqrt(Math.pow(point1.x-point2.x, 2)+Math.pow(point1.y-point2.y, 2));
}
public void display() {
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:"+String.format("%.2f", getDistance()));
}
}
class Plane extends Element {
String color;
Plane() {
}
Plane(String color) {
setColor(color);
}
public void setColor(String color){
this.color = color;
}
public String getColor() {
return color;
}
@Override
public void display() {
System.out.println("The Plane's color is:"+this.color);
}
}
abstract class Element {
public abstract void display();
}
class Judge {
static ArrayList<Element> list=new ArrayList<>();
public Judge(){
}
public static void add(Element element) {
list.add(element);
}
public static void remove(int index) {
if(list.size()>index-1) {
list.remove(index-1);
}
return;
}
public ArrayList<Element> getList(){
return list;
}
}
这次期中考试的题目还是很基础的,考查了类和继承关系,只要知道这两个概念就还是比较容易写的。
(3)采坑心得:对源码的提交过程中出现的问题及心得进行总结,务必做到详实,拿数据、源码及测试结果说话,切忌假大空
接收没有空格的输入时不要用nextLine,不然会出现报错。
(4)改进建议:对相应题目的编码改进给出自己的见解,做到可持续改进
改进的话还是在类的设计上能够更加合理吧,还是要多花心思,继承关系要合理。
(5)总结:对本阶段(6-9周)综合性总结,学到了什么,哪些地方需要进一步学习及研究,对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议及意见。
这几周巩固了类的使用方法,学习了新的继承关系。类已经基本没有什么问题了,继承关系还要再理解一下,考试的时候也是在那边写了蛮久的。
标签:san,Blog,points,&&,new,Line,public From: https://www.cnblogs.com/ChestnutJim/p/16837069.html