PTA题目集最后三次总结.md
PTA题目集最后三次总结
一·包含内容：知识点 题量 难度
1.第一次作业
（1）知识点
7-1.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，字符串和子字符串的获取
7-2.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，简单的数学计算，字符串和子字符串的获取。
7-3.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，简单的数学计算，循环结构，字符串和子字符串的获取
（2）题量
这三题由于选择判断的深入和复杂化代码量和逻辑思维消耗量都是逐渐增高的
（3）具体题目
7-1电信计费系列1-座机计费
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
输入数据中出现的不符合格式要求的行一律忽略。
7-2定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。
- 定义接口Container：
属性：
public static final double pi=3.1415926;
抽象方法:
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]);
static double sumofVolume(Container c[]);
其中两个静态方法分别计算返回容器数组中所有对象的面积之和、周长之和； - 定义Cube类、Cylinder类均实现自Container接口。
第一行n表示对象个数，对象类型用cube、cylinder区分，cube表示立方体对象，后面输入边长，输入cylinder表示圆柱体对象，后面是底圆半径、高。
分别输出所有容器对象的表面积之和、体积之和，结果保留小数点后2位。
2.第二次作业
（1）知识点
7-1.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，正则表达式的使用，抽象类的运用，多态的运用
7-2.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，简单的数学计算
（2）题量
7-1、题由于主体的核心以计算为主故代码长度较多。
7-2题只是一些简单的计算以及继承多态的简单运用故比较短
（3）具体题目
7-1电信计费系列2-手机+座机计费
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打
t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
7-2 sdut-Collection-sort--C~K的班级（II）
经过不懈的努力，C~K终于当上了班主任。
现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？
输入格式:
第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.
接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。
输出格式:
第一行输出一个n，代表删除重复名字后C~K的班级共有几人。
接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。
输入样例:
6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F
输出样例
3
0000 blf2 22 F
0001 MeiK 20 M
0002 sdk2 21 M
7-3阅读程序，按照题目需求修改程序
提示：学生复制以下代码到编程区，并按需求进行调试修改。
// 1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
public class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ;
// 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
输入样例:
在这里给出一组输入。例如：
zs
10
ls
20
ww
30
输出样例:
在这里给出相应的输出。例如：
zs---10
ls---20
ww---30
3.第三次作业
（1）知识点
7-1.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，类的创建，类和方法的引用，正则表达式的运用，较为复杂的计算。
7-2.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，类的创建，类和方法的引用，正则表达式的运用，较为复杂的计算。
7-3.从控制台读取输入以及输出，赋值语句和赋值表达式，选择结构，简单的数学计算，循环结构，类的创建，类和方法的引用，正则表达式的运用，较为复杂的计算。
（2）题量
7-1在类的创建以及具体方法数学计算较之后两者比较少。而后两次，7-3在类的创建以及具体方法数学计算开始变得比较复杂
（3）具体题目
7-1 电信计费系列3-短信计费
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。
输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容 （短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
本题只考虑短信计费，不考虑通信费用以及月租费。
7-2编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。
在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。
7-3 设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
请在下面的【】处添加代码。
二.设计与分析
1.题目集一7-3
（1）选择的原因
由于此题囊括了在进行基础的java练习中容易遇到的一些比较复杂且容易忘记的知识点，如数组的建立、如何类一个输入对象、以及循环的调用，故值得讲解，
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main{
public static void main(String arg[]){
int []a = new int [10];
Scanner scanner = new Scanner(System.in);
for(int i=0;i<10;i++){
a[i]=scanner.nextInt();
}
int sum=0;
for(int j=0;j<10;j++){
if(a[j]%2!=0)
sum+=a[j];
}
System.out.print(sum);
}
}
分析
第一行为了能够顺利进行输入操作，我们需要现引入Scanner这个类，因为java主要是用于面向对象的而不是面向过程，许多操作我们都是可以通过java中所含有的各种各样的类，里面有许多现成的函数只要在class外使用import直接引用即可，这里的Scanner就是用来创建一个输入对象的以便输入我们想要的数据。
第四行中我们创建了一个数组对象，数组对象的创建格式是 数据类型（如 int 、double、boolean等）+[]+ 数组名字+空格+等于号 + new + 数据类型（如 int 、double、boolean等）+[数组数量] ；
第五行中创建了一个输入的类对象，格式为 Scanner + 对象名字 = new Scanner（System.in）；然后我们就可以使用这个类scanner 去创建我们的输入对象了，比如在第七行中的输入的数组我们就可以这样写a[i] = scanner.nextInt();当然因为我们为该数组输入的是整数，如果想要其他的类型只要将next后面的Int改为其他的数据类型表达式如Double等，记住数据类型的第一个字母要大写哦！
好说了一下主要的知识点，接下来我们来讨论一下如何实现计算奇数和这个小功能，我们需要将我们输入的整数中所有的奇数全部求和，即我们需要建立一个循环将每一个输入的数都进行一个检查，这就要用到我们的if语句了，通过条件a[i]除于2是否会有大于0的余数，如果有即为奇数（代码为 a[i]%2>0 ）,然后我们可以提前定义一个整型变量 sum ，初始值设为0，用于将我们的奇数加起来，最后当循环结束后就可以得到奇数和了。
2.题目集一7-6
（1）选择的原因
本题主要涉及了一个在以后会经常用到的一个知识点，即从字符串中获取字符这样一个操作。
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
String number = scanner.next();
if(number.length()==8)
{
if(number.charAt(2)=='0')
{
if(number.charAt(3)=='1'||number.charAt(3)=='2'||number.charAt(3)=='3')
{
if(number.charAt(3)=='1')
{
System.out.println("入学年份：20"+number.charAt(0)+number.charAt(1)+"年");
System.out.println("学院：材料学院");
System.out.println("班级："+number.charAt(4)+number.charAt(5));
System.out.println("学号："+number.charAt(6)+number.charAt(7));
}
if(number.charAt(3)=='2')
{
System.out.println("入学年份：20"+number.charAt(0)+number.charAt(1)+"年");
System.out.println("学院：机械学院");
System.out.println("班级："+number.charAt(4)+number.charAt(5));
System.out.println("学号："+number.charAt(6)+number.charAt(7));
}
if(number.charAt(3)=='3')
{
System.out.println("入学年份：20"+number.charAt(0)+number.charAt(1)+"年");
System.out.println("学院：外语学院");
System.out.println("班级："+number.charAt(4)+number.charAt(5));
System.out.println("学号："+number.charAt(6)+number.charAt(7));
}
}
else
{
System.out.println("Wrong Format");
}
}
else if(number.charAt(2)=='2'&&number.charAt(3)=='0')
{
System.out.println("入学年份：20"+number.charAt(0)+number.charAt(1)+"年");
System.out.println("学院：软件学院");
System.out.println("班级："+number.charAt(4)+number.charAt(5));
System.out.println("学号："+number.charAt(6)+number.charAt(7));
}
else
{
System.out.println("Wrong Format");
}
}
else
{
System.out.println("Wrong Format");
}
}
}
分析
本题的大概意思就是通过输入的字符串的其中一些字符的信息来来获取所需要的学生信息，包括入学年份、所属学院、所属班级、学生学号。当然也不要忘记错误的输入也要判断并输出相应的提示语。
然后在写代码之前我们先想好如何解决错误输入的问题，错误的情况我们经过简单的分析可以得出存在两个错误种类，一种是输入的长度不符合标准，第二种是由于一些特定的地方所输入的数字是有一定的种类限制和范围的，故而我们可以通过确认这几个固定的字符位置上的数字是否满足正确的输入，便可以确定是否为正确的输入了，同理也可通过这种方法来读取我们想要的学生信息。
好首先第一步我们自然需要创建我们的输入类对象并创建输入的对象取名为number，数据类型为String 代表字符串，使用number.charAt（），（ ）里面就输入你需要的字符串所在的位数，就可以得到一个单独的char类型的字符了。
然后我们就可以开始对我们输入的字符串进行具体的分析了，首先我们自然要先判断一下输入的字符串的长度，因为在题目中字符串的长度是固定的8个字符，我们可以直接用方法 字符串的名字.length（）就可以得出字符串的长度了如果符合就进入下一个阶段的判断，如果不是就是第一种错误的情况，输出用System.out.println（“Wrong Format ”），在第二阶段用charAt（），获取三个固定的位置上的字符，只要有一个不符立刻输出Wrong Format ，当满足了三个条件就根据三个所得字符的种类来分别输出所得到的学生信息。
3.题目集二7-2
（1）选择的原因
该题在字符串上又新使用了一个关于字符串的方法——获取一定长度的子字符串且在选择判断方面较之上一题题目集一7-6又有所提高。
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in= new Scanner(System.in);
String s=in.nextLine();
int x=0;
if(s.length()<11)
{
System.out.println("null data");
}
for(int i=0;i<s.length();i++) {
if(s.substring(i,i+1).equals("0")) {
x=1;
break;
}
}
if(x==1)
{
int n=1;
for(int i=0;i<s.length();i++) {
if(s.substring(i,i+1).equals("0"))
{
int m=0;
for(int j=i+1;j<i+9;j++) {
if(s.substring(j,j+1).equals("1"))
{
m++;
}
}
if(s.substring(i+10,i+11).equals("1")) {
if((s.substring(i+9,i+10).equals("1")&&m%2==1)||(s.substring(i+9,i+10).equals("0")&&m%2==0))
{
System.out.println(n+":"+"parity check error");
n++;
i+=10;
}
else
{
System.out.println(n+":"+s.substring(i+1,i+9));
n++;
i+=10;
}
}
else
{
System.out.println(n+":"+"validate error");
n++;
i+=10;
}
}
}
}
else
{
System.out.println("null data");
}
}
}
分析
本题的大致意思就是通过输入的字符串的其中一些字符的信息来来获取所需要的信息，通过获取子字符串以及子字符串的某个字符来获取我们需要的信息。
4.题目集三7-1
（1）选择的原因
该题较之前两次作业集开始大规模使用类和方法来处理我们的题目，真正体现了java中面向对象这一重要思想，我们可以一道题目分为对象和所用的方法，这些可以使用类将其封装，这样我们的代码就具有极其强的可读性，同时在后续的引用和修改都极其的方便，这也是java所具有的三大特性即封装、继承和多态的最直观的体现。此题在这个思想上适合初步的运用，难度不会太大，非常适合练习类的运用。
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String point = scanner.nextLine();
judge(point);
}
public static void judge(String point){
String s1 = "(-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s2 = "(-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
if(point.matches(s1)){ pointDiss a = new pointDiss();
Point p1 = a.exchange1(point);
Point p2 = a.exchange2(point);
double result = a.diss(p1,p2);
System.out.println(result);
}else if(point.matches(s2)){
System.out.println("wrong number of points");
}else{
System.out.println("Wrong Format");
}
}
//"[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
}
class Point{
double x;
double y;
/*
* Point(double x,double y){ this.x=x; this.y=y; }
*/
double getx(){
return x;
}
void setx(double x){
this.x=x;
}
double gety(){
return y;
}
void sety(double y){
this.y=y;
}
}
class pointDiss{
public Point exchange1(String Point){
Point p1 = new Point();
Point p2 = new Point();
int t = 0;
int m = 0;
String[] a= new String[4];
for(int i=0;i<Point.length();i++){
if(Point.charAt(i)==','||Point.charAt(i)==' '){
a[t] = Point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= Point.substring(m,Point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
return p1;
}
public Point exchange2(String Point){
Point p1 = new Point();
Point p2 = new Point();
int t = 0;
int m = 0;
String[] a= new String[4];
for(int i=0;i<Point.length();i++){
if(Point.charAt(i)==','||Point.charAt(i)==' '){
a[t] = Point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= Point.substring(m,Point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
return p2;
}
double diss(Point p1,Point p2){
double result;
double x = Math.pow(p1.x-p2.x,2);
double y = Math.pow(p1.y-p2.y,2);
result = Math.sqrt(x+y);
return result;
}
}
分析
我们首先分析这道题，这道题涉及到使用点的坐标来解决问题，那从面向对象的思想来看，我们先定义一个点的类的对像并存储点的x坐标和y坐标，我们可以使用方法set（）和get（）来存储和获取点的坐标。然后我们需要考虑如何处理我们所输入的字符串并从中提取出我们需要的各个点的x，y坐标，由于同时存在不同的选项代表不同的需求，这也需要纳入我们的考虑范围之内，我们可以使用正则表达式，通过判断输入的字符串是否符合我们所需要的格式就可以比较轻松的的得知输入的字符串是否符合我们的要求，从而进行不同的判断输出。
所以，我们首先需要将我们所需要的类的大致框架写好，根据上一部分的分析我们需要创建好关于点的类Point{},其中包含getx（）、gety（）、setx（）、sety（）四个方法，同时再创建pointDiss{}类，并在其中创建方法exchang（）将我们在之后由字符串转化好的x、y坐标通过我们在pointDiss类中创建的方法diss（）用于计算两点之间的距离，这样我们所需要的基本功能就大致的搭建好了。
然后我们还有一个主要问题没有解决便是关于错误的输入如何判断他们的错误种类，为了解决它我们需要运用正则表达式，在这里我截取了我们所需要的关于正则表达式的一些语法图。
所以通过这个我们就可以直接在我们的Main类中创建我们的judge方法直接判断，在main方法中进行我们字符串的输入，然后在Main类里引用pointDiss创建一个pointDiss类的对象，并运用其中的exchange方法将我们的字符串加到exchange的（）内作为形式参数来得到转化成功后的两个Point，然后运用diss方法用于就是两点间的距离，我们代码的大致思路就是如此。
5.题目集三7-2
（1）选择的原因
该题较之7-1在类的学习上进一步深入，从点的类的创建到线的创建，有助于进一步的学习，二我在这里也没有做到完美，不敢说完全吃透了这道题，只能尽己所能了
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String spot = input.nextLine();
Output output = new Output();
output.legal(spot);
}
}
class Output
{
Switch swich = new Switch();
Calculate calculate = new Calculate();
public void legal(String spot)
{
String s1 = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s2 = "[2][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s3 = "[3][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s4 = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s5 = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String a = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String b1 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String b2 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String c1 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){1,3}";
String c2 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){4,}";
if(spot.matches(s1))
{
double[] xy = new double[4];
swich.StringtoDouble(4, spot, xy);
calculate.slope(xy);
}
else if(spot.matches(s2))
{
double[] xy = new double[6];
swich.StringtoDouble(6, spot, xy);
calculate.distance(xy);
}
else if(spot.matches(s3))
{
double[] xy = new double[6];
swich.StringtoDouble(6, spot, xy);
calculate.collinear(xy);
}
else if(spot.matches(s4))
{
double[] xy = new double[8];
swich.StringtoDouble(8, spot, xy);
calculate.parallel(xy);
}
else if(spot.matches(s5))
{
double[] xy = new double[8];
swich.StringtoDouble(8, spot, xy);
calculate.intersection(xy);
}
else if(spot.matches(a)||spot.matches(b1)||spot.matches(b2)||spot.matches(c1)||spot.matches(c2))
{
System.out.println("wrong number of points");
}
else
{
System.out.println("Wrong Format");
}
}
}
class Switch
{
public void StringtoDouble(int num,String spot,double xy[])
{
String[] arr = new String[num];
int m = 2;
int t = 0;
for(int i=2;i<spot.length();i++)
{
if(spot.charAt(i)==','||spot.charAt(i)==' ')
{
arr[t] = spot.substring(m,i);
m = i+1;
t++;
}
}
arr[t]= spot.substring(m,spot.length());
for(int i=0;i<num;i++)
{
xy[i] = Double.parseDouble(arr[i]);
}
}
}
class Calculate
{
public void slope(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3])
{
System.out.println("points coincide");
}
else
{
if(xy[0]==xy[2])
{
System.out.println("Slope does not exist");
}
else
{
double result = (xy[1]-xy[3])/(xy[0]-xy[2]);
System.out.println(result);
}
}
}
public void distance(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[2]&&xy[4]==xy[5]||xy[2]==xy[4]&&xy[3]==xy[5])
{
System.out.println("points coincide");
}
else
{
double a = xy[4]-xy[2];
double b = xy[5]-xy[3];
double m = Math.abs(b*xy[0]-a*xy[1]+xy[3]*a-xy[2]*b);
double n = Math.sqrt(a*a+b*b);
double result = m/n;
System.out.println(result);
}
}
public void collinear(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[2]&&xy[4]==xy[5]||xy[2]==xy[4]&&xy[3]==xy[5])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
if(xy[0]==xy[2]&&xy[0]==xy[4])
{
flag = true;
}
else
{
double k1=(xy[1]-xy[5])/(xy[0]-xy[4]);
double k2=(xy[3]-xy[5])/(xy[2]-xy[4]);
if(k1==k2)
{
flag = true;
}
}
System.out.println(flag);
}
}
public void parallel(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[4]&&xy[1]==xy[5]||xy[0]==xy[6]&&xy[1]==xy[7]||xy[2]==xy[4]&&xy[3]==xy[5]||xy[2]==xy[6]&&xy[3]==xy[7]||xy[4]==xy[6]&&xy[5]==xy[7])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
if(xy[1]==xy[3]&&xy[5]==xy[7])
{
flag = true;
}
else
{
double k1=(xy[1]-xy[3])/(xy[0]-xy[2]);
double k2=(xy[5]-xy[7])/(xy[4]-xy[6]);
if(k1==k2)
{
flag = true;
}
}
System.out.println(flag);
}
}
public void intersection(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[4]&&xy[1]==xy[5]||xy[0]==xy[6]&&xy[1]==xy[7]||xy[2]==xy[4]&&xy[3]==xy[5]||xy[2]==xy[6]&&xy[3]==xy[7]||xy[4]==xy[6]&&xy[5]==xy[7])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
double k1,k2;
if(xy[1]==xy[3]&&xy[5]==xy[7])
{
flag = true;
}
else
{
k1=(xy[1]-xy[3])/(xy[0]-xy[2]);
k2=(xy[5]-xy[7])/(xy[4]-xy[6]);
if(k1==k2)
{
flag = true;
}
}
if(flag==true)
{
System.out.println("is parallel lines,have no intersection point");
}
else
{
double A,B,C,D,E,F,x,y;
A = xy[3]-xy[1];
B = xy[0]-xy[2];
C = -(xy[0]*xy[3]+xy[2]*xy[1]);
D = xy[7]-xy[5];
E = xy[4]-xy[6];
F = -(xy[4]*xy[7]+xy[6]*xy[5]);
x = (C*E-B*F)/(A*E-B*D);
y = (A*F-C*D)/(A*E-B*D);
System.out.print(x+","+y+" ");
if(((x>=xy[0]&&x<=xy[2]||x<=xy[0]&&x>=xy[2])||(x>=xy[4]&&x<=xy[6]||x<=xy[4]&&x>=xy[6]))&&((y>=xy[1]&&y<=xy[3]||y<=xy[1]&&y>=xy[3])||(y>=xy[5]&&y<=xy[7]||y<=xy[5]&&y>=xy[7])))
{
System.out.println(true);
}
else
{
System.out.println(false);
}
}
}
}
}
分析
本题主要思想其实与上一题大差不差，主要新引入了一个关于显得类，而为了实现线的类的功能，我们需要继续沿用之前关于点的类来构成我们作为线的一些基本的要素，为了方便我们的计算，我们可以将每一条线以Ax+By+C=0来表示，同时在我们的Line类里面加入与线有关的方法来计算斜率，长度等，但是在这里由于代码长度过长我还是沿用了老方法，通过返回数组的形式来进行判断。
首先常用的Scanner引用创建一个输入的类以便创建输入对象等基础操作自然必不可少。我们先规划好我们创建的输入对象不如就在我们的Main中，同时我们所有的输入就一起写在一个output类中，判断输入的正确与否就在output类中的legal方法中判断，而进一步深入在legal方法中我们当然要将我们的字符串转换为整型数组，到时候就在legal方法里用我们在之后写好的各种关于处理具体计算等问题的方法就可以了。
然后在legal里运用正则表达式用if结构判断输入的合法与否，不同错误种类自有输出的不同语句，正确的我们只需要根据得到的字符串种类来进行相应的计算和判断。
6.题目集三7-3
（1）选择的原因
此题在点线的运用上成功的将两者过渡到了三角形的判断上了，由于线类中已经包含了我们判断三角形所需要的绝大部分信息，当然其中各种方法的设计也十分考验在面向过程的能力，当然在运用面向过程能力之前需要我们那个运用面向对象来讲代码的框架设计好。
（2）题目的设计与分析
源代码设计
OK先上源代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String point = scanner.nextLine();
judge(point);
}
public static void judge(String point){
String s1 = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s2 = "[2][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s3 = "[3][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s4 = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s5 = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String a = "[123][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String b1 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String b2 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String c1 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){1,3}";
String c2 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){4,}";
if(point.matches(s1)){
Exchange c = new Exchange();
Point p1 = c.exchange3_1(point);
Point p2 = c.exchange3_2(point);
Point p3 = c.exchange3_3(point);
line s = new line();
double line1=s.distance(p1,p2);
double line2=s.distance(p2,p3);
double line3=s.distance(p1,p3);
double lineK1 = s.linekCalculator(p1,p2);
double lineK2 = s.linekCalculator(p2,p3);
double lineK3 = s.linekCalculator(p1,p3);
sameJudges b = new sameJudges();
boolean three = b.threePoint(p1,p2,p3);
if(three==false){
System.out.println("points coincide");
}else if((line1==line2&&line2==line3)&&(lineK1!=lineK2)){
System.out.println("false true");
}else if(((line1==line2&&line2!=line3)||(line2==line3&&line1!=line3)||(line1==line3&&line2!=line3))&&lineK1!=lineK2){
System.out.println("true false");
}else{
System.out.println("data error");
}
}else if(point.matches(s2)){
Exchange c = new Exchange();
line s = new line();
Point p1 = c.exchange3_1(point);
Point p2 = c.exchange3_2(point);
Point p3 = c.exchange3_3(point);
double X = (p1.x+p2.x+p3.x)/3;
double Y = (p1.y+p2.y+p3.y)/3;
double lineK1 = s.linekCalculator(p1,p2);
double lineK2 = s.linekCalculator(p2,p3);
double line1=s.distance(p1,p2);
double line2=s.distance(p2,p3);
double line3=s.distance(p1,p3);
double C = line1+line2+line3;
double p=C/2;
double S = Math.sqrt(p*(p-line1)*(p-line2)*(p-line3));
sameJudges b = new sameJudges();
boolean two = b.threePoint(p1,p2,p3);
if(two==false){
System.out.println("points coincide");
}else if(lineK1!=lineK2){
System.out.print(C+" "+S+" "+X+","+Y);
}else{
System.out.println("data error");
}
}else if(point.matches(s3)){
Exchange c = new Exchange();
Point p1 = c.exchange3_1(point);
Point p2 = c.exchange3_2(point);
Point p3 = c.exchange3_3(point);
line s = new line();
double lineK1 = s.linekCalculator(p1,p2);
double lineK2 = s.linekCalculator(p2,p3);
double line1=s.distance(p1,p2);
double line2=s.distance(p2,p3);
double line3=s.distance(p1,p3);
sameJudges b = new sameJudges();
boolean two = b.threePoint(p1,p2,p3);
double t;
if (line1<line2){t=line1;line1=line2;line2=t;}
if(line1<line3){t=line1;line1=line2;line3=t;}
if(line2<line3){t=line2;line2=line3;line3=t;}
if(two==false){
System.out.println("points coincide");
}else if(lineK1!=lineK2){
if((line1*line1)>(line2*line2+line3*line3)){
System.out.println("true false false");
}
if((line1*line1)==(line2*line2+line3*line3)){
System.out.println("false true false");
}
if((line1*line1)<(line2*line2+line3*line3)){
System.out.println("false false true");
}
}else{
System.out.println("data error");
}
}
else
if(point.matches(a)||point.matches(b1)||point.matches(b2)||point.matches(c1)||point.matches(c2)){
System.out.println("wrong number of points");
}
else{
System.out.println("Wrong Format");
}
}
}
class Point{
double x;
double y;
double getx(){
return x;
}
void setx(double x){
this.x=x;
}
double gety(){
return y;
}
void sety(double y){
this.y=y;
}
}
class line{
double lineK;
double lineA;
double lineC;
double lineB = -1.0;
public double linekCalculator(Point p2,Point p3){
double lineK = (p2.y-p3.y)/(p2.x-p3.x);
return lineK;
}
public double lineaCalculator(Point p2,Point p3){
double lineA = (p2.y-p3.y)/(p2.x-p3.x);
return lineA;
}
public double linecCalculator(Point p2,Point p3){
double lineC = p2.y-(p2.y-p3.y)*p2.x/(p2.x-p3.x);
return lineC;
}
public double distance(Point p1,Point p2){
double dis = Math.sqrt((p1.y-p2.y)*(p1.x-p2.x));
return dis;
}
}
class Exchange{
public Point exchange2_1(String point){
Point p1 = new Point();
Point p2 = new Point();
int t = 0;
int m = 2;
String[] a= new String[4];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
return p1;
}
public Point exchange2_2(String point){
Point p1 = new Point();
Point p2 = new Point();
int t = 0;
int m = 2;
String[] a= new String[4];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
return p2;
}
public Point exchange3_1(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
int t = 0;
int m = 2;
String[] a= new String[6];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[5]));
p3.sety(Double.parseDouble(a[6]));
return p1;
}
public Point exchange3_2(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
int t = 0;
int m = 2;
String[] a= new String[6];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[5]));
p3.sety(Double.parseDouble(a[6]));
return p2;
}
public Point exchange3_3(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
int t = 0;
int m = 2;
String[] a= new String[6];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[5]));
p3.sety(Double.parseDouble(a[6]));
return p3;
}
public Point exchange4_1(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
Point p4 = new Point();
int t = 0;
int m = 2;
String[] a= new String[8];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[4]));
p3.sety(Double.parseDouble(a[5]));
p4.setx(Double.parseDouble(a[6]));
p4.sety(Double.parseDouble(a[7]));
return p1;
}
public Point exchange4_2(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
Point p4 = new Point();
int t = 0;
int m = 2;
String[] a= new String[8];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[4]));
p3.sety(Double.parseDouble(a[5]));
p4.setx(Double.parseDouble(a[6]));
p4.sety(Double.parseDouble(a[7]));
return p2;
}
public Point exchange4_3(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
Point p4 = new Point();
int t = 0;
int m = 2;
String[] a= new String[8];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[4]));
p3.sety(Double.parseDouble(a[5]));
p4.setx(Double.parseDouble(a[6]));
p4.sety(Double.parseDouble(a[7]));
return p1;
}
public Point exchange4_4(String point){
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
Point p4 = new Point();
int t = 0;
int m = 2;
String[] a= new String[8];
for(int i=0;i<point.length();i++){
if(point.charAt(i)==','||point.charAt(i)==' '){
a[t] = point.substring(m,i);
m = i+1;
t++;
}
}
a[t]= point.substring(m,point.length());
p1.setx(Double.parseDouble(a[0]));
p1.sety(Double.parseDouble(a[1]));
p2.setx(Double.parseDouble(a[2]));
p2.sety(Double.parseDouble(a[3]));
p3.setx(Double.parseDouble(a[4]));
p3.sety(Double.parseDouble(a[5]));
p4.setx(Double.parseDouble(a[6]));
p4.sety(Double.parseDouble(a[7]));
return p4;
}
}
class sameJudges{
public boolean threePoint(Point p1,Point p2,Point p3){
if(p1.x==p2.x&&p1.y==p2.y||p1.x==p3.x&&p1.y==p3.y||p3.x==p2.x&&p3.y==p2.y){
return false;
}else{
return true;
}
}
public boolean fourPoint1(Point p1,Point p2,Point p3,Point p4){
if(p1.x==p2.x&&p1.y==p2.y||p1.x==p3.x&&p1.y==p3.y||p1.x==p4.x&&p1.y==p4.y||p2.x==p3.x&&p2.y==p3.y||p2.x==p4.x&&p2.y==p4.y||p3.x==p4.x&&p3.y==p4.y){
return false;
}else{
return true;
}
}
public boolean fourPoint2(Point p1,Point p2,Point p3,Point p4){
if(p1.x==p2.x&&p1.y==p2.y||p1.x==p3.x&&p1.y==p3.y||p1.x==p4.x&&p1.y==p4.y||p2.x==p3.x&&p2.y==p3.y||p2.x==p4.x&&p2.y==p4.y||p3.x==p4.x&&p3.y==p4.y){
return false;
}else{
return true;
}
}
}
分析
首先基本对象包括输入类的引用等必不可少，在我们的main函数中我们只需要将我们的输入对象设计好即可，其他功能只需要我们引用我们在之后写好的各种类便好。
由于输入坐标的增加，我们首先需要运用正则表达式将各种错误情况设计好，其次对于可能存在的坐标重合现象我们子啊之后的judge类中要专门写一个方法来进行是否重合的判断，我们就可以这样设计
当然由于坐标的不同，也会有不同的判断重合的方法。
然后对于坐标的转化我们同样可以创建一个exchange方法就放在我们的Exchange类里面。
对于点线我们同样可以为它们写不同的类，这样我们的代码在封装、引用和更改上也会非常的方便，同时为line类编写计算斜率，A,B,C等的方法。
最后就是我们根据各个选项的要求在judge类中通过我们从line类中得到不同的数据信息如斜率等编写不同判断方法，这样代码的基本框架和大部分细节就完成了。
三.踩坑心得
1.如果可以牺牲一些代码的可搬运性，我们可以将一些类和方法写到一处，这样可以方便我们要运用其中的一些方法时还要麻烦的去创建相应的类对象，这样在最后的main函数中我们只需要用到很少的类，当然也可以将这些类放到最终我们在main引用的类中。
2.要时刻牢记面向对象的核心思想以及它的三个特性继承，封装，多态。要清楚执行操作的对象和执行操作这两者有本质的不同，深刻理解两者的差异可以帮助我们在构建类的框架上能够少走弯路，错路，我在第三次第二题上就犯了严重的错误，导致代码极其臃肿，逻辑极其混乱。
四.改进建议
1.在建立输入对象时可以将输入类的对象放在我们其他的一些关键类中。
2.对于类的理解我有了一些更深层次的理解，执行的对象，对象执行的动作，比如题目如果要求有一些输入错误测试，这就可以专门写一个类，将所有的与之相关的类和方法来放入其中，这样在main函数中我们就只需要引入一个类了，代码的逻辑也会更加的清晰。
五.总结
1.首先必须时刻谨记关于面向对象的概念，即面向对象 (Object Oriented,OO) 的思想对软件开发相当重要，它的概念和应用甚至已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD 技术、人工智能等领域。面向对象是一种 对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向过程 (Procedure Oriented) 是一种 以过程为中心 的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是 封装、继承、类。
2.对于对象的属性和方法必须有清晰的理解执行者和执行者使用的方法之间可谓天差地别。
3.我认为在逻辑框架不是很清楚时可以通过撰写一个思维导图来帮助自己理清代码中关于各种类与方法之间的逻辑方法，下面就是我在第三次第一题所写的一个简略的导图
浙公网安备 33010602011771号