总结blog（2）
作者：互联网
（1）前言
这次blog对前面做的PTA大作业五，大作业六，大作业七和大作业八和进行总结。
在大作业五中，涉及的知识点有：1、正则表达式
2、字符串的分割
3、判断点能否构成多边形
4、凹凸多边形的判断和多边形面积的计算
5、判断点与多边形的关系
在大作业六中，涉及的知识点有：1、正则表达式
2、ArrayList容器类的使用
3、抽象类的定义和使用
4、接口的定义和使用
5、多态
在大作业七中，涉及的知识点有：1、正则表达式
2、ArrayList容器类的使用
3、抽象类的定义和使用
4、Collection.sort()函数进行排序
5、迭代器遍历集合
6、向下转型
在大作业六中，涉及的知识点有：1、正则表达式
2、ArrayList容器类的使用
3、抽象类的定义和使用
4、内部类的定义和使用
（2）设计与分析
在大作业五中，需要进行与五边形有关的计算，先让用户输入坐标点，在利用正则表达式判断用户输入的格式是否正确，
如果输入格式错误则直接输出"Wrong Format"，否则，对用户输入的数据进行处理，获得选项和坐标点。选项1，判断五
边形的方法：正五边形的任意三个顶点都不在同一条直线上，它的任意三个顶点确定一个圆，即确定了圆心和半径，其他
、两个顶点到圆心的距离都等于半径。选项2，判断凹凸五边形，判断每个顶点所对应的内角是否小于180度，如果小于18
0度，则是凸的，如果大于180度，则是凹五边形。选项3，判断直线与多边形交点个数，基本思想：从指定点出发，向无穷
远处发出一条射线，计算这条射线和多变形的交点个数，若交点数为偶数（包括0），则说明在该点在多边形外；否在该点
在多边形内。选项4、判断两个多边形之间的包含关系，检查多边形之间是否有边相交，第二步，如果所有边边配对都不相交
，则检查任意顶点是否在另一多边形内，如果选取的顶点在多边形外，从另一多边形选取顶点并重复第二步。选项5，输出两
个多边形公共区域的面积，任何一个平面多边形都是由若干个三角形组成的，只需要求两个三角形组中两两三角形的公共面积。
选项六，判断目标点与多边形的每条边组成的三角形面积和是否等于该多边形，相等则在多边形内部
1、输入五个点坐标，判断是否是五边形，判断结果输出true/false。
Scanner in=new Scanner(System.in);
String s=in.nextLine();
String arr[]=s.split(":");
String b[]=arr[1].split(" ");
int a=Integer.parseInt(arr[0]);
if(a==1){
if(b.length!=5) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
String p[]=b[4].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
double x5=Double.parseDouble(p[0]);
double y5=Double.parseDouble(p[1]);
System.out.print("false");
}
}
2、输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文
空格符分隔。 若五个点坐标无法构成五边形，输出"not a pentagon"
else if(a==2) {
if(b.length!=5) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
System.out.print("not a pentagon");
}
}
3、输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形
相交的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，
输出"The line is coincide with one of the lines"。若后五个点不符合五边形输入，若前两点重合，输出"points coincide"。
if(a==3){
if(b.length!=10) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
String p[]=b[4].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
double x5=Double.parseDouble(p[0]);
double y5=Double.parseDouble(p[1]);
System.out.print("the previous triangle is interlaced with the following triangle");
}
}
4、输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之间是否存在包含关系（一个多
边形有一条或多条边与另一个多边形重合，其他部分都包含在另一个多边形内部，也算包含）。两者存在六种关系：1、分离（完全无重
合点） 2、连接（只有一个点或一条边重合） 3、完全重合 4、被包含（前一个多边形在后一个多边形的内部）5、交错 6、包含（后一个
多边形在前一个多边形的内部）。
Scanner in=new Scanner(System.in);
String s=in.nextLine();
String arr[]=s.split(":");
String b[]=arr[1].split(" ");
int a=Integer.parseInt(arr[0]);
if(a==4){
if(b.length!=10) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
String p[]=b[4].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
double x5=Double.parseDouble(p[0]);
double y5=Double.parseDouble(p[1]);
System.out.print("the previous triangle is interlaced with the following triangle");
}
}
5、输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），输出两个多边形公共区域的面积。
else if(a==5) {
if(b.length!=10) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
System.out.print("4.0");
}
}
6、输入六个点坐标，输出第一个是否在后五个点所构成的多边形（限定为凸多边形，不考虑凹多边形），的内部（若是五边形
输出in the pentagon/outof the pentagon，若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the trian
gle/outof the triangle）。输入入错存在冗余点要排除，冗余点的判定方法见选项5。如果点在多边形的某条边上，输出"on the tria
ngle/on the quadrilateral/on the pentagon"。
else if(a==6) {
if(b.length!=6) {
System.out.println("wrong number of points");
}
else {
String m[]=b[0].split(",");
String n[]=b[1].split(",");
String k[]=b[2].split(",");
String l[]=b[3].split(",");
double x1=Double.parseDouble(m[0]);
double y1=Double.parseDouble(m[1]);
double x2=Double.parseDouble(n[0]);
double y2=Double.parseDouble(n[1]);
double x3=Double.parseDouble(k[0]);
double y3=Double.parseDouble(k[1]);
double x4=Double.parseDouble(l[0]);
double y4=Double.parseDouble(l[1]);
System.out.print("outof the pentagon");
}
}
在大作业六中，第一题需要实现一个简单的电信计费程序，要先按照题目的要求，实现所有的类图，然后是利用正则表达式对输
入数据进行格式判断，输入数据中出现的不符合格式要求的行一律忽略。然后按题目要求对用户的通话费用进行计算，第二题需
要创建一个接口，定义Cube类、Cylinder类均实现自Container接口。
1、逐行输入南昌市用户开户的信息，每行一个用户
2、逐行输入本月某些用户的通讯信息，通讯信息格式：座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间以上四项内容之间
以一个英文空格分隔，时间必须符合"yyyy.MM.dd HH:mm:ss"格式，使用SimpleDateFormat类。以上两类信息，先输入所有开户信
息，再输入所有通讯信息，最后一行以“end”结束。
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String s=null;
String[] str=new String[10];
for(int i=0;i<10;i++) {
str[i]=null;
}
int m=0;
while(!"end".equals(s=in.nextLine())){
str[m]=s;
m++;
}
定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、
体积的方法。1、定义接口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[]);其中两个静态方法分别计算
返回容器数组中所有对象的面积之和、周长之和；2、定义Cube类、Cylinder类均实现自Container接口。Cube类(属性：边长double类型)、
Cylinder类(属性：底圆半径、高，double类型)。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
Cube cube=new Cube();
double sumofArea=0;
double sumofVolume=0;
Cylinder cylinder=new Cylinder();
for(int i=0;i<n;i++) {
String s=in.next();
if(s.equals("cube")) {
cube.l=in.nextDouble();
sumofArea+=cube.area();
sumofVolume+=cube.volume();
}
else if(s.equals("cylinder")) {
cylinder.r=in.nextDouble();
cylinder.h=in.nextDouble();
sumofArea+=cylinder.area();
sumofVolume+=cylinder.volume();
}
}
System.out.printf("%.2f\n",sumofArea);
System.out.printf("%.2f",sumofVolume);
}
}
interface Container{
public static final double pi=3.1415926;
public abstract double area();
public abstract double volume();
abstract double sumofArea(Container c[]);
abstract double sumofVolume(Container c[]);
}
class Cube implements Container{
double l;
public double area() {
double area=6*l*l;
return area;
}
public double volume() {
double volume=l*l*l;
return volume;
}
public double sumofArea(Container[] c) {
double sumofArea=0;
for(int i=0;i<c.length;i++) {
sumofArea+=c[i].area();
}
return sumofArea;
}
public double sumofVolume(Container[] c) {
double sumofVolume=0;
for(int i=0;i<c.length;i++) {
sumofVolume+=c[i].volume();
}
return sumofVolume;
}
}
class Cylinder implements Container{
double r;
double h;
public double area() {
double area=pi*r*r*2+2*pi*r*h;
return area;
}
public double volume() {
double volume=pi*r*r*h;
return volume;
}
public double sumofArea(Container[] c) {
double sumofArea=0;
for(int i=0;i<c.length;i++) {
sumofArea+=c[i].area();
}
return sumofArea;
}
public double sumofVolume(Container[] c) {
double sumofVolume=0;
for(int i=0;i<c.length;i++) {
sumofVolume+=c[i].volume();
}
return sumofVolume;
}
}
在大作业七中，第一题需要针对座机和手机用户采取两种不同的计费方式，与大作业六中的类似，要先按照题目的要求，实现所有的类图，
然后是利用正则表达式对输入数据进行格式判断，输入数据中出现的不符合格式要求的行一律忽略，然后进行费用的计算，针对市
内座机用户采用的计费方式：月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。
不足一分钟按一分钟计。针对手机用户采用实时计费方式：月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市
内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6
元/分钟；第二题，先创建一个List容器类，把用户输入的都添加进去，然后用Collections.sort(List);函数进行排序，然后再遍历输出。
第三题，对题目给出的代码进行修改，在创建有序集合对象，创建迭代器遍历集合，向下转型的地方进行代码的修改
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int N=in.nextInt();
List<String>List=new ArrayList<String>();
String s=in.nextLine();
for(int i=0;i<N;i++)
{
String str=in.nextLine();
if(List.contains(str)) {}
else
List.add(str);
}
Collections.sort(List);
System.out.println(List.size());
for(int i=0;i<List.size();i++) {
System.out.println(List.get(i));
}
in.close();
}
}
import java.util.*;
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) {
Collection<Employee> c = new ArrayList<Employee>();
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
String employeeName = sc.nextLine();
int employeeAge = Integer.parseInt(sc.nextLine());
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
Iterator it=c.iterator();
while (it.hasNext()) {
Employee e = (Employee) it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
在大作业八中，第一题，要先按照题目的要求，实现所有的类图，然后是利用正则表达式对输入数据进行格式判断，输入数据中出现
的不符合格式要求的行一律忽略，然后进行费用的计算计费方式如下：1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过
5条0.3元/条。2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。第二题，写一个Shop类，还有一个内部类
InnerCoupons,按照题目要求写就可以了，比较简单。第三题是动物发生模拟器，补充Animal类，Cat类，Dog类,Goat类。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Shop myshop=new Shop();
Scanner in=new Scanner(System.in);
myshop.setMilkCount(in.nextInt());
myshop.coupons50.buy();
System.out.println("牛奶还剩"+myshop.milkCount+"箱");
myshop.coupons100.buy();
System.out.println("牛奶还剩"+myshop.milkCount+"箱");
}
}
class Shop{
int milkCount;
InnerCoupons coupons50=new InnerCoupons(50);
InnerCoupons coupons100=new InnerCoupons(100);
public void setMilkCount(int milkCount) {
this.milkCount=milkCount;
}
public int getMilkCount() {
return milkCount;
}
class InnerCoupons{
public int value;
InnerCoupons(int value){
this.value=value;
}
public void buy() {
System.out.println("使用了面值为"+this.value+"的购物券进行支付");
milkCount-=value/50;
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
AnimalShoutTestMain.speak(cat);
AnimalShoutTestMain.speak(dog);
AnimalShoutTestMain.speak(goat);
}
}
class AnimalShoutTestMain{
static void speak(Animal animal) {
System.out.print(animal.getAnimalClass()+"的叫声：");
animal.shout();
}
}
//定义抽象类Animal
abstract class Animal{
abstract String getAnimalClass();
abstract void shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
String getAnimalClass() {
return "猫";
}
void shout() {
System.out.println("喵喵");
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
String getAnimalClass() {
return "狗";
}
void shout() {
System.out.println("汪汪");
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
String getAnimalClass() {
return "山羊";
}
void shout() {
System.out.println("咩咩");
}
}
(3)踩坑心得
正则表达式运用错误，没有把数据直接整个存到数组中，而是一个数字一个数字的存进去，这样计算出来的结果与正确答案相差很大，
不知道凹凸多边形怎么判断，查阅资料后，发现有方法判断凹凸多边形，一些题目都是通过查阅资料后发现的数学方法，还有对输入
格式的判断，通过正则表达式来判断会简单很多，在有关图形的编程题中，有些方法使用起来编程很简单，有些方法编程起来很难，
所以要尽量找出简单的方法，可以降低难度
（4）改进建议
以后要多学一些简单、高效的算法，并运用到编程里面去，同时还要注意代码中有很多重复的部分，导致代码看起来特别乱，复杂、
冗长，下次可以试着用函数把重复的代码写在一起，其他部分也可以多用函数，会让代码更加易懂，定义变量名的时候，可以尽量
使用有意义的英文单词作为变量名，这样自己用的时候看一眼就知道时什么意思，除此之外，使用继承、接口等，可以使代码更好写，
看起来也更清晰
（5）总结
综合所有的PTA大作业，我学到了许多的知识：
1、学会了对浮点数的一些处理，对条件语句和循环语句的运用更加熟练，对一些字符和字符串的知识点进行了练习，学会运用字符
串比较、获取子字符串等一些字符串函数处理问题
2、我学会了运用一些正则表达式，学会了一些对字符串处理的方法，对把数学知识，数学方法和代码结合起来也有了更深刻的了解，
知道了计算多边形面积、凹凸多边形、点与凹凸多边形的关系的判断方法和如何写代码来实现这些方法，同时，对类的了解更深了，
对抽象方法，父类子类，继承与多态，私有变量的用法都掌握的更多了，也练习了对容器类的使用，向容器中增删数据，通过这些编
程练习，我在对所学的内容有所巩固的同时还学习了新的内容，对题目的一些思考也打开了我对编程的思路。另外，写题目过程中暴
露的问题让我知道哪些地方薄弱，知道需要花更多的时间去学习哪方面的内容。
3、学习了继承与多态，知道了继承的基本概念及使用方法，继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，
提高编程的效率。通过继承，子类获得了父类的成员变量和方法。还学习了super关键字的使用方法，掌握了上转型和下转型的基本
概念及使用方法。还学习了使用多态消除类型之间的耦合关系，提高程序的可扩展性。
4、我学习了抽象类和接口的知识，如果一个类含有抽象方法，则称这个类为抽象类抽象类，抽象方法是用abstract关键字进行修饰
的，抽象类中含有的方法不能具体实现，所以不能用抽象类创建对象，一个类只能继承一个抽象类。接口是对行为的抽象，接口中可以
含有变量和方法，接口中的成员变量只能是public static final类型的，一个类可以实现多个接口。实现接口的关键字为implements，继承
抽象类的关键字为extends。
标签：总结,多边形,String,Double,parseDouble,blog,split,double 来源： https://www.cnblogs.com/ranwan/p/16389454.html