标签：index curr 输出 BLOG 四边形 public 输入

一.前言：

题目集04：点线形系列的计算，难度很大。主要考字符串的读取还有我们对测试点的把控，是否考虑了各种情况。
题目集05：主要考正则表达式和ATM结构的设计。而ATM结构的设计难度很大，主要是对前面学习的综合性考察，由业务背景，自行设计程序结构，重点考核类的封装性及类间关系设计（关联、组合及依赖）的考察。
题目集06：知识是题目集04和05的一个综合型，有正则表达式，点线形系列的计算的凸四边形的计算，和银行类的设计。其中正则表达式和银行类的设计比较简单而点线形系列的计算的凸四边形的计算难度很大。
期中考试：考察类的设计和继承与多态还有重构增加新的类。
学习通：考察泛型的知识点，使用泛型写一个链表。

二.设计与分析:

1.题目集04-1：点线形系列1-计算两点之间的距离。

要求：输入连个点的坐标，计算两点之间的距离。

难点：判断输入点是否合法。

思路：读取输入的字符串用spilt分开进行判断。

import java.util.Scanner;

public class Main {
    public static int NumType(String s){
        Double a;
    try
    {
        a = Double.parseDouble(s);
    }
    catch(Exception e){
        return -1;
    }
    return 0;
    }
    public static void main(String [] args){
        Scanner input = new Scanner(System.in);
        String arr=input.nextLine();
        String[] nums = arr.split(" ");
        int x=0;
        for(int i=0;i<arr.length()-1;i++) {
            if(arr.charAt(i) == ' ' && arr.charAt(i+1) == ',' ||
                    arr.charAt(i) == ' ' && arr.charAt(i+1) == ' ' ||
                    arr.charAt(i) == ' ' && arr.charAt(i+1) == '.' ||
                    arr.charAt(i) == ',' && arr.charAt(i+1) == ' ' ||
                    arr.charAt(i) == ',' && arr.charAt(i+1) == ',' ||
                    arr.charAt(i) == ',' && arr.charAt(i+1) == '.' ||
                    arr.charAt(i) == '.' && arr.charAt(i+1) == ' ' ||
                    arr.charAt(i) == '.' && arr.charAt(i+1) == ',' ||
                    arr.charAt(i) == '.' && arr.charAt(i+1) == '.' ||
                    arr.charAt(i) == '0' && arr.charAt(i+1) == '0') {
                x++;
            }
            else if(arr.charAt(0) == ' ' ||
                    arr.charAt(0) == ',' ||
                    arr.charAt(0) == '.') {
                x++;
            }
            else if(arr.charAt(arr.length()-1) == ' ' ||
                    arr.charAt(arr.length()-1) == ',' ||
                    arr.charAt(arr.length()-1) == '.') {
                x++;
            }
        }
        if(x!=0) {
            System.out.println("Wrong Format");
        }
        else if(arr.indexOf(' ')==-1) {
            System.out.println("Wrong Format");
        }
        else {

            String[] nums1 = nums[0].split(",");
            String[] nums2 = nums[1].split(",");
            if(nums.length >= 3) {
                System.out.println("wrong number of points");
            }

            else if(NumType(nums1[0])==-1||NumType(nums1[1])==-1||NumType(nums2[0])==-1||NumType(nums2[1])==-1) {
                System.out.println("Wrong Format");
            }
            else {
                double x1 = Double.parseDouble(nums1[0]);
                double y1 = Double.parseDouble(nums1[1]);
                double x2 = Double.parseDouble(nums2[0]);
                double y2 = Double.parseDouble(nums2[1]);
                double d = ((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
                d=Math.sqrt(d);
                System.out.println(d);
            }
        }
    }
}

 

题目我只设计了一个类，如何判断输入的点是否合法我使用了笨办法考虑出现错误的所有可能。

2.题目集04-2：点线形系列2-线的计算

要求：用户输入一组选项和数据，进行与直线有关的计算。选项包括：
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"。

难点：第五个要求的计算，第二个要求的计算距离，和输入的点是否合法。

思路：读取输入的字符串用spilt分开进行判断。使用一个num等于输入字符串的第一个数，然后用if判断num等于几而实现第几个要求。

 我也只设计了一个类其中illegal用于判断输入是否合法，Pointserror判断点的数量是否错误。

测试点很多我提交很多遍但是还有几个测试点过不去。

3.题目集04-3：点线形系列3-三角形的计算

要求：用户输入一组选项和数据，进行与三角形有关的计算。选项包括：
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"

 

 

 

 因为这几道题我都只有一个类，所以不放类图了。

难点：都是难点

思路：类似于上一题，但是这题难度在于计算，如要求一我计算了三角形三条边，根据边长判断是否是等腰三角形、等边三角形，但是还有一个测试点过不去。而4，5要求难度很大，写不出来。

要求二我计算了周长、面积、重心坐标，三个参数但是不能按输出的数据若小数点后超过6位，只保留小数点后6位，多余部分采用四舍五入规则进到最低位。小数点后若不足6位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333333，1.0按格式输出为1.0要求输出。

要求三我计算出三角形各个角的cos值，判断是否是钝角、直角还是锐角三角形，但是还有一个测试点过不去。

4.链表练习

要求：1.判断链表是否为空

　　　2.获取当前链表节点数量

　　　3.获取链表中第index个位置的节点的data值

　　　4.删除链表最后一个节点

　　　5.删除链表中第index位置的节点 

　　　6.在链表的第index个位置之前插入一个节点，值为theElement，index∈[1,size]

　　　7.在链表尾插入节点，插入节点data值为element

　　　8.获取第一个节点的data值

　　　9.获取链表最后一个节点的data值

 

 

 

 因为有好几个.java文件我这里放的是最主要的图List。

public interface DoubleLinkedListImpl<E> {

    public boolean isEmpty();

    public int getSize();

    public E get(int index);
    
    public void remove();

    public void remove(int index);

    public void add(int index, E theElement);

    public void add(E element);

    public void printList();
    
    public E getFirst(); 

    public E getLast();
}

public class LList<E> implements DoubleLinkedListImpl<E> {
    private Node<E> head;// 头结点（非第一个节点），当前节点，尾节点
    private Node<E> curr;
    private Node<E> tail;

    private int size = 0;    
    
    public LList() {
        super();
        // TODO 自动生成的方法存根
        head = new Node<E>();
        head.setNext(null);
        curr = tail = null;
        this.size = 0;
    }

    @Override
    public boolean isEmpty() {
        // TODO 自动生成的方法存根
        return this.size == 0;
    }

    @Override
    public int getSize() {
        // TODO 自动生成的方法存根
        return this.size;
    }

    @Override
    public E get(int index) {
        // TODO 自动生成的方法存根
        if(index < 1 || index > this.size) {
            return null;
        }
        
        curr = head;
        for(int i = 0; i < index; i ++) {
            curr = curr.getNext();
        }
        
        return curr.getData();
    }

    @Override
    public void remove(int index) {
        // TODO 自动生成的方法存根
        if(index < 1 || index > this.size) {
            return ;
        }
        
        curr = head;
        
        if(index == 1) {
            curr = head.getNext();
            head.setNext(curr.getNext());
        }else {//找到第index - 1个节点赋给curr
            for(int i = 1;i < index; i++) {
                curr = curr.getNext();
            }
            
            curr.setNext(curr.getNext().getNext());
        }
        
        if(index == this.size) {//如果删除的是最后一个节点
            tail = curr;
        }
        
        this.size --;//整个链表的节点数量-1

    }

    @Override
    public void add(int index, E theElement) {
        // TODO 自动生成的方法存根
        if(index < 1 || index > this.size + 1) {
            return ;
        }
        Node<E> curr = new Node<>();
        curr.setData(theElement);
        curr.setNext(null);
        
        if(this.size == 0) {
            head.setNext(curr);
            tail = curr;
        }
        else if(index == this.size + 1) {
            this.tail.setNext(curr);
            tail = curr;
        }
        else {
            Node<E> tempNode = head;
            for(int i  = 1; i < index;i++) {
                tempNode = tempNode.getPrevious();
            }
            curr.setNext(tempNode.getNext());
            tempNode.setNext(curr);
        }
        this.size ++;
    }

    @Override
    public void add(E element) {
        // TODO 自动生成的方法存根
        this.add(this.size + 1,element);

    }

    @Override
    public void printList() {
        // TODO 自动生成的方法存根
        curr = head.getNext();
        for(int i = 1; i <= this.size;i ++) {
            System.out.print(curr.getData() + " ");
            curr = curr.getNext();
        }
        
        System.out.println("");

    }
    
    public E getLast() {
        if(this.size != 0) {
            System.out.println(tail.getData());
            return tail.getData();
        }
        return null;
    }

    @Override
    public E getFirst() {
        // TODO 自动生成的方法存根
        if(this.size != 0) {
            System.out.println(head.getNext().getData());
            return head.getNext().getData();
        }
        return null;
    }

    @Override
    public void remove() {
        // TODO 自动生成的方法存根
        this.remove(size);
    }

}

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LList<Integer> list = new LList<>();
//        输入
        list.add(2);
        list.add(4);
        list.add(6);
        list.add(8);
        list.printList();
        
//        删除最后一个节点
        list.remove();
        list.printList();
        
//        删除
        list.remove(3);
        list.printList();
        
//        特定位置插入
        list.add(3,6);
        list.printList();
//        获取第一个/最后一个节点
        list.getFirst();
        list.getLast();
    }
}

