PTA- JAVA题目集（一）总结与经验
PTA- JAVA题目集（一）总结与经验
输入格式:
输出格式:
过滤掉空闲、起始、结束以及奇偶校验位之后的数据，数据之前加上序号和英文冒号。
如有多个数据，每个数据单独一行显示。
若数据不足11位或者输入数据全1没有起始位，则输出"null data"，
若某个数据的结束符不为1，则输出“validate error”。
若某个数据奇偶校验错误，则输出“parity check error”。
若数据结束符和奇偶校验均不合格，输出“validate error”。
如：11011或11111111111111111。例如：1:11101011 2:01001101 3:validate error
解决代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str1;
str1=in.nextLine();
int cnt=1;
int c=0;
if(str1.length()==10&&str1.charAt(9)=='1'){
System.out.print("null data");
}else {
for(int i=0;i<str1.length();i++) {
if(str1.charAt(i)=='0') {
if(str1.length()-i<10&&cnt==1) {
c=1;
System.out.print("null data");
System.out.print("\n");
break;
}
int ks=0;
for(int j=i+1;j<=i+8;j++){
if(str1.charAt(j)=='1'){
ks++;
}
}
if(ks%2==0){
if(str1.charAt(i+9)=='0'&&str1.charAt(i+10)!='0') {
System.out.print(cnt+":");
System.out.print("parity check error");
}else if(str1.charAt(i+10)=='0'){
System.out.print(cnt+":");
System.out.print("validate error");
}else {
System.out.print(cnt+":");
for(int j=i+1;j<=i+8;j++) {
System.out.print(str1.charAt(j));
}
}
i+=10;
cnt++;
System.out.print("\n");
}else {
if(str1.charAt(i+9)=='1'&&str1.charAt(i+10)!='0') {
System.out.print(cnt+":");
System.out.print("parity check error");
}else if(str1.charAt(i+10)=='0'){
System.out.print(cnt+":");
System.out.print("validate error");
}else {
System.out.print(cnt+":");
for(int j=i+1;j<=i+8;j++) {
System.out.print(str1.charAt(j));
}
}
i+=10;
cnt++;
System.out.print("\n");
}
}
}
if(c==0&&cnt==1){
System.out.print("null data");
}
}
in.close();
}
}
-
采坑心得：题目中是过滤后的数据长度大于11，而不是输入的数据长度大于11
-
改进建议：将Main的功能分散，增加代码的可读性
-
总结心得：写JAVA的代码时，不应该将目光放在实现结果上，而是应该关注代码的总体结构，结构清晰分工明确，实现代码也就又快又准；
问题1. 7-1 点线形系列1-计算两点之间的距离 (10 分)
- 输入连个点的坐标，计算两点之间的距离
- 输入格式:
- 4个double类型的实数，两个点的x，y坐标，依次是x1、y1、x2、y2，两个点的坐标之间以空格分隔，每个点的x,y坐标以英文“,”分隔。例如：0,0 1,1或0.1,-0.3 +3.5,15.6。
- 若输入格式非法，输出"Wrong Format"。
- 若输入格式合法但坐标点的数量超过两个，输出“wrong number of points”。
- 输出格式:
- 计算所得的两点之间的距离。例如：1.4142135623730951
问题2. 7-2 点线形系列2-线的计算 (42 分)
-
用户输入一组选项和数据，进行与直线有关的计算。选项包括：
1：输入两点坐标，计算斜率，若线条垂直于X轴，输出"Slope does not exist"。
2：输入三个点坐标，输出第一个点与另外两点连线的垂直距离。
3：输入三个点坐标，判断三个点是否在一条线上，输出true或者false。
4：输入四个点坐标，判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false.
5：输入四个点坐标，计算输出前两个点所构成的直线与后两点构成的直线的交点坐标，x、y坐标之间以英文分隔","，并输出交叉点是否在两条线段之内（不含四个端点）的判断结果(true/false)，判断结果与坐标之间以一个英文空格分隔。若两条线平行，没有交叉点，则输出"is parallel lines,have no intersection point"。输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。
例如：1:0,0 1,1
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"，问题3. 7-3 点线形系列3-三角形的计算 (48 分)用户输入一组选项和数据，进行与三角形有关的计算。选项包括：
1：输入三个点坐标，判断是否是等腰三角形、等边三角形，判断结果输出true/false，两个结果之间以一个英文空格符分隔。
2：输入三个点坐标，输出周长、面积、重心坐标，三个参数之间以一个英文空格分隔，坐标之间以英文","分隔。
3：输入三个点坐标，输出是钝角、直角还是锐角三角形，依次输出三个判断结果（true/false），以一个英文空格分隔，
4：输入五个点坐标，输出前两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。若直线与三角形一条线重合，输出"The point is on the edge of the triangle"
5：输入四个点坐标，输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）。
必须使用射线法，原理：由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。如果交点有两个或0个，则在三角形之外。若点在三角形的某条边上，输出"on the triangle"输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
如果输入的三个点无法构成三角形，输出"data error"。
注意：输出的数据若小数点后超过6位，只保留小数点后6位，多余部分采用四舍五入规则进到最低位。小数点后若不足6位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333333，1.0按格式输出为1.0选项4中所输入线的两个点坐标重合，输出"points coincide"，
1.设计Java程序时先构思类
- public class Main{}//解决指令问题 class point{} //解决点问题 class line{}//解决线问题 class triangle{} //解决三角形问题
- 错误写法：只有一个类Main,所有问题交给main方法执行，无法做到资源的重复利用，从而减少解决相关问题时间和资源；
2.设计类（分析类的职能与作用）
- Main类-------接受输入，解析输入，检查输入，调用point ,line,triangle完成输入指令
a. public static void main(String[] args) // 执行主功能
b.public static boolean chack_in(String a) // 检查是否符合格式
c.public static boolean chack_pointsum(String a) // 检查点数量是否符合
e.public static void operation1() //操作一
..........
- Point类-------包含点的属性（横坐标x，纵坐标），对坐标进行赋值，计算点到另外的点的距离
a.double x;double y; //定义横坐标x,纵坐标y
b.public void input(Arraylist<String> a); //给x,y赋值
c.public double calculatedistance(Point p) //计算点到另一点的距离
d.public boolean chack_point(Point p); //判断两点是否重合
- Line类---------包含线的属性（点p1，点p2)，计算线的斜率，计算另外一点到直线距离，判断点是否在直线上，判断两直线是否平行，计算两直线交点；
a.Point p1 = new Point();Point p2 = new Point();
b.public void input(Arraylist<String> a); //给点p1,p2赋值
c.public double calculate_slope(void); //计算线的斜率
d.public double calculate_distance(Point p); //计算另外一点到直线的距离
e.public int if_on_line(Point p); //判断点是否在直线上
f.public boolean if_parallel(Line l); //判断另外一直线是否与该直线平行
g.public Point intersection(Line l)； //计算另外一直线与该直线的交点
h.public boolean chack_slope() //检查线段斜率是否存在
- Triangle类------包含三角形的属性（点p1，点p2 , 点p3），根据边长判断三角形类型（边，角），计算三角形面积，周长以及重心坐标，计算直线与三角形的交点个数，判断点是否在三角形的内部
a.Point p1 = new Point();Point p2 = new Point();Point p3 = new Point();
b.public void input(Arraylist<String> a); //给点p1,p2，p3赋值
c.public int if_edge_shape(); //根据边判断三角形的形状
d.public int if_horn_shape(); //根据角判断三角形的形状
e.public double caluate_C()； //计算三角形的周长
f.public double caluate_S()； //计算三角形的面积
g.public Point caluate_gravity_point()； //计算三角形的重心
h.public int caluate_sum_intersection()； //计算直线与三角形的交点个数
i.public Point if_inside()； //判断点是否在三角形内部
j.public boolean chack_triangle()； //判断三角形是否合法
注意点：设计类中的方法时应该体现“封装性”，尽量不要进行与类无关的输出和返回 ，确保方法能够再次利用
错误示范：
public void countk() {
if(Math.abs(p1.x-p2.x)<1e-15) {
System.out.print("Slope does not exist");
}else {
System.out.print((p1.y-p2.y)/(p1.x-p2.x));
}
}
其中将Main类中指令操作（计算斜率）的输出结果放进了Line类中计算斜率的方法中，而不返回。导致后续代码无法引用计算斜率；
3.问题三改进后的代码：
import java.text.NumberFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String a = in.nextLine();
if(chack_in(a)) {
System.out.print("");
}else if(chack_point_sum(a)) {
System.out.print("");
}else {
String[] aa = a.split(":");
String[] point = aa[1].split(" ");
switch(aa[0]) {
case "1":
operation_1(point);
break;
case "2":
operation_2(point);
break;
case "3":
operation_3(point);
break;
case "4":
operation_4(point);
break;
case "5":
operation_5(point);
break;
}
}
in.close();
}
//操作1//
public static void operation_1(String[] point) {
Triangle triangle = new Triangle();
String[] point1 = point[0].split(",");
String[] point2 = point[1].split(",");
String[] point3 = point[2].split(",");
triangle.p1.input(Double.parseDouble(point1[0]), Double.parseDouble(point1[1]));
triangle.p2.input(Double.parseDouble(point2[0]), Double.parseDouble(point2[1]));
triangle.p3.input(Double.parseDouble(point3[0]), Double.parseDouble(point3[1]));
if(triangle.chack_triangle()){
System.out.print("data error");
}else {
if(triangle.shape_line_triangle()==1) {
System.out.print("true true");
}else {
System.out.print("true false");
}
}
}
//操作2//
public static void operation_2(String[] point) {
Triangle triangle = new Triangle();
String[] point1 = point[0].split(",");
String[] point2 = point[1].split(",");
String[] point3 = point[2].split(",");
triangle.p1.input(Double.parseDouble(point1[0]), Double.parseDouble(point1[1]));
triangle.p2.input(Double.parseDouble(point2[0]), Double.parseDouble(point2[1]));
triangle.p3.input(Double.parseDouble(point3[0]), Double.parseDouble(point3[1]));
if(triangle.chack_triangle()){
System.out.print("data error");
}else {
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(6);
System.out.print(nf.format(triangle.caluate_C())+" "+nf.format(triangle.caluate_S())+" "+
nf.format(triangle.caluate_gravity_point().read_x())+" "+nf.format(triangle.caluate_gravity_point().read_y()));
}
}
//操作3//
public static void operation_3(String[] point) {
Triangle triangle = new Triangle();
String[] point1 = point[0].split(",");
String[] point2 = point[1].split(",");
String[] point3 = point[2].split(",");
triangle.p1.input(Double.parseDouble(point1[0]), Double.parseDouble(point1[1]));
triangle.p2.input(Double.parseDouble(point2[0]), Double.parseDouble(point2[1]));
triangle.p3.input(Double.parseDouble(point3[0]), Double.parseDouble(point3[1]));
if(triangle.chack_triangle()){
System.out.print("data error");
}else {
if(triangle.shape_horn_triangle()==1) {
System.out.print("false false true");
}else if(triangle.shape_horn_triangle()==0) {
System.out.print("false true false");
}else {
System.out.print("true false false");
}
}
}
//操作4//
public static void operation_4(String[] point) {
Triangle triangle = new Triangle();
Triangle triangle1 = new Triangle();
Line line = new Line();
String[] point1 = point[0].split(",");
String[] point2 = point[1].split(",");
String[] point3 = point[2].split(",");
String[] point4 = point[3].split(",");
String[] point5 = point[4].split(",");
line.p1.input(Double.parseDouble(point1[0]), Double.parseDouble(point1[1]));
line.p2.input(Double.parseDouble(point2[0]), Double.parseDouble(point2[1]));
triangle.p1.input(Double.parseDouble(point3[0]), Double.parseDouble(point3[1]));
triangle.p2.input(Double.parseDouble(point4[0]), Double.parseDouble(point4[1]));
triangle.p3.input(Double.parseDouble(point5[0]), Double.parseDouble(point5[1]));
Line l1 = new Line();
l1.p1=triangle.p1;l1.p2=triangle.p2;
Line l2 = new Line();
l2.p1=triangle.p1;l2.p2=triangle.p3;
Line l3 = new Line();
l3.p1=triangle.p2;l3.p2=triangle.p3;
if(line.p1.chack_point(line.p2)){
System.out.print("points coincide");
}else if(triangle.chack_triangle()){
System.out.print("data error");
}else {
if(line.if_parallel(l3)==0||line.if_parallel(l2)==0||line.if_parallel(l1)==0) {
System.out.print("The point is on the edge of the triangle");
}else {
System.out.print(triangle.caluate_sum_intersection(line));
}
}
}
//操作5//
public static void operation_5(String[] point) {
Triangle triangle = new Triangle();
Point p = new Point();
String[] point1 = point[0].split(",");
String[] point2 = point[1].split(",");
String[] point3 = point[2].split(",");
String[] point4 = point[3].split(",");
p.input(Double.parseDouble(point1[0]), Double.parseDouble(point1[1]));
triangle.p1.input(Double.parseDouble(point2[0]), Double.parseDouble(point2[1]));
triangle.p2.input(Double.parseDouble(point3[0]), Double.parseDouble(point3[1]));
triangle.p3.input(Double.parseDouble(point4[0]), Double.parseDouble(point2[1]));
Line l1 = new Line();
l1.p1=triangle.p1;l1.p2=triangle.p2;
Line l2 = new Line();
l2.p1=triangle.p1;l2.p2=triangle.p3;
Line l3 = new Line();
l3.p1=triangle.p2;l3.p2=triangle.p3;
if(triangle.chack_triangle()){
System.out.print("data error");
}else {
if(l1.if_on_line(p)||l2.if_on_line(p)||l3.if_on_line(p)) {
System.out.print("on the triangle");
}else {
if(triangle.if_inside(p)) {
System.out.print("in the triangle");
}else {
System.out.print("outof the triangle");
}
}
}
}
//检查总字符串的格式//
public static boolean chack_in(String a) {
boolean ttr = false;
String[] aa = a.split(":");
String[] point = aa[1].split(" ");
if(aa[0].length()!=1) {
ttr = true;
}else if(aa[0].charAt(0)!='1'&&aa[0].charAt(0)!='2'&&aa[0].charAt(0)!='3'
&&aa[0].charAt(0)!='4'&&aa[0].charAt(0)!='5') {
ttr = true;
}
if(aa.length!=2) {
ttr = true;
}
for(int i=0;i<point.length;i++) {
if(point[i].length()==0) {
ttr = true ;
}
}
for(int i=0;i<point.length;i++ ) {
for(int j=0;j<point[i].length();j++) {
if(point[i].contains(",")) {
String[] number = point[i].split(",");
if(number.length==2) {
if(number[0].length()>=2) {
if(number[0].charAt(0)=='0'&&number[0].charAt(1)=='0') {
ttr = true;
}
}
if(number[1].length()>=2) {
if(number[1].charAt(0)=='0'&&number[1].charAt(1)=='0') {
ttr = true;
}
}
if(!number[0].matches("^([+-]?\\d+)(.\\d+)?")) {
ttr = true ;
}
if(!number[1].matches("^([+-]?\\d+)(.\\d+)?")) {
ttr = true ;
}
}else {
ttr = true ;
}
}else {
ttr = true ;
}
}
}
return ttr;
}
//检查总字符串所含的点的个数//
public static boolean chack_point_sum(String a) {
boolean arry = false;
int cnt = 0;
String[] aa = a.split(":");
String[] point = aa[1].split(" ");
cnt = point.length;
if(a.charAt(0)=='1'&&cnt!=3) {
arry = true;
}else if(a.charAt(0)=='2'&&cnt!=3) {
arry = true ;
}else if(a.charAt(0)=='3'&&cnt!=3) {
arry = true ;
}else if(a.charAt(0)=='4'&&cnt!=5) {
arry = true ;
}else if(a.charAt(0)=='5'&&cnt!=4) {
arry = true ;
}
return arry;
}
}
//点类//
class Point {
private double x,y;
//读入x y 的值//
public void input(double a,double b) {
x = a;
y = b;
}
//读取x的值//
public double read_x() {
return x;
}
//读取y的值//
public double read_y() {
return y;
}
//计算两点的距离//
public double caluate_distance(Point p) {
return Math.sqrt((x-p.x )*(x-p.x )+(y-p.y )*(y-p.y));
}
//检查线的两点是否重合//
public boolean chack_point(Point p) {
boolean wssa = false ;
if(Math.abs(x-p.read_x())<1e-15&&Math.abs(y-p.read_y())<1e-15) {
wssa = true ;
}
return wssa;
}
}
//线段//
class Line{
Point p1 = new Point();
Point p2 = new Point();
//检查线段的斜率是否存在//
public boolean chack_slope() {
boolean wssa = true ;
if(Math.abs(p1.read_x()-p2.read_x())<1e-15) {
wssa = false ;
}
return wssa;
}
//计算线段的斜率//
public double caluate_slope() {
return (p1.read_x()-p2.read_y())/(p1.read_x()-p2.read_y());
}
//计算点到直线的距离//
public double caluate_distance(Point a) {
double distance ;
if(if_on_line(a)){
distance = 0;
}else {
distance = Math.abs(a.read_x()*p1.read_y()+p1.read_x()*p2.read_y()+p2.read_x()*a.read_y()
-a.read_x()*p2.read_y()-p1.read_x()*a.read_y()-p2.read_x()*p1.read_y())/p1.caluate_distance(p2);
}
return distance ;
}
//判断点是否再直线上//
public boolean if_on_line(Point p) {
boolean jes = false ;
Line l1 = new Line();
Line l2 = new Line();
l1.p1=p1;l1.p2=p;
l2.p1=p2;l2.p2=p;
if(l1.caluate_slope()==l2.caluate_slope()) {
jes = true;
}
return jes;
}
//判断点是否在线段内//
//在线段内返回true，在线段外返回false//
public boolean if_in_line(Point p) {
boolean jes = true ;
if(p.caluate_distance(p1)>p1.caluate_distance(p2)||p.caluate_distance(p2)>p1.caluate_distance(p2)) {
jes = false ;
}
return jes;
}
//判断两直线是否平行//
//若两直线平行返回1，若两直线重合返回0，若两直线相交返回-1
public int if_parallel(Line l) {
int cnt ;
double x1 = (p1.read_x()-p2.read_x())*(l.p1.read_x()-l.p2.read_x())
+(p1.read_y()-p2.read_y())*(l.p1.read_y()-l.p2.read_y());
if(x1/(p1.caluate_distance(p2)*l.p1.caluate_distance(p2))!=1) {
cnt=-1;
}else {
if(l.caluate_distance(p1)==0) {
cnt=0;
}else {
cnt=1;
}
}
return cnt;
}
//计算两直线交点,返回Point//
public Point caluate_intersection(Line a) {
Point p = new Point();
double dx1 = p1.read_x()-p2.read_x();
double dx2 = a.p1.read_x()-a.p2.read_x();
double dy1 = p1.read_x()-p2.read_x();
double dy2 = a.p1.read_x()-a.p2.read_x();
double mid1 = dy1/dx1;
double mid2 = dy2/dx2;
double rx = (a.p2.read_y()-p2.read_y()-a.p2.read_y()*mid2+p2.read_y()*mid1)/(mid1-mid2);
double ry = (rx-p2.read_x())*mid1+p2.read_y();
p.input(rx, ry);
return p;
}
}
//三角形//
class Triangle{
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
//检查三点是否构成三角形//
//若构成三角形返回false,若不构成三角形返回true//
public boolean chack_triangle() {
boolean err = true ;
if(Math.abs(p1.caluate_distance(p2)-p1.caluate_distance(p3))<p2.caluate_distance(p3)
&&Math.abs(p1.caluate_distance(p3)+p1.caluate_distance(p2))>p2.caluate_distance(p3)){
err = false ;
}
return err ;
}
//判断是否为等边三角形，或等腰三角形//
//若为等腰三角形，返回0//
//若为等边三角形，返回1//
public int shape_line_triangle() {
int shape = 0;
if(Math.abs(p1.caluate_distance(p2)-p1.caluate_distance(p3))<1e-15&&
Math.abs(p2.caluate_distance(p1)-p2.caluate_distance(p3))<1e-15) {
shape = 1;
}
return shape;
}
//计算三角形面积,返回面积//
public double caluate_S() {
return Math.abs(p1.read_x()*p2.read_y()+p2.read_x()*p3.read_y()+p3.read_x()*p1.read_y()
-p1.read_x()*p3.read_y()-p2.read_x()*p1.read_y()-p3.read_x()*p2.read_y())/2;
}
//计算三角形的周长，返回周长//
public double caluate_C() {
return p1.caluate_distance(p2)+p1.caluate_distance(p3)+p2.caluate_distance(p3);
}
//计算三角形的重心坐标，返回Point//
public Point caluate_gravity_point() {
Point p = new Point();
double dx = (p1.read_x()+p2.read_x()+p3.read_x())/3;
double dy = (p1.read_y()+p2.read_y()+p3.read_y())/3;
p.input(dx, dy);
return p;
}
//判断三角形是锐角三角形还是直角三角形或钝角三角形//
//若是锐角三角形返回1，若是直角三角形返回0，若是钝角三角形则返回-1//
public int shape_horn_triangle() {
int shape ;
double j1 = (p2.read_x()-p1.read_x())*(p3.read_x()-p1.read_x())
+(p2.read_y()-p1.read_y())*(p3.read_y()-p1.read_y());
double j2 = (p3.read_x()-p2.read_x())*(p1.read_x()-p2.read_x())
+(p3.read_y()-p2.read_y())*(p1.read_y()-p2.read_y());
double j3 = (p1.read_x()-p3.read_x())*(p2.read_x()-p3.read_y())
+(p1.read_y()-p3.read_y())*(p2.read_y()-p3.read_y());
if(j1<0||j2<0||j3<0) {
shape = 1;
}else if(j1==0||j2==0||j3==0) {
shape = 0 ;
}else {
shape = -1;
}
return shape;
}
//计算直线与三角形的交点//
//返回交点个数//
public int caluate_sum_intersection(Line a) {
int sum = 0;
Line l1 = new Line();
l1.p1=p1;l1.p2=p2;
Line l2 = new Line();
l2.p1=p1;l2.p2=p3;
Line l3 = new Line();
l3.p1=p2;l3.p2=p3;
if(l1.if_parallel(a)==1) {
Point point1 = a.caluate_intersection(l2);
if(l2.if_in_line(point1)) {
sum++;
}
Point point2 = a.caluate_intersection(l3);
if(l3.if_in_line(point2)) {
sum++;
}
}else if(l2.if_parallel(a)==1) {
Point point1 = a.caluate_intersection(l1);
if(l1.if_in_line(point1)) {
sum++;
}
Point point2 = a.caluate_intersection(l3);
if(l3.if_in_line(point2)) {
sum++;
}
}else if(l3.if_parallel(a)==1) {
Point point1 = a.caluate_intersection(l1);
if(l1.if_in_line(point1)) {
sum++;
}
Point point2 = a.caluate_intersection(l2);
if(l2.if_in_line(point2)&&point1.chack_point(point2)) {
sum++;
}
}else {
Point point1 = a.caluate_intersection(l1);
if(l1.if_in_line(point1)) {
sum++;
}
Point point2 = a.caluate_intersection(l2);
if(l2.if_in_line(point2)&&point1.chack_point(point2)) {
sum++;
}
Point point3 = a.caluate_intersection(l2);
if(l2.if_in_line(point3)&&point1.chack_point(point3)&&point2.chack_point(point3)) {
sum++;
}
}
return sum;
}
//判断点是否再三角形内部//
public boolean if_inside(Point a) {
boolean rea = false ;
Line l1 = new Line();
l1.p1=p1;l1.p2=a;
Line l2 = new Line();
l2.p1=p2;l2.p2=a;
Line l3 = new Line();
l3.p1=p3;l3.p2=a;
Line l4 = new Line();
l4.p1=p1;l4.p2=p2;
Line l5 = new Line();
l5.p1=p2;l5.p2=p3;
Line l6 = new Line();
l6.p1=p3;l6.p2=p1;
if(!l5.if_in_line(l1.caluate_intersection(l5))||!l4.if_in_line(l3.caluate_intersection(l4))
||!l6.if_in_line(l2.caluate_intersection(l6))) {
rea = true;
}
return rea;
}
}
- 采坑心得：
线段斜率不存在会导致运用点斜式计算结果出现error，运用两点式解决问题，直线可能交点在三角形三个顶点上导致直线与两边相交但只有一个交点，
- 改进建议：
参数的选择还不是太精巧，引用时偶尔遇到参数与现有数据不匹配的问题；
- 总结心得：
1.封装能够在实现类的功能时保证类的独立性
2.类在独立时，能够在任何情况下被快速引用
3.一个类如果无法保持独立性，想要调用类的功能时总是会遇到等等问题（参数的不匹配，类方法的功能赘余），而当问题复杂后只能选择再写一个方法，导致时间的不必要的流失
浙公网安备 33010602011771号