pta第二次博客
pta第二次博客
1.前言
这三次作业对正则表达式的规范使用都又较高的要求，如果正则写的不够全面会导致很多输入格式错误的问题，导致很多测试点过不去，也要求第三次作业的三角形的代码又较高的复用性，不然会导致每题都要去重构一下，会浪费大量的时间。
2.设计与分析
第四次作业第一题
1.题目：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为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"结束。
输出格式:
与输入行相对应的各个整数之和。
试题分析
本题的难点在于如何如何将数字从段落中提取出来，只要对pattern和Matcher有所了解就能解决。
源代码展示：
查看代码
package pta41;
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 S = in.nextLine();
int sum=0;
Pattern x=Pattern.compile("[0-9]+");
while(!S.equals("end"))
{
sum=0;
Matcher matcher=x.matcher(S);
while(matcher.find())
{
zd n=new zd();
sum+=n.zh(matcher.group());
}
System.out.println(sum);
S=in.nextLine();
}
}
}
class zd {
int str;
public int zh(String x)
{
str=Integer.valueOf(x);
return str;
}
}
SourceMonitor生成的报表内容：
类图
代码分析总结：
本次作业比较简单，代码也不多，不做分析。
第四次作业第二题
题目：
点线形系列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"。
试题分析
本题主要考察大量的点与线的判断以及点与面的判断，因为四边形可以成由两个三角形共用同一条边组成，所以在写代码时可以借用三角形的代码来简化操作，运用循环来判断各种特殊情况。
源代码展示：
查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String S = in.nextLine();
if (S.charAt(1) != ':'||S.contains(", ")||S.charAt(S.length()-1)==',') {
System.out.println("Wrong Format");
return;
}
String[] str = S.split(":");
if ("1".equals(str[0])) {
point4 p1=new point4();
p1.quadrilateral(str[1],1);
System.out.println(p1.sbx +" "+p1.pxsbx);
}
if ("2".equals(str[0])) {
point4 p1=new point4();
p1.quadrilateral(str[1],1);
if(p1.sbx)
System.out.println(p1.lx +" "+p1.jx+" "+p1.zfx);
else
System.out.println("not a quadrilateral");
}
if ("3".equals(str[0])) {
point4 p1=new point4();
p1.quadrilateral(str[1],1);
if(p1.t|| p1.a)
p1.S=p1.s1+p1.s2;
else
p1.S= p1.s1-p1.s2;
String c1=String.format("%."+3+"f",p1.c);String s2=String.format("%."+3+"f", p1.S);
p1.c= Double.parseDouble(c1);p1.S= Double.parseDouble(s2);
if(p1.sbx)
System.out.println(p1.t+" "+p1.c+" "+p1.S);
else
System.out.println("not a quadrilateral");
}
if("4".equals(str[0]))
{
case4 p2=new case4();
p2.point6(str[1]);
System.out.print("p2.j");
}
if("5".equals(str[0]))
{
case5 p2=new case5();
p2.point5(str[1]);
}
}
}
class point4{
String[] l=new String[20];
String[] s=new String[20];
boolean sbx,pxsbx,jx,lx,zfx,t,a;
double x1, y1, x2, y2, x3, y3, x4, y4,k4,k5,k6,l4,l5,l6,c,S,s1,s2;
public void quadrilateral(String str,int b){
l=str.split(" ");
zz x=new zz();
samepoint p=new samepoint();
point3 triangle=new point3();
sbx=false;pxsbx=false;jx=false;lx=false;zfx=false;t=false;a=false;
int i,j;
for(i=0;i<l.length;i++)
{
s=l[i].split(",");
if (s.length != 2) {
System.out.println("Wrong Format");
System.exit(0);
}
for(j=0;j<s.length;j++)
x.z(s[j]);
}
if (l.length != 4) {
System.out.println("wrong number of points");
System.exit(0);
}
s = l[0].split(",");x1 = Double.valueOf(s[0]);y1 = Double.valueOf(s[1]);
s = l[1].split(",");x2 = Double.valueOf(s[0]);y2 = Double.valueOf(s[1]);
s = l[2].split(",");x3 = Double.valueOf(s[0]);y3 = Double.valueOf(s[1]);
s = l[3].split(",");x4 = Double.valueOf(s[0]);y4 = Double.valueOf(s[1]);
triangle.sjx(x1,y1,x2,y2,x3,y3);
s1= triangle.s;
k4=(y4-y1)/(x4-x1);k5=(y4-y2)/(x4-x2);k6=(y4-y3)/(x4-x3);
l4=Math.sqrt(Math.pow(x1-x4,2)+Math.pow(y1-y4,2));
l5=Math.sqrt(Math.pow(x4-x2,2)+Math.pow(y4-y2,2));
l6=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
if(b==1)
{
if(triangle.inline(x4,y4,x1,y1,x2,y2)||triangle.inline(x4,y4,x1,y1,x3,y3)||triangle.inline(x4,y4,x3,y3,x2,y2)||triangle.inline(x1,y1,x2,y2,x3,y3))
return;
if(p.point(x1,x2,y1,y2)||p.point(x1,x3,y1,y3)||p.point(x1,x4,y1,y4)||p.point(x3,x2,y3,y2)||p.point(x4,x2,y4,y2)||p.point(x3,x4,y3,y4))
{
System.out.println("points coincide");
System.exit(0);
}
if((!xj(x1,y1,x4,y4,x2,y2,x3,y3)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4))||(!xj(x2,y2,x3,y3,x1,y1,x4,y4)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4)))
{
sbx=true;t=true;
}
if((xj(x1,y1,x4,y4,x2,y2,x3,y3)&&xj(x1,y1,x2,y2,x3,y3,x4,y4))||(xj(x2,y2,x3,y3,x1,y1,x4,y4)&&xj(x3,y3,x4,y4,x1,y1,x2,y2))||(xj(x3,y3,x4,y4,x1,y1,x2,y2)&&xj(x1,y1,x3,y3,x2,y2,x4,y4)))
{
sbx=true;a=true;t=false;
}
if(xj(x2,y2,x3,y3,x1,y1,x4,y4)&&xj(x1,y1,x2,y2,x3,y3,x4,y4))
{
sbx=true;a=false;t=false;
}
if(((l5== triangle.l2&&l4==triangle.l3&&k4== triangle.k3)||(l4==triangle.l3&&l6==triangle.l1&&k4== triangle.k3)||(k5== triangle.k2&&l5== triangle.l2&&l6==triangle.l1))&&sbx)
pxsbx=true;
if(pxsbx&&triangle.zj)
jx=true;
if(triangle.l1==l4&&l4==l6&&l6==triangle.l3&&sbx)
lx=true;
if(jx&&lx)
zfx=true;
}
c= triangle.l1+ triangle.l3+l4+l6;
triangle.sjx(x1,y1,x3,y3,x4,y4);
s2= triangle.s;
S=s1+s2;
if(b==2)
{
if(x1==x3)
{
triangle.sjx(x2,y2,x3,y3,x4,y4);
s2= triangle.s;
S=s1+s2;
}
}
if(b==3)
{
if(pd(x1,y1,x2,y2,x3,y3,x4,y4))
{
if((!xj(x1,y1,x4,y4,x2,y2,x3,y3)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4))||(!xj(x2,y2,x3,y3,x1,y1,x4,y4)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4)))
{
sbx=true;t=true;
}
if((xj(x1,y1,x4,y4,x2,y2,x3,y3)&&xj(x1,y1,x2,y2,x3,y3,x4,y4))||(xj(x2,y2,x3,y3,x1,y1,x4,y4)&&xj(x3,y3,x4,y4,x1,y1,x2,y2))||(xj(x3,y3,x4,y4,x1,y1,x2,y2)&&xj(x1,y1,x3,y3,x2,y2,x4,y4)))
{
sbx=true;a=true;t=false;
}
if(xj(x2,y2,x3,y3,x1,y1,x4,y4)&&xj(x1,y1,x2,y2,x3,y3,x4,y4))
{
sbx=true;a=false;t=false;
}
if(t||a)
S=s1+s2;
else
S= s1-s2;
}
else {
if(triangle.inline2(x2,y2,x1,y1,x3,y3))
triangle.sjx(x1,y1,x3,y3,x4,y4);
if(triangle.inline2(x3,y3,x2,y2,x4,y4))
triangle.sjx(x1,y1,x2,y2,x4,y4);
if(triangle.inline2(x4,y4,x1,y1,x3,y3))
triangle.sjx(x1,y1,x2,y2,x3,y3);
}
}
}
public boolean xj(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4)
{
double A1,B1,C1,A2,B2,C2,x,y;
A1=y1-y2;B1=x2-x1;C1=y2*x1-y1*x2;
A2=y3-y4;B2=x4-x3;C2=y4*x3-y3*x4;
if(A1*B2==A2*B1)
return false;
x=(B2*C1-B1*C2)/(B1*A2-B2*A1);
y=(A2*C1-A1*C2)/(A1*B2-A2*B1);
if((x>x1&&x<x2||x<x1&&x>x2)&&(y>x1&&y<y2||y>y2&&y<y1))
return true;
else
return false;
}
public void jd(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4,double x,double y) {
double A1, B1, C1, A2, B2, C2;
A1 = y1 - y2;B1 = x2 - x1;C1 = y2 * x1 - y1 * x2;
A2 = y3 - y4;B2 = x4 - x3;C2 = y4 * x3 - y3 * x4;
x = (B2 * C1 - B1 * C2) / (B1 * A2 - B2 * A1);
y = (A2 * C1 - A1 * C2) / (A1 * B2 - A2 * B1);
}
public boolean pd(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4){
//判断四边形还是三角形
point3 s=new point3();
samepoint p=new samepoint();
if((x1==x2&&x2==x3&&y1==y2&&y2==y3)||(x1==x2&&x2==x4&&y1==y2&&y2==y4)||(x1==x3&&x3==x4&&y1==y3&&y3==y4)||(x2==x3&&x3==x4&&y2==y3&&y3==y4))
{
System.out.println("not a quadrilateral or triangle");
System.exit(0);
}
if((p.point(x1,x2,y1,y2)||p.point(x1,x3,y1,y3)||p.point(x3,x4,y3,y4)||s.inline(x3,y3,x1,y1,x2,y2))&&(s.pdsjx(x1,y1,x3,y3,x4,y4)||s.pdsjx(x1,y1,x2,y2,x4,y4)||s.pdsjx(x1,y1,x2,y2,x3,y3)))
return false;
else if((!xj(x1,y1,x4,y4,x2,y2,x3,y3)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4))||(!xj(x2,y2,x3,y3,x1,y1,x4,y4)&&!xj(x1,y1,x2,y2,x3,y3,x4,y4)))
return true;
else{
System.out.println("not a quadrilateral or triangle");
System.exit(0);
return false;
}
}
}
class case4{
String[] l=new String[50];
String[] s=new String[50];
double x1, y1, x2, y2,S,s1,s2,x5,x6,x7,x8,y5,y6,y7,y8,j;
public void point6(String str)
{
j=0;
l=str.split(" ");
zz x=new zz();
samepoint p=new samepoint();
point3 t=new point3();
point4 q=new point4();
q.quadrilateral(str.substring(l[1].length()+1),3);
s=l[0].split(",");x1 = Double.valueOf(s[0]);y1 = Double.valueOf(s[1]);
s=l[1].split(",");x2 = Double.valueOf(s[0]);y2 = Double.valueOf(s[1]);
if(p.point(x1,x2,y1,y2)){
System.out.println("points coincide");
System.exit(0);
}
q.jd(x1,y1,x2,y2,q.x2,q.y2,q.x3,q.y3,x6,y6);
q.jd(x1,y1,x2,y2,q.x2,q.y2,q.x1,q.y1,x5,y5);
q.jd(x1,y1,x2,y2,q.x4,q.y4,q.x3,q.y3,x7,y7);
q.jd(x1,y1,x2,y2,q.x1,q.y1,q.x4,q.y4,x8,y8);
if(t.inline2(q.x1,q.y1,x1,y1,x2,y2)||t.inline2(q.x2,q.y2,x1,y1,x2,y2)||t.inline2(q.x3,q.y3,x1,y1,x2,y2)||t.inline2(q.x4,q.y4,x1,y1,x2,y2))
j+=1;
if(!q.sbx)
{
if(t.inline2(q.x1,q.y1,x1,y1,x2,y2)){
if(t.inline2(q.x2,q.y2,x1,y1,x2,y2)||t.inline2(q.x3,q.y3,x1,y1,x2,y2)){
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
S=t.s;
if(q.xj(x1,y1,x2,y2,q.x2,q.y2,q.x3,q.y3)){
j+=1;
t.sjx(x1,y1,x2,y2,x6,y6);
s1=t.s;
s2=S-t.s;
}
}
}
}
}
class case5{
String[] l=new String[50];
String[] s=new String[50];
double x1, y1;
public void point5(String str){
l=str.split(" ");
zz x=new zz();
samepoint p=new samepoint();
point3 t=new point3();
point4 q=new point4();
q.quadrilateral(str.substring(l[0].length()+1),2);
s=l[0].split(",");
x1 = Double.valueOf(s[0]);y1 = Double.valueOf(s[1]);
if(q.pd(q.x1,q.y1,q.x2,q.y2,q.x3,q.y3,q.x4,q.y4))
{
if(t.inline2(x1,y1,q.x1,q.y1,q.x2,q.y2)||t.inline2(x1,y1,q.x2,q.y2,q.x3,q.y3)||t.inline2(x1,y1,q.x3,q.y3,q.x4,q.y4)||t.inline2(x1,y1,q.x1,q.y1,q.x4,q.y4))
{
System.out.println("on the quadrilateral");
System.exit(0);
}
double S= q.S;
t.sjx(x1,y1,q.x1,q.y1,q.x2,q.y2);double s1=t.s;
t.sjx(x1,y1,q.x2,q.y2,q.x3,q.y3);double s2=t.s;
t.sjx(x1,y1,q.x3,q.y3,q.x4,q.y4);double s3=t.s;
t.sjx(x1,y1,q.x1,q.y1,q.x4,q.y4);double s4=t.s;
if(Math.abs(S-s1-s2-s3-s4)<0.001)
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
else
{
if(t.inline2(x1,y1,q.x1,q.y1,q.x2,q.y2)||t.inline2(x1,y1,q.x2,q.y2,q.x3,q.y3)||t.inline2(x1,y1,q.x3,q.y3,q.x4,q.y4)||t.inline2(x1,y1,q.x1,q.y1,q.x4,q.y4))
{
System.out.println("on the triangle");
System.exit(0);
}
if(p.point(x1,q.x1,y1,q.y1)||p.point(x1,q.x2,y1,q.y2)||p.point(x1,q.x3,y1,q.y3)||p.point(x1,q.x4,y1,q.y4))
{
System.out.println("on the triangle");
System.exit(0);
}
double S= q.S;
t.sjx(x1,y1,q.x1,q.y1,q.x2,q.y2);double s1=t.s;
t.sjx(x1,y1,q.x2,q.y2,q.x3,q.y3);double s2=t.s;
t.sjx(x1,y1,q.x3,q.y3,q.x4,q.y4);double s3=t.s;
t.sjx(x1,y1,q.x1,q.y1,q.x4,q.y4);double s4=t.s;
if(Math.abs(S-s1-s2-s3-s4)<0.001)
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
}
}
class samepoint{
public boolean point(double x1,double x2,double y1,double y2)
{
if(x1==x2&&y1==y2)
return true;
else
return false;
}
}
class zz {
public void z(String s){
if (!s.matches("[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)")||s.matches("[+-]?")||s.length()>6) {
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class point3{
boolean zj;
double l1,l2,l3,k1,k2,k3,s,c;
public void sjx(double x1,double y1,double x2,double y2,double x3,double y3)
{
zj=false;
l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
l2=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
l3=Math.sqrt(Math.pow(x3-x2,2)+Math.pow(y3-y2,2));
if(Math.abs(l1*l1+l3*l3-l2*l2)<0.000001)
zj=true;
k1=(y2-y1)/(x2-x1);
k2=(y3-y1)/(x3-x1);
k3=(y3-y2)/(x3-x2);
c=l1+l2+l3;
s=Math.sqrt((c/2)*(c/2-l1)*(c/2-l2)*(c/2-l3));
}
public boolean pdsjx(double x1,double y1,double x2,double y2,double x3,double y3)
{
if(inline1(x1,y1,x2,y2,x3,y3))
return false;
else
return true;
}
public boolean inline(double x1,double y1,double x2,double y2,double x3,double y3)
{
double l=((y2-y3)*x1-(x2-x3)*y1-y2*x3+y3*x2)/(Math.sqrt((y2-y3)*(y2-y3)+(x2-x3)*(x2-x3)));
if(Math.abs(l)<0.00001)
return true;
else
return false;
}
public boolean in(double x,double y,double x1,double y1,double x2,double y2)
{
if((x>x1&&x<x2||x<x1&&x>x2)&&(y>x1&&y<y2||y>y2&&y<y1))
return true;
else
return false;
}
public boolean inline1(double x1,double y1,double x2,double y2,double x3,double y3)
{
double l=((y2-y3)*x1-(x2-x3)*y1-y2*x3+y3*x2)/(Math.sqrt((y2-y3)*(y2-y3)+(x2-x3)*(x2-x3)));
if(Math.abs(l)<0.00001&&in(x1,y1,x2,y2,x3,y3))
return true;
else
return false;
}
public boolean inline2(double x1,double y1,double x2,double y2,double x3,double y3)
{
double l=((y2-y3)*x1-(x2-x3)*y1-y2*x3+y3*x2)/(Math.sqrt((y2-y3)*(y2-y3)+(x2-x3)*(x2-x3)));
if(Math.abs(l)<0.00001&&(in(x1,y1,x2,y2,x3,y3)||(x1==x2&&y1==y2)||x1==x3&&y1==y3))
return true;
else
return false;
}
}
SourceMonitor生成的报表内容：
类图
代码分析总结：
本次作业如果前面的三角形代码复用性较高的话难度相对三角形提升不高，但我三角形的代码复用性太低了，所以又需要从头开始，但也是与三角形的代码一样没有学会面向对象，导致代码复用性不行，而且因为没有面向对象导致没有拿满分，最后一个选项没有实现。
第四次作业第三题
题目：
设计一个银行业务类
编写一个银行业务类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 welcome()
{
String s="中国银行";
System.out.println(s+"欢迎您的到来！");
}
public static void welcomeNext()
{
System.out.println("请收好您的证件和物品，欢迎您下次光临！");
}
public static void main(String[] args)
{
int i=3;
zz l=new zz();
welcome();
account people=new account();
Scanner in = new Scanner(System.in);
String s=in.nextLine();
l.z(s);
String n = l.S[0];
String p=l.S[1];
people.setName(n);
people.setPassword(p);
// System.out.println("注册成功");
s=in.nextLine();
l.z(s);
p=l.S[0];
Double b=Double.valueOf(l.S[1]);
people.input(p,b);
while(i>0)
{
s=in.nextLine();
l.z(s);
p=l.S[0];
b=Double.valueOf(l.S[1]);
people.output(p,b);
i--;
}
welcomeNext();
}
}
class zz {
public String[] S= new String[1];
public void z(String s){
S=s.split(" ");
}
}
class account {
private String name;
private String password;
private double balance;
public void input(String p,double b)
{
if(!p.equals(getPassword()))
{
System.out.println("您的密码错误！");
}
else
{
this.balance+=b;
System.out.println("您的余额有"+getBalance()+"元。");
}
}
public void output(String p,double b)
{
if(!p.equals(getPassword()))
{
System.out.println("您的密码错误！");
}
else if(b>this.balance)
{
System.out.println("您的余额不足！");
}
else
{
this.balance-=b;
System.out.println("请取走钞票，您的余额还有"+getBalance()+"元。");
}
}
public String getPassword() {
return password;
}
public double getBalance() {
return balance;
}
public void setName(String name) {
this.name = name;
}
public void setPassword(String password) {
this.password = password;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
SourceMonitor生成的报表内容：
类图
代码分析总结：
本次作业因为题目要求写的比较详细，所以对类的定义和调用操作比较简单，代码的复用性较高。
第五次作业第一题
题目：
点线形系列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
试题分析
本次作业是上一次四边形的延申，在四边形的基础上再加一条边变成五边形，但考核的仍然是基于三角形的点与线，点与面的操作，可以把五边形拆分为三个三角形，再利用之前的三角形的代码来优化代码。
源代码展示：
查看代码
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Case case1=new Case(),case2=new Case(),case3=new Case();
Scanner in = new Scanner(System.in);
String S = in.nextLine();
if(!S.matches("^[1-3]:((([+-]?((0|[1-9][0-9]*)(\\.[0-9]+)?)),([+-]?(0|[1-9][0-9]*)(\\.[0-9]+)?))\\s?)+")){
System.out.println("Wrong Format");
return;
}
String[] str = S.split(":");
if ("1".equals(str[0])) {
case1.is(str[1]);
}
if ("2".equals(str[0])) {
case2.dented(str[1]);
}
if ("3".equals(str[0])) {
case3.Cut(str[1]);
}
}
}
class Case{
public void is(String str){
point5 p5=new point5();
p5.pentagon(str);
System.out.println(p5.wbx);
}
public void dented(String str){
point5 p5=new point5();
point3 triangle=new point3();
p5.pentagon(str);
reduce r=new reduce();
if(!p5.wbx){
System.out.println("not a pentagon");
return;
}
triangle.sjx(p5.p[0],p5.p[1],p5.p[2]);
double s1= triangle.s;
triangle.sjx(p5.p[0],p5.p[2],p5.p[3]);
double s2= triangle.s;
triangle.sjx(p5.p[0],p5.p[3],p5.p[4]);
double s3= triangle.s;
p5.S= s1+s2+s3;
int i;
for(i=0;i<p5.p.length;i++){
int a=i+1;if(a>4) a=a-5;
int b=i+2;if(b>4) b=b-5;
int c=i+3;if(c>4) c=c-5;
int d=i+4;if(d>4) d=d-5;
triangle.sjx(p5.p[i],p5.p[a],p5.p[b]);
s1= triangle.s;
triangle.sjx(p5.p[i],p5.p[b],p5.p[c]);
s2= triangle.s;
triangle.sjx(p5.p[i],p5.p[c],p5.p[d]);
s3= triangle.s;
if(Math.abs(p5.S-s1-s2-s3)>0.0001){
System.out.println("false");
return;
}
}
p5.S=r.exchange(p5.S);p5.c=r.exchange(p5.c);
System.out.println("true"+" "+p5.c+" "+p5.S);
}
public void Cut(String str){
point7 p7=new point7();
p7.cut(str);
System.out.println(p7.jd+" "+p7.s1+" "+p7.s2);
}
}
class point7{
String[] input = new String[30];
String[] s = new String[30];
point1[] p=new point1[7];
point2 l=new point2();
double S,s1,s2;
int jd=0;
public void cut(String str){
int i, j;
point3 p3=new point3();
input = str.split(" ");
for (i = 0; i < input.length; i++)
s = input[i].split(",");
if (input.length !=7) {
System.out.println("wrong number of points");
System.exit(0);
}
for(i=0;i<input.length;i++){
p[i]=new point1();
p[i].point(input[i]);
}
l.get(p[0],p[1]);
ArrayList line1=new ArrayList();ArrayList line2=new ArrayList();ArrayList line3=new ArrayList();
line2.add(input[2]);
for(i=2;i<input.length;i++){
line1.add(input[i]);
}
for(i=1;i<line1.size();i++){
if(line1.get(i)!=line2.get(i-1<0? i+4:i-1)){
continue;
}
if(i==line1.size()-1){
line2.add(line1.get(i));
}
}
for(i=0;i<line2.size();i++){
point2 l1=new point2();
l1.get(p[(i-1<0? i+4:i-1)+2],p[(i+1>4? i-4:i+1)+2]);
if(p3.in(p[i+2],l1)){
line3.add(line2.get(i));
}
}
if(line3.size()<3){
System.out.println("not a polygon");
return;
}
if(line3.size()==3){
point3 triangle = new point3();
point1[] p=new point1[3];
for(i=0;i<line3.size();i++){
p[i].point(String.valueOf(line3.get(i)));
}
triangle.sjx(p[0],p[1],p[2]);
S=triangle.s;
}
if(line3.size()==4){
point4 p4=new point4();
point1[] p=new point1[4];
for(i=0;i<line3.size();i++){
p[i].point(String.valueOf(line3.get(i)));
}
p4.quadrilateral(p[0],p[1],p[2],p[3]);
S=p4.S;
}
if(line3.size()==5){
point5 p5=new point5();
String line=""+input[2]+input[3]+input[4]+input[5]+input[6];
p5.pentagon(line);
S=p5.S;
}
}
public void cut1(point2 l1,point3 triangle){
}
}
class point5{
String[] input = new String[30];
String[] s = new String[30];
point1[] p=new point1[5];
point2[] l=new point2[5];
boolean wbx=true;
double S,c;
public void pentagon(String str) {
input = str.split(" ");
point1 p1=new point1();//交点
point2 line =new point2();
point3 triangle = new point3();
point4 p4=new point4();
int i, j;
for (i = 0; i < input.length; i++)
s = input[i].split(",");
if (input.length != 5) {
System.out.println("wrong number of points");
System.exit(0);
}
for(i=0;i<input.length;i++){
p[i]=new point1();
p[i].point(input[i]);
}
for(i=0,j=0;i<l.length;i++,j++){
if(j==5) break;
int z=i+1;
if(z>4)z=z-5;
l[i]=new point2();
l[i].get(p[i],p[z]);
}
for(i=0;i<l.length;i++){
for(j=i+1;j<l.length;j++){
if (line.samepoint(p[i], p[j])) {
wbx=false;return;
}
}
}
for(i=0;i<5;i++) {
j = i + 1;
if (j > 4) j = j - 5;
int z;
for(z=0;z<3;z++){
if(triangle.in(p[i],l[j])){
wbx=false;return;
}
}
}
for(i=0;i<5;i++){
j=i+2;j=j%5;
int a=i+1;if(a>4) a=a-5;
int z;
if(p4.parallel(l[i],l[a])){
wbx=false;
return;
}
for(z=0;z<2;z++){
if(p4.xj(l[i],l[j])){
p4.jd(l[i],l[j],p1);
if(triangle.in(p1,l[i])||triangle.in(p1,l[j])){
wbx=false;
return;
}
}
j++;j=j%5;
}
}
for(i=0;i<l.length;i++){
c+=l[i].len;
}
}
}
class point4 {
double S;
point2 l1=new point2();point2 l2=new point2();point2 l3=new point2();point2 l4=new point2();
public void quadrilateral(point1 p1,point1 p2,point1 p3,point1 p4){
l1.get(p1,p2);l2.get(p2,p3);l3.get(p3,p4);l4.get(p4,p1);
point3 triangle1 = new point3();point3 triangle2 = new point3();
triangle1.sjx(p1,p2,p3);triangle2.sjx(p1,p3,p4);
S=triangle1.s+triangle2.s;
}
public boolean xj(point2 l1,point2 l2)
{
double x,y;
if(l1.A*l2.B==l2.A*l1.B)
return false;
x=(l2.B*l1.C-l1.B*l2.C)/(l1.B*l2.A-l2.B*l1.A);
y=(l2.A*l1.C-l1.A*l2.C)/(l1.A*l2.B-l2.A*l1.B);
if((x>l1.p1.x&&x<l1.p2.x||x<l1.p1.x&&x>l1.p2.x)&&(y>l1.p1.y&&y<l1.p2.y||y>l1.p2.y&&y<l1.p1.y))
return true;
else
return false;
}
public void jd(point2 l1,point2 l2,point1 p) {
p.x=(l2.B*l1.C-l1.B*l2.C)/(l1.B*l2.A-l2.B*l1.A);
p.y=(l2.A*l1.C-l1.A*l2.C)/(l1.A*l2.B-l2.A*l1.B);
}
public boolean parallel(point2 l1,point2 l2){//平行
if(l1.k==l2.k)
return true;
else
return false;
}
}
class point1{
double x,y;
public void point(String l){
String[] s=l.split(",");
x = Double.valueOf(s[0]);
y = Double.valueOf(s[1]);
}
}
class point2{
double len,k,A,B,C;
point1 p1,p2;
public boolean samepoint(point1 p1,point1 p2)
{
if(p1.x==p2.x&&p1.y==p2.y)
return true;
else
return false;
}
public void get(point1 p1,point1 p2){
this.p1=p1;this.p2=p2;
len=Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
k=(p2.y-p1.y)/(p2.x-p1.x);
A=p1.y-p2.y;B=p2.x-p1.x;C=p2.y*p1.x-p1.y*p2.x;
}
}
class point3{
point2 l1,l2,l3;
double s,c;
public void sjx(point1 p1,point1 p2,point1 p3)
{
l1=new point2();l2=new point2();l3=new point2();
l1.get(p1,p2);l2.get(p1,p3);l3.get(p2,p3);
c=l1.len+l2.len+l3.len;
s=Math.sqrt((c/2)*(c/2-l1.len)*(c/2-l2.len)*(c/2-l3.len));
}
public double ptol(point1 p1,point2 l2){//点到直线距离
double l=(l2.A*p1.x+l2.B*p1.y+l2.C)/(Math.sqrt(l2.A*l2.A+l2.B*l2.B));
return l;
}
public boolean in(point1 p1,point2 l2)
{
point2 l=new point2();
if(l.samepoint(p1,l2.p1)||l.samepoint(p1,l2.p2))
return true;
if((p1.x-l2.p1.x)*(p1.x-l2.p2.x)<=0&&(p1.y-l2.p1.y)*(p1.y-l2.p2.y)<=0)
return true;
else
return false;
}
}
class reduce{
public double exchange(double a){
String c=String.format("%."+3+"f",a);a= Double.parseDouble(c);
return a;
}
}
SourceMonitor生成的报表内容：
类图
代码分析总结：
吸取了前面两次夺得教训，这次的代码我进行了重构，对点线面三个类继续了详细的分工，但因为在前一次作业上花费了太多时间，导致我没有时间做完这题。
第五次作业第二题
题目：
点线形系列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
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
试题分析
本题是上一题的延申，在构建完五边形后进行面与面，点与面的判断，但涉及的方法和特殊情况非常多且复杂。
源代码展示：
查看代码
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Case case1=new Case(),case2=new Case(),case3=new Case();
Scanner in = new Scanner(System.in);
String S = in.nextLine();
if(!S.matches("^[1-6]:((([+-]?((0|[1-9][0-9]*)(\\.[0-9]+)?)),([+-]?(0|[1-9][0-9]*)(\\.[0-9]+)?))\\s?)+")){
System.out.println("Wrong Format");
return;
}
String[] str = S.split(":");
if ("6".equals(str[0])) {
case3.Cut(str[1]);
}
}
}
class Case{
public void Cut(String str){
point6 p6=new point6();
p6.cut(str);
if(p6.line3.size()==3)
p6.cut1(p6.p[0],p6.triangle);
}
}
class point6{
String[] input = new String[30];
String[] s = new String[30];
point1[] p=new point1[7];
point3 triangle = new point3();
point4 p4=new point4();
point5 p5=new point5();
double S;
ArrayList line1=new ArrayList();ArrayList line2=new ArrayList();ArrayList line3=new ArrayList();
public void cut(String str){
int i,j;
point3 p3=new point3();
input = str.split(" ");
for (i = 0; i < input.length; i++)
s = input[i].split(",");
if (input.length !=6) {
System.out.println("wrong number of points");
System.exit(0);
}
for(i=0;i<input.length;i++){
p[i]=new point1();
p[i].point(input[i]);
}
line2.add(input[2]);
for(i=2;i<input.length;i++){
line1.add(input[i]);
}
for(i=1;i<line1.size();i++){
boolean same=false;
for(j=0;j<line2.size();j++){
if(line1.get(i)==line2.get(j))
same=true;
}
if(same==false)
line2.add(line1.get(i));
}
for(i=0;i<line2.size();i++){
point2 l1=new point2();
l1.get(p[(i-1<0? i+line2.size():i-1)+1],p[(i>line2.size()-1? i-line2.size()-1:i+1)+1]);
if(!p3.in(p[i+1],l1)){
line3.add(line2.get(i));
}
}
if(line3.size()<3){
System.out.println("not a polygon");
return;
}
if(line3.size()==3){
point1[] p=new point1[3];
for(i=0;i<line3.size();i++){
p[i]=new point1();
p[i].point(line3.get(i).toString());
}
triangle.sjx(p[0],p[1],p[2]);
S=triangle.s;
}
if(line3.size()==4){
point1[] p=new point1[4];
for(i=0;i<line3.size();i++){
p[i].point(String.valueOf(line3.get(i)));
}
p4.quadrilateral(p[0],p[1],p[2],p[3]);
S=p4.S;
}
if(line3.size()==5){
String line=""+input[1]+input[2]+input[3]+input[4]+input[5];
p5.pentagon(line);
S=p5.S;
}
}
public void cut1(point1 p1, point3 triangle){
point3 triangle1=new point3();point3 triangle2=new point3();point3 triangle3=new point3();
point3 p3=new point3();
point2 l=new point2();
triangle1.sjx(p1,triangle.p1,triangle.p2);triangle2.sjx(p1,triangle.p2,triangle.p3);triangle3.sjx(p1, triangle.p1, triangle.p3);
if(l.samepoint(p1,triangle.p1)||l.samepoint(p1,triangle.p2)||l.samepoint(p1,triangle.p3)){
System.out.println("on the triangle");
System.exit(0);
}
if(p3.in(p1,triangle.l1)||p3.in(p1,triangle.l2)||p3.in(p1,triangle.l3)){
System.out.println("on the triangle");
System.exit(0);
}
if(Math.abs(S-triangle1.s-triangle2.s-triangle3.s)<0.001){
System.out.println("in the triangle");
}
else {
System.out.println("outof the triangle");
}
}
}
class point5{
String[] input = new String[30];
String[] s = new String[30];
point1[] p=new point1[5];
point2[] l=new point2[5];
boolean wbx=true;
double S,c;
public void pentagon(String str) {
input = str.split(" ");
point1 p1=new point1();//交点
point2 line =new point2();
point3 triangle = new point3();
point4 p4=new point4();
int i, j;
for (i = 0; i < input.length; i++)
s = input[i].split(",");
if (input.length != 5) {
System.out.println("wrong number of points");
System.exit(0);
}
for(i=0;i<input.length;i++){
p[i]=new point1();
p[i].point(input[i]);
}
for(i=0,j=0;i<l.length;i++,j++){
if(j==5) break;
int z=i+1;
if(z>4)z=z-5;
l[i]=new point2();
l[i].get(p[i],p[z]);
}
for(i=0;i<l.length;i++){
for(j=i+1;j<l.length;j++){
if (line.samepoint(p[i], p[j])) {
wbx=false;return;
}
}
}
for(i=0;i<5;i++) {
j = i + 1;
if (j > 4) j = j - 5;
int z;
for(z=0;z<3;z++){
if(triangle.in(p[i],l[j])){
wbx=false;return;
}
}
}
for(i=0;i<5;i++){
j=i+2;j=j%5;
int a=i+1;if(a>4) a=a-5;
int z;
if(p4.parallel(l[i],l[a])){
wbx=false;
return;
}
for(z=0;z<2;z++){
if(p4.xj(l[i],l[j])){
p4.jd(l[i],l[j],p1);
if(triangle.in(p1,l[i])||triangle.in(p1,l[j])){
wbx=false;
return;
}
}
j++;j=j%5;
}
}
for(i=0;i<l.length;i++){
c+=l[i].len;
}
}
}
class point4 {
double S;
point1 p1=new point1(),p2=new point1(),p3=new point1(),p4=new point1();
point2 l1=new point2();point2 l2=new point2();point2 l3=new point2();point2 l4=new point2();
public void quadrilateral(point1 p1,point1 p2,point1 p3,point1 p4){
this.p1=p1;this.p2=p2;this.p3=p3;this.p4=p4;
l1.get(p1,p2);l2.get(p2,p3);l3.get(p3,p4);l4.get(p4,p1);
point3 triangle1 = new point3();point3 triangle2 = new point3();
triangle1.sjx(p1,p2,p3);triangle2.sjx(p1,p3,p4);
S=triangle1.s+triangle2.s;
}
public boolean xj(point2 l1,point2 l2)
{
double x,y;
if(l1.A*l2.B==l2.A*l1.B)
return false;
x=(l2.B*l1.C-l1.B*l2.C)/(l1.B*l2.A-l2.B*l1.A);
y=(l2.A*l1.C-l1.A*l2.C)/(l1.A*l2.B-l2.A*l1.B);
if((x>l1.p1.x&&x<l1.p2.x||x<l1.p1.x&&x>l1.p2.x)&&(y>l1.p1.y&&y<l1.p2.y||y>l1.p2.y&&y<l1.p1.y))
return true;
else
return false;
}
public void jd(point2 l1,point2 l2,point1 p) {
p.x=(l2.B*l1.C-l1.B*l2.C)/(l1.B*l2.A-l2.B*l1.A);
p.y=(l2.A*l1.C-l1.A*l2.C)/(l1.A*l2.B-l2.A*l1.B);
}
public boolean parallel(point2 l1,point2 l2){//平行
if(l1.k==l2.k)
return true;
else
return false;
}
}
class point1{
double x,y;
public void point(String l){
String[] s=l.split(",");
x = Double.valueOf(s[0]);
y = Double.valueOf(s[1]);
}
}
class point2{
double len,k,A,B,C;
point1 p1,p2;
public boolean samepoint(point1 p1,point1 p2)
{
if(p1.x==p2.x&&p1.y==p2.y)
return true;
else
return false;
}
public void get(point1 p1,point1 p2){
this.p1=p1;this.p2=p2;
len=Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
k=(p2.y-p1.y)/(p2.x-p1.x);
A=p1.y-p2.y;B=p2.x-p1.x;C=p2.y*p1.x-p1.y*p2.x;
}
}
class point3{
point1 p1=new point1(),p2=new point1(),p3=new point1();
point2 l1,l2,l3;
double s,c;
public void sjx(point1 p1,point1 p2,point1 p3)
{
this.p1=p1;this.p2=p2;this.p3=p3;
l1=new point2();l2=new point2();l3=new point2();
l1.get(p1,p2);l2.get(p1,p3);l3.get(p2,p3);
c=l1.len+l2.len+l3.len;
s=Math.sqrt((c/2)*(c/2-l1.len)*(c/2-l2.len)*(c/2-l3.len));
}
public double ptol(point1 p1,point2 l2){//点到直线距离
double l=(l2.A*p1.x+l2.B*p1.y+l2.C)/(Math.sqrt(l2.A*l2.A+l2.B*l2.B));
return l;
}
public boolean in(point1 p1,point2 l2)
{
point2 l=new point2();
if(l.samepoint(p1,l2.p1)||l.samepoint(p1,l2.p2))
return true;
if((p1.x-l2.p1.x)*(p1.x-l2.p2.x)<=0&&(p1.y-l2.p1.y)*(p1.y-l2.p2.y)<=0)
return true;
else
return false;
}
}
class reduce{
public double exchange(double a){
String c=String.format("%."+3+"f",a);a= Double.parseDouble(c);
return a;
}
}
SourceMonitor生成的报表内容：
类图
代码分析总结：
因为时间不够，所以我只简略写了一下选项6，上一题重构代码后我代码的复用性明显提高了不少，也认识到了正确分类的重要性，但对于点与线这种两个类之间进行计算的操作我还是不怎么熟练，不知道是要重新开一个类还是在两者其中一个类中定义方法来进行操作，还是要多去向同学学习
期中考试第一题
题目：
点与线（类设计）
设计一个类表示平面直角坐标系上的点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:长度值
试题分析
本题因为给出了类图，所以只要对着类图去定义类和函数就行
源代码展示：
查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double x1 ,x2,y1,y2;
try{
x1 = input.nextDouble(); y1= input.nextDouble();
x2= input.nextDouble();y2= input.nextDouble();
}
catch(Exception InInitializerError){
System.out.println("Wrong Format");return;
}
if(x1<0||x1>200||y1<0||y1>200||x2<0||x2>200||y2<0||y2>200){
System.out.println("Wrong Format");return;
}
String color= input.next();
Point1 point1=new Point1(x1,y1);
Point1 point2=new Point1(x2,y2);
Line line=new Line(point1,point2,color);
line.display();
}
}
class 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;
}
private double x;
private double y;
Point1(double x,double y){
this.x=x;this.y=y;
}
public void display(){
System.out.println("("+String.format("%.2f", this.getX())+","+String.format("%.2f", this.getY())+")");
}
}
class Line{
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;
}
private Point1 point1;
private Point1 point2;
private String color;
Line(Point1 point1,Point1 point2,String color){
this.point1=point1;this.point2=point2;this.color=color;
}
public void display(){
System.out.println("The line's color is:" +this.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.print("The line's length is:");
System.out.println(String.format("%.2f", getDistance()));
}
public double getDistance(){
double len=Math.sqrt(Math.pow(this.point2.getX()-this.point1.getX(),2)+Math.pow(this.point2.getY()-this.point1.getY(),2));
return len;
}
}
SourceMonitor生成的报表内容：
（因为我在电脑上写代码时是在上一题的代码中修改的，所以电脑上只保存了第三题的代码文件故三题的报表内容会一致）
类图
略
代码分析总结：
因为给出了类图，所以难度不高，代码的复用性也较高，复杂性也较低。
期中考试第二题
题目：
点线面问题重构（继承与多态）
在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。
对题目中的点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:颜色值
试题分析
本题只是在上一题的基础上增加了一个父类，按照给的类图写就行
源代码展示：
查看代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double x1 ,x2,y1,y2;
try{
x1 = input.nextDouble(); y1= input.nextDouble();
x2= input.nextDouble();y2= input.nextDouble();
}
catch(Exception InInitializerError){
System.out.println("Wrong Format");return;
}
if(x1<0||x1>200||y1<0||y1>200||x2<0||x2>200||y2<0||y2>200){
System.out.println("Wrong Format");return;
}
String color= input.next();
Point1 point1=new Point1(x1,y1);
Point1 point2=new Point1(x2,y2);
Line line=new Line(point1,point2,color);
Plane plane=new Plane(color);
Element element;
element = point1;//起点Point
element.display();
element = point2;//终点Point
element.display();
element = line;//线段
element.display();
element = plane;//面
element.display();
}
}
class Point1 extends Element{
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;
}
private double x;
private double y;
Point1(double x,double y){
this.x=x;this.y=y;
}
void display(){
System.out.println("("+String.format("%.2f", this.getX())+","+String.format("%.2f", this.getY())+")");
}
}
class Line extends Element{
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;
}
private Point1 point1;
private Point1 point2;
private String color;
Line(Point1 point1,Point1 point2,String color){
this.point1=point1;this.point2=point2;this.color=color;
}
public double getDistance(){
double len=Math.sqrt(Math.pow(this.point2.getX()-this.point1.getX(),2)+Math.pow(this.point2.getY()-this.point1.getY(),2));
return len;
}
@Override
void display() {
System.out.println("The line's color is:" +this.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.print("The line's length is:");
System.out.println(String.format("%.2f", getDistance()));
}
}
abstract class Element{
abstract void display();
}
class Plane extends Element{
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
private String color;
Plane(String color){
this.color=color;
}
@Override
void display() {
System.out.println("The Plane's color is:"+this.getColor());
}
}
SourceMonitor生成的报表内容：
类图
略
代码分析总结：
本题只是在上一题的基础上增加一个面类以及增加一个父类，让点线面类继承父类，对上一题稍作修改就行。
期中考试第三题
题目：
点线面问题再重构（容器类）
在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
在原有类设计的基础上，增加一个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超出合法范围，程序自动忽略该操作
试题分析
本题引入了ArrayList，还增加了删除和增加的操作要求。
源代码展示：
查看代码
package 期中考试;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double x1 ,x2,y1,y2;
String color;
GeometryObject g=new GeometryObject();
try{
x1 = input.nextDouble(); y1= input.nextDouble();
x2= input.nextDouble();y2= input.nextDouble();
}
catch(Exception InInitializerError){
System.out.println("Wrong Format");return;
}
if(x1<0||x1>200||y1<0||y1>200||x2<0||x2>200||y2<0||y2>200){
System.out.println("Wrong Format");return;
}
int choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
try{
x1 = input.nextDouble(); y1= input.nextDouble();
}
catch(Exception InInitializerError){
System.out.println("Wrong Format");return;
}
if(x1<0||x1>200||y1<0||y1>200){
System.out.println("Wrong Format");return;
}
Element point=new Point1(x1,y1);
g.add(point);
break;
case 2://insert Line object into list
try{
x1 = input.nextDouble(); y1= input.nextDouble();
x2= input.nextDouble();y2= input.nextDouble();
}
catch(Exception InInitializerError){
System.out.println("Wrong Format");return;
}
if(x1<0||x1>200||y1<0||y1>200||x2<0||x2>200||y2<0||y2>200){
System.out.println("Wrong Format");return;
}
color= input.next();
Point1 point1=new Point1(x1,y1);
Point1 point2=new Point1(x2,y2);
Element line=new Line(point1,point2,color);
g.add(line);
break;
case 3://insert Plane object into list
color= input.next();
Element plane=new Plane(color);
g.add(plane);
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
g.remove(index);
}
choice = input.nextInt();
}
for(Element element:g.list){
element.display();
}
}
}
class Point1 extends Element{
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;
}
private double x;
private double y;
Point1(double x,double y){
this.x=x;this.y=y;
}
void display(){
System.out.println("("+String.format("%.2f", this.getX())+","+String.format("%.2f", this.getY())+")");
}
}
class Line extends Element{
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;
}
private Point1 point1;
private Point1 point2;
private String color;
Line(Point1 point1,Point1 point2,String color){
this.point1=point1;this.point2=point2;this.color=color;
}
public double getDistance(){
double len=Math.sqrt(Math.pow(this.point2.getX()-this.point1.getX(),2)+Math.pow(this.point2.getY()-this.point1.getY(),2));
return len;
}
@Override
void display() {
System.out.println("The line's color is:" +this.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.print("The line's length is:");
System.out.println(String.format("%.2f", getDistance()));
}
}
abstract class Element{
abstract void display();
}
class Plane extends Element{
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
private String color;
Plane(String color){
this.color=color;
}
@Override
void display() {
System.out.println("The Plane's color is:"+this.getColor());
}
}
class GeometryObject{
GeometryObject(){
}
ArrayList<Element> list=new ArrayList<Element>();
public void add(Element element){
list.add(element);
}
public void remove(int index){
list.remove(index-1);
}
public ArrayList<Element> getList() {
return list;
}
}
SourceMonitor生成的报表内容：
类图
略
代码分析总结：
本题是对上一题按照给予的类图进行修改，但因为时间有限，在考试时没能写完，在考完回寝室之后才写完代码。
3.踩坑心得：
在写期中考试的题目时忘记用try来判断错误输入了，导致卡了较久。
4.改进建议
在写题时要先对题目总体进行分析，先画出类图的大致框架再去码代码，这样写题速度会提升较多。
要学会去使用继承与多态来简化代码。
5.总结
1.通过这几次作业，我对类的分工越来越熟练，提升也比较明显，也认识到了细分类的重要性，代码的复杂度在不断降低，复用性在不断上升。
2.今后也要重视问题分析，仔细分类，也多去了解多态的使用。
3.写代码考虑得不全面，导致经常有些测试点别人一遍过而我要卡半天。
4.如果实在无法理解题目可以去网上看看前辈们的思路，看看他们的类是怎么定义的，而不是明明看不懂题目还要去摁敲代码，到头来测试点又过不去，又浪费了大量时间。