public class Node<E> {
    private E data;
    private Node<E> next;
    private Node<E> previous;
    public Node() {

    }
    
    public Node(E data) {
        super();
        this.data = data;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }
    
    public Node<E> getPrevious(){
        return previous;
    }
    
    public void setPrevious(Node<E> previous) {
        this.previous = previous;
    }
}

难点：要对c语言链表足够条件。

思路：定义一个指针类，用于指针。对于节点的插入要考虑插入点在第一个还是最后一个还是中间，又或者插入的下标错误。

5.期中考试01

要求：

• 设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息，格式如下：(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则直接输出Wrong Format

• 设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息

难点：如何读取和输出

思路：主要是Main方法我用for循环获取每一行的内容。输出在其他类中定义display()方法输出各种内容。

6.期中考试02

要求：

在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。

• 对题目中的点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类的引用，分别使用该引用调用以上四个对象的display()方法

 

 

 思路：无，按题目要求定义一个Element类并引用从而实现多态。添加一个类Plane与前一题的类类似，难点在于输出。

7.期中考试03

要求：在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。

• 在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList<Element>类型的对象（若不了解泛型，可以不使用<Element>）
• 增加该类的add()方法及remove(int index)方法，其功能分别为向容器中增加对象及删除第index - 1（ArrayList中index>=0）个对象
• 在主方法中，用户循环输入要进行的操作（choice∈[0,4]），其含义如下：
  • 1：向容器中增加Point对象
  • 2：向容器中增加Line对象
  • 3：向容器中增加Plane对象
  • 4：删除容器中第index - 1个数据，若index数据非法，则无视此操作
  • 0：输入结束

题目没写出来

8.题目集06-2：点线形系列4-凸四边形的计算

要求：用户输入一组选项和数据，进行与四边形有关的计算。

以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。

 

 

 

 

 

难点：在三角形的计算一题上难度更进一步，如何判断点是否输入非法是否点的数量不对，又或者是否是点重合还是不能构成四边形。

因为有之前几次点线形系列题目计算，我这次分出来各种类，写起来要比之前轻松很多但是依旧没有写出来。

三.采坑心得:

1.题目集04-2：点线形系列2-线的计算和题目集04-3：点线形系列3-三角形的计算

写题目时没有先考虑类与类之间关系，只设计了一个类，写的时候很麻烦，也写不出来。

以后写题目时要先考虑设计类图关系。

2.链表练习

 对链表中的指针类不够熟悉，设计了很长一段时间。对于如何遍历链表还不是很熟悉。

3.期中考试

期中考试对于如何读取输入的字符串我使用的是nextLine，忘记了前四个是数字可以用nextDouble，

而且因为输入行数确定所以可以直接多定义Doubel x=new nextDouble，而我使用的是for循环，重复读取。

而且对多态不过了解，并且发现写题目时发现时间不够，以前没有在这么短时间里写题目。

4.题目集06-2：点线形系列4-凸四边形的计算

考虑并设计了几个类但是不能掌握好类和类之间的关系，对类的设计不是很好，

而且写代码时也不能很好的考虑可能会出现什么情况应该怎么办，

测试点有很多都没有通过，而且要求4，5的计算也不会。

四.改进建议：

点线形系列应该多设计几个类这样可以写的更清楚更明白。

链表的设计没有用上previous指针，可以考虑使用previous指针是否更加方便。

期中考试的题目可以

Double str1=new nextDouble;
 Double str2=new nextDouble;
 Double str3=new nextDouble;
 Double str4=new nextDouble;
 String str5=new nextLine;

这样定义而不是

String[] str = new String[5];
        for(int i=0;i<5;i++) {
            String arr = input.nextLine();
            str[i]=arr;
        }

这样。而且写代码是不会一键构成代码浪费了很多时间。

五.总结： 

以后写代码时，要先学会设计类图，理清楚类与类之间的关系。

写代码不能要考虑用什么代码更加合适，比如用户输入double型就用nextDouble，而不是nextLine。

标签：index,curr,输出,BLOG,四边形,public,输入
来源： https://www.cnblogs.com/Aa3111ll/p/16212479.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。