题目集4~6的总结性Blog

前言：
除大作业外综合难度不大（不然不会这么多人写的全对）,但其实大作业反复调试后再问问同学问问老师也是能做出来的。主要涉及类的继承与多态，其中大作业就难在管理数据这一方面，题量不多但需要花时间，我写完刚好花了两个半天的时间。尤其是题集6只有一题，我觉得这样安排很好，可以让我们专心思考大作业。

题集4：

7-1 答题判题程序-4

设计实现答题程序，模拟一个小型的测试，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。本题在答题判题程序-3基础上新增的内容统一附加在输出格式说明之后，用粗体标明。

输入格式:

程序输入信息分五种，信息可能会打乱顺序混合输入。

1、题目信息
题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式约束：
1、题目的输入顺序与题号不相关，不一定按题号顺序从小到大输入。
2、允许题目编号有缺失，例如：所有输入的题号为1、2、5，缺少其中的3号题。此种情况视为正常。
样例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4

2、试卷信息

试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。 \

格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
格式约束：
题目编号应与题目信息中的编号对应。
一行信息中可有多项题目编号与分值。
样例：#T:1 3-5 4-8 5-2

3、学生信息

学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名，格式如下。

格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
样例：
#S:1 #A:5 #A:22
1是试卷号
5是1号试卷的顺序第1题的题目答案
4、答卷信息

答卷信息按行输入，每一行为一张答卷的答案，每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。答卷中：

格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
格式约束：
答案数量可以不等于试卷信息中题目的数量，没有答案的题目计0分，多余的答案直接忽略，答案之间以英文空格分隔。
答案内容可以为空，即””。
答案内容中如果首尾有多余的空格，应去除后再进行判断。
答卷信息中仅包含试卷号、学号，而没有后续内容的，视为一张空白卷，为有效信息，不做格式错误处理。
样例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是试卷号
20201103是学号
2-5中的2是试卷中顺序号，5是试卷第2题的答案，即T中3-2的答案
6-4中的6是试卷中顺序号，4是试卷第6题的答案，即T中7-3的答案
注意：不要混淆顺序号与题号

5、删除题目信息

删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”

格式："#D:N-"+题目号
格式约束：
题目号与第一项”题目信息”中的题号相对应，不是试卷中的题目顺序号。
本题暂不考虑删除的题号不存在的情况。
样例：

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

T:1 1-5 2-8

X:20201103 Tom-20201104 Jack

S:1 20201103 #A:1-5 #A:2-4

D:N-2

end

输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
the question 2 invalid~0
20201103 Tom: 0 0~0
答题信息以一行"end"标记结束，"end"之后的信息忽略。

输出格式:

1、试卷总分警示

该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。
格式："alert: full score of test paper"+试卷号+" is not 100 points"
约束：有多张试卷时，按输入信息的先后顺序输出警示。

样例：alert: full score of test paper2 is not 100 points

2、答卷信息

一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。

格式：题目内容+"_"+答案++""+判题结果（true/false）

约束：如果输入的答案信息少于试卷的题目数量，每一个缺失答案的题目都要输出"answer is null" 。

样例：

 answer is null

 3+2=~5~true

 4+6=~22~false.

 answer is null

3、判分信息

判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。

格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目、被删除的题目、答案错误的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：20201103 Tom: 0 0~0
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。

4、被删除的题目提示信息

当某题目被试卷引用，同时被删除时，答案中输出提示信息。样例见第5种输入信息“删除题目信息”。

5、题目引用错误提示信息

试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。例如：

输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103 #A:1-4

end
输出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案输出时，一道题目同时出现答案不存在、引用错误题号、题目被删除，只提示一种信息，答案不存在的优先级最高，例如：

输入：

N:1 #Q:1+1= #A:2

T:1 3-8

X:20201103 Tom-20201104 Jack-20201105 Www

S:1 20201103

end
输出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式错误提示信息

输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。

  例如：wrong format:2 #Q:2+2= #4

7、试卷号引用错误提示输出

如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出，参见样例8。

8、学号引用错误提示信息

如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。参见样例9。

本次作业新增内容：

1、输入选择题题目信息

题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#Z:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。

新增约束：标准答案中如果包含多个正确答案（多选题），正确答案之间用英文空格分隔。
例如：

Z:2 #Q:宋代书法有苏黄米蔡四家，分别是： #A:苏轼 黄庭坚 米芾 蔡襄

多选题输出：

输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。

多选题给分方式：

答案包含所有正确答案且不含错误答案给满分；包含一个错误答案或完全没有答案给0分；包含部分正确答案且不含错误答案给一半分，如果一半分值为小数，按截尾规则只保留整数部分。
例如：

N:1 #Q:1+1= #A:2

Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D

T:1 1-5 2-9

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-A C

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4

2、输入填空题题目信息

题目信息为独行输入，一行为一道题，多道题可分多行输入。

格式："#K:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
格式基本的约束与一般的题目输入信息一致。
例如：#K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴
填空题输出：

输出格式与一般答卷题目的输出一致，判断结果除了true、false，增加一项”partially correct”表示部分正确。

填空题给分方式：

答案与标准答案内容完全匹配给满分，包含一个错误字符或完全没有答案给0分，包含部分正确答案且不含错误字符给一半分，如果一半分值为小数，按截尾规则只保留整数部分。

例如：

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

T:1 1-5 2-10

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-瑶琴

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_瑶琴partially correct
20201103 Tom: 0 5~5

3、输出顺序变化

只要是正确格式的信息，可以以任意的先后顺序输入各类不同的信息。比如试卷可以出现在题目之前，删除题目的信息可以出现在题目之前等。

例如：

T:1 1-5 2-10

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-古筝

end
输出：
alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_古筝false
20201103 Tom: 0 0~0

4、多张试卷信息

本题考虑多个同学有多张不同试卷的答卷的情况。输出顺序优先级为学号、试卷号，按从小到大的顺序先按学号排序，再按试卷号。

例如：

T:1 1-5 2-10

T:2 1-8 2-21

N:1 #Q:1+1= #A:2

S:2 20201103 #A:1-2 #A:2-古筝

S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴

S:1 20201104 #A:1-2 #A:2-瑟

S:2 20201104 #A:1-5 #A:2-七弦琴

X:20201103 Tom-20201104 Jack

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

end
输出：
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=₅false
古琴在古代被称为：_{瑶琴或七弦琴}true
20201103 Tom: 0 10~10
1+1=₂true
古琴在古代被称为：_古筝false
20201103 Tom: 8 0~8
1+1=₂true
古琴在古代被称为：_瑟false
20201104 Jack: 5 0~5
1+1=₅false
古琴在古代被称为：_七弦琴partially correct
20201104 Jack: 0 10~10
新增的题目异常情况的处理与一般题目相同，具体样例参考上一次大作业的样例说明：
答题判题程序-3题面.pdf

输入样例1:
多选题测试，不含删除。例如：

N:1 #Q:1+1= #A:2

Z:2 #Q:党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信 #A:A B C D

T:1 1-5 2-9

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-A C

end
输出样例1:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
党十八大报告提出要加强()建设。A 政务诚信 B 商务诚信 C社会诚信 D司法公信~A C~partially correct
20201103 Tom: 0 4~4
输入样例2:
填空题测试，不含删除。例如：

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

T:1 1-5 2-10

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-瑶琴

end
输出样例2:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_瑶琴partially correct
20201103 Tom: 0 5~5
输入样例3:
乱序测试，不含删除。例如：

T:1 1-5 2-10

N:1 #Q:1+1= #A:2

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

X:20201103 Tom

S:1 20201103 #A:1-5 #A:2-古筝

end
输出样例3:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
1+1=₅false
古琴在古代被称为：_古筝false
20201103 Tom: 0 0~0
输入样例4:
两个同学多张不同试卷的答卷，不含删除。例如：

T:1 1-5 2-10

T:2 1-8 2-21

N:1 #Q:1+1= #A:2

S:2 20201103 #A:1-2 #A:2-古筝

S:1 20201104 #A:1-2 #A:2-瑟

S:1 20201103 #A:1-5 #A:2-瑶琴或七弦琴

S:2 20201104 #A:1-5 #A:2-七弦琴

X:20201103 Tom-20201104 Jack

K:2 #Q:古琴在古代被称为： #A:瑶琴或七弦琴

end
输出样例4:
在这里给出相应的输出。例如：

alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
1+1=₅false
古琴在古代被称为：_{瑶琴或七弦琴}true
20201103 Tom: 0 10~10
1+1=₂true
古琴在古代被称为：_古筝false
20201103 Tom: 8 0~8
1+1=₂true
古琴在古代被称为：_瑟false
20201104 Jack: 5 0~5
1+1=₅false
古琴在古代被称为：_七弦琴partially correct
20201104 Jack: 0 10~10

在原有的基础上加入了多选题，难度大增，应该在原有类的基础上新建立一个多选题类用于分别判断，其他没什么很需要注意的地方，以下是我的代码：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//删除信息库
ArrayList removeNum = new ArrayList<>();
//输入信息分流
String input ="";
//学生信息库
ArrayList stu = new ArrayList<>();
//试卷类的整体
NN paper = new NN();
//试卷类的题库部分
ArrayList Nbank = new ArrayList<>();
do{
input = in.nextLine();
String tempStr = input.substring(0,2);
if(tempStr.equals("#N")){////#N:1 #Q:1+1= #A:2
N n = new N(input);
Nbank.add(n);

            }//#T:1(试卷号) 1-5(题目-分数) 2-8
            //有分值但是没有题干答案的题要打印
            //(按着顺序打)non-existent question~0
            else if(tempStr.equals("#T")){
                input = input.substring(3);
                paper.setNid(input.charAt(0)+"");
                String[] score = input.substring(2).split(" ");
                paper.setPerScore(score);



            }//#X:20201103(学号) Tom(姓名)-(分隔符)20201104 Jack-20201104 Www
            else if(tempStr.equals("#X")){
                input = input.substring(3);
                String[] students = input.split("-");
                for (int i= 0;i<students.length;i++) {
                    X student = new X(students[i]);
                    stu.add(student);
                }



            }//#S:1 20201103 #A:1-5 #A:2-4
            else if(tempStr.equals("#S")){
                input = input.substring(3);
                if(input.charAt(0)=='1'){
                    String[] returnPaper = input.split(" ");
                    for (int i = 0; i < stu.size(); i++) {
                        if(stu.get(i).getSid().equals(returnPaper[1])){
                            stu.get(i).setResponse(returnPaper);
                            break;
                        }
                    }
                }
            }//#D:N-2
            else if(tempStr.equals("#D")){
                input = input.substring(3);
                String[] inputParts = input.split(" ");
                for (int i = 0; i < inputParts.length; i++) {
                    removeNum.add(inputParts[i]);
                }
            }
        }while(!input.equals("end"));

        //给每道题赋分值,这里还得考虑给没有题号的Nbank集合创建一个新的N类
        for (int paperIndex = 0;paperIndex<paper.getPerScore().length;paperIndex++) {
            boolean isFind = false;
            for(int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++){
                String[] parts = paper.getPerScore()[paperIndex].split("-");
                //parts[0]是标题,part[1]是分值

                if(parts[0].equals(Nbank.get(NbankIndex).getNname().substring(3))){
                    Nbank.get(NbankIndex).setScore(Integer.parseInt(parts[1]));
                    isFind = true;
                    break;
                }
            }
            if(!isFind){
                N wrongN = new N("");
                wrongN.setNname("#N:"+paper.getPerScore()[paperIndex].split("-")[0]);
                wrongN.setScore(Integer.parseInt(paper.getPerScore()[paperIndex].split("-")[1]));
                Nbank.add(wrongN);


        //用字符串数组确定有哪些是错误引用的题目
        ArrayList<String> wrongQuote =new ArrayList<>();
        for (int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++) {
            if(Nbank.get(NbankIndex).getScore()!=0&&Nbank.get(NbankIndex).getQstem()==""){
                String wrongNum = Nbank.get(NbankIndex).getNname().substring(3);
                wrongQuote.add(wrongNum);
            }
        }
        //添加移除标签
        for (int removeIndex = 0; removeIndex < removeNum.size(); removeIndex++) {
            for (int NbankIndex = 0; NbankIndex < Nbank.size(); NbankIndex++) {String title = removeNum.get(removeIndex).substring(2);
                if(title.equals(Nbank.get(NbankIndex).getNname().substring(3))){
                   Nbank.get(NbankIndex).setRemove(true);
                }
            }
        }
        //确立试卷
        paper.setNnum(Nbank);

        //alert: full score of test paper1 is not 100 points
        if(paper.getTotalScore()!=100){
            System.out.println("alert: full score of test paper"+paper.getNid()+" is not 100 points");
        }




        for (int stuNum = 0; stuNum < stu.size(); stuNum++) {
            if(stu.get(stuNum).getResponse().size()!=0){
                ArrayList<perN> per = stu.get(stuNum).getResponse();
                ArrayList<String> responseSituation = new ArrayList<>();
                int score = 0;
                //当遇到
                for (int perNindex = 0; perNindex < per.size(); perNindex++) {//以学生的作答情况进行遍历
                    //以试卷的题库进行核对

                    //将1-5 分为 1 和 5
                    String[] parts = per.get(perNindex).getRespond().split("-");

                    //parts[0]是题号 part[1]是答案

                    //试卷题号遍历题库
                    boolean isFind = false;
                    for (int paperNnum = 0; paperNnum < paper.getNnum().size(); paperNnum++) {
                        //getNnum 获得的是试卷上的题库
                        isFind = false;
                        String sid = paper.getNnum().get(paperNnum).getNname().substring(3);
                        //这个是消去'#N:'后的题号,可以与parts[0]直接对比
                                //题目的编号存在
                                if(parts[0].equals(sid)){
                                    if(paper.getNnum().get(paperNnum).getAnswer().equals("")){
                                        isFind = true;
                                        System.out.println("non-existent question~0");
                                        responseSituation.add("0");

                                    }
                                    else if (!paper.getNnum().get(paperNnum).isRemove()) {
                                        isFind = true;
                                        System.out.print(paper.getNnum().get(paperNnum).getQstem().substring(3)+"~"+parts[1]+"~");
                                        String answer = paper.getNnum().get(paperNnum).getAnswer().substring(3);
                                        String strScore = "0";

                                        if(parts[1].equals(answer)){
                                            System.out.println(true);
                                            //记录每次的分与总分,每次得分存在responseSituation,总分存在score里
                                            responseSituation.add(paper.getNnum().get(paperNnum).getScore()+"");
                                            score += Integer.parseInt(paper.getPerScore()[paperNnum]);

                                        }
                                        else {
                                            System.out.println(false);
                                        }
                                    }
                                else {
                                    //题目存在但是被删除了
                                        int ifRemoveIndex = Integer.parseInt(parts[0]);
                                        if(ifRemoveIndex<paper.getNnum().size()){
                                            if(paper.getNnum().get(ifRemoveIndex).isRemove()) {
                                                System.out.println("the question "+paper.getNnum().get(ifRemoveIndex).getNname().substring(3)+" invalid~0");
                                            }
                                        }


                                }

                                }
                            else {
                                //换下一个看看
                            }


                    }


                    if(isFind==false){
                        responseSituation.add("0");
                    }

                }

                //成绩打印部分

                stu.get(stuNum).setResponseSituation(responseSituation);
                if(paper.getNnum().size()- wrongQuote.size()>per.size()){
                    System.out.println("answer is null");
                }
                System.out.print(stu.get(stuNum).getSid()+" "+stu.get(stuNum).getSname()+":");
                for (int i1 = 0; i1 < responseSituation.size(); i1++) {
                    System.out.print(" "+responseSituation.get(i1));
                }
                System.out.print("~"+score);
            }
            else {
                continue;
            }
        }




    }











}

//建立题目类:#N (单个题目信息)
class N{
private String Nname;//题号
private String Qstem;//题干
private String Answer;//正确答案
private int score;//分值
private boolean isRemove;

public boolean isRemove() {
    return isRemove;
}

public void setRemove(boolean remove) {
    isRemove = remove;
}

public int getScore() {
    return score;
}

public void setScore(int score) {
    this.score = score;
}

public String getNname() {
    return Nname;
}

public void setNname(String nname) {
    Nname = nname;
}

public String getQstem() {
    return Qstem;
}

public void setQstem(String qstem) {
    Qstem = qstem;
}

public String getAnswer() {
    return Answer;
}

public void setAnswer(String answer) {
    Answer = answer;
}

public N() {
}

public N(String N) {
        String[] n =N.split(" ");
        if(n.length==3){
            Nname = n[0];
            Qstem = n[1];
            Answer = n[2];
        }
        else {

            Nname = "";
            Qstem = "";
            Answer = "";
        }


}

public String toString(){
    return Nname+" "+Qstem+" "+Answer+" "+score;
}

}
//建立试卷类:#N[] (整套试卷信息)
class NN{
private String Nid;//试卷编号
private ArrayList Nnum;//试卷全部题目
private String[] perScore;//试卷的每道题的题号与分值(形式: 1-5 )
private int totalScore;//试卷总分值

public String[] getPerScore() {
    return perScore;
}

public void setPerScore(String[] perScore) {
    this.perScore = perScore;
    calculateTotal();
}

public int getTotalScore() {
    return totalScore;
}

public void setTotalScore(int totalScore) {
    this.totalScore = totalScore;
}

public String getNid() {
    return Nid;
}

public void setNid(String nid) {
    Nid = nid;
}

public ArrayList<N> getNnum() {
    return Nnum;
}

public void setNnum(ArrayList<N> nnum) {
    Nnum = nnum;
}

public NN(String nid, ArrayList<N> nnum) {
    Nid = nid;
    Nnum = nnum;
}


public NN() {
}

public void calculateTotal(){
    //1-5 2-8
    int ret =0;
    for (int i = 0; i < this.perScore.length; i++) {
         ret += Integer.parseInt(perScore[i].substring(2));
    }
    totalScore = ret;
}

}

//建立答卷类:#X (学生的信息)
class X{
private String sname;//学生姓名
private String sid;//学生考号
private ArrayList response;//学生的作答情况
private int score;//学生的总分
private ArrayList responseSituation;

public ArrayList<String> getResponseSituation() {
    return responseSituation;
}

public void setResponseSituation(ArrayList<String> responseSituation) {
    this.responseSituation = responseSituation;
}

////1 20201103 #A:1-5 #A:2-4
public void setResponse(String[] response) {
    String[] strings = new String[response.length-2];
    for (int i = 0; i < strings.length; i++) {
        strings[i] = response[i+2];
        perN pn =new perN(response[i+2].substring(3),false,0);
            this.response.add(pn);
    }
}

public ArrayList<perN> getResponse() {
    return response;
}

public void setResponse(ArrayList<perN> response) {
    this.response = response;
}

public int getScore() {
    return score;
}

public void setScore(int score) {
    this.score = score;
}

public X() {
}

public X(String str) {
    //20201103(学号) Tom(姓名)-(分隔符)20201104 Jack-20201104 Www
    String[] s = str.split(" ");
    this.sname = s[1];
    this.sid = s[0];
    ArrayList<perN> p = new ArrayList<>();
    this.setResponse(p);
}

public String getSname() {
    return sname;
}

public void setSname(String sname) {
    this.sname = sname;
}

public String getSid() {
    return sid;
}

public void setSid(String sid) {
    this.sid = sid;
}

}
class perN{
private String respond;
private boolean isRight;
private int score;

public String getRespond() {
    return respond;
}

public void setRespond(String respond) {
    this.respond = respond;
}

public boolean isRight() {
    return isRight;
}

public void setRight(boolean right) {
    isRight = right;
}

public int getScore() {
    return score;
}

public void setScore(int score) {
    this.score = score;
}

public perN() {
}

public perN(String respond, boolean isRight, int score) {
    this.respond = respond;
    this.isRight = isRight;
    this.score = score;
}

}

4-2
设计一个学生类（Student）和它的一个子类——本科生类（Undergraduate）。要求如下：
（1）Student类有姓名（name）和年龄（age）属性，两者的访问权限为protected；一个包含两个参数的构造方法，用于给姓名和年龄属性赋值；一个show( )方法用于输出Student的属性信息，输出格式为Student[name=XXX,age=XX]。
（2）Undergraduate类增加一个专业（major）属性，该属性的访问权限为private；有一个包含三个参数的构造方法，前两个参数用于给继承的年龄和姓名属性赋值，第三个参数给专业属性赋值；一个show( )方法用于输出Undergraduate的属性信息，输出格式为Undergraduate[name=XXX,age=XXX,major=XXX]。

在测试类Main的main( )方法中，调用Student类的带参数的构造方法创建对象object1，调用Undergraduate类的带参数的构造方法创建对象object2，然后分别调用它们的show( )方法。

输入格式:
第一行从键盘输入姓名（字符串）、年龄（整数）给Student类的对象object1，中间以空格隔开。
第二行从键盘输入姓名（字符串）、年龄（整数）、专业（字符串）给Undergraduate类的对象object2，中间以空格隔开。

输出格式:
第一行输出object1的姓名、年龄，格式为：Student[name=XXX,age=XX]
第二行输出object2的姓名、年龄、专业，格式为： Undergraduate[name=XXX,age=XXX,major=XXX]

输入样例:
在这里给出一组输入。例如：

张三 12
李四 19 计算机科学与技术
输出样例:
在这里给出相应的输出，其中的标点符号为英文格式。例如：

Student[name=张三,age=12]
Undergraduate[name=李四,age=19,major=计算机科学与技术]

以下是我的代码：
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Student object1 =new Student(in.next(),in.nextInt());
Undergraduate object2 =new Undergraduate(in.next(),in.nextInt(),in.next());
object1.show();
object2.show();
}
}
class Student{

protected String name;
protected int age;

public void show(){
    System.out.println("Student[name="+name+",age="+age+"]");
}

public Student(String name, int age) {
    this.name = name;
    this.age = age;
}

Student(){
}
protected void setName(String name){
    this.name = name;
}
protected String getName(){
    return name;
}
protected int getAge(){
    return age;
}
protected void setAge(int age){
    this.age = age;
}

}

class Undergraduate extends Student{
private String major;

public Undergraduate(String name,int age,String major) {
    this.name = name;
    this.age = age;
    this.major = major;
}

public String getMajor() {
    return major;
}

public void setMajor(String major) {
    this.major = major;
}
public void show(){
    System.out.println("Undergraduate[name="+name+",age="+age+",major="+major+"]");
}

}

分析：

类定义和继承关系

1. Student 类

   • 属性：
     • name：学生的名字，类型为 String。
     • age：学生的年龄，类型为 int。
   • 构造方法：
     • Student(String name, int age)：带参数的构造方法，用于初始化 name 和 age。
     • Student()：无参构造方法。
   • 方法：
     • show()：打印学生的名字和年龄。
     • 一些 getter 和 setter 方法，用于访问和修改 name 和 age 属性。

2. Undergraduate 类

   • 继承自 Student 类，表示本科生。
   • 属性：
     • major：本科生的专业，类型为 String。
   • 构造方法：
     • Undergraduate(String name, int age, String major)：带参数的构造方法，用于初始化 name、age 和 major。
   • 方法：
     • show()：重写了 Student 类的 show() 方法，打印本科生的名字、年龄和专业。
     • getter 和 setter 方法，用于访问和修改 major 属性。

Main 类

• main 方法：
  • 创建一个 Scanner 对象 in，用于从控制台读取输入。
  • 读取用户输入的名字和年龄，创建一个 Student 对象 object1。
  • 读取用户输入的名字、年龄和专业，创建一个 Undergraduate 对象 object2。
  • 调用 object1 的 show() 方法，打印学生的信息。
  • 调用 object2 的 show() 方法，打印本科生的信息。

我的代码成功实现了：
如何使用继承来扩展类的功能，并通过控制台输入和输出演示了对象的创建和方法调用，达成了题目需求.

4-3

学校需要构建综合系统，使用者包含多种角色。角色Role分两类：学生Student和雇员Employee；雇员又分为教员Faculty和职员Staff。
每个角色都有姓名、性别。学生有学号、班级。一个雇员有工号、入职日期。教员有职称。职员有职位称号。
请以如下Main类为基础，构建各个角色类，将代码补充完整。

public class Main {
public static void main(String[] args) {
Faculty fac = new Faculty("张三",32,"33006","2019","10","25","讲师");
Student stu=new Student("李四",19,"20201103","202011");
Staff sta = new Staff("王五",27,"32011","2015","06","17","教务员");
fac.show();
sta.show();
stu.show();
}
}
输入格式:
无

输出格式:
我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

我是张三，年龄32岁。工号是33006，2019年10月25日入职。是一名教师，讲师职称。
我是王五，年龄27岁。工号是32011，2015年6月17日入职。是一名教务员。
我是李四，年龄19岁。学号是20201103，来自202011班。

我的代码：

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);

            Faculty fac = new Faculty("张三",32,"33006","2019","10","25","讲师");
            Student stu=new Student("李四",19,"20201103","202011");
            Staff sta = new Staff("王五",27,"32011","2015","06","17","教务员");
            fac.show();
            sta.show();
            stu.show();

    }

}
class Role{
private String name;
private int age;
private String id;
private String gender;

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 String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getGender() {
    return gender;
}

public void setGender(String gender) {
    this.gender = gender;
}

public Role(String name, int age, String id) {
    this.name = name;
    this.age = age;
    this.id = id;
}

public Role() {
}

}
class Student extends Role{
private String classId ;

public Student(String name, int age, String id, String classId) {
    super(name, age, id);
    this.classId = classId;
}

public Student(String classId) {
    this.classId = classId;
}

public String getClassId() {
    return classId;
}

public void setClassId(String classId) {
    this.classId = classId;
}
public void show(){
    System.out.println("我是"+getName()+"，年龄"+getAge()+"岁。学号是"+getId()+"，来自"+getClassId()+"班。");
}

}
class Employee extends Role{
private String date[];

public String[] getDate() {
    return date;
}

public void setDate(String[] date) {
    this.date = date;
}

public Employee(String name, int age, String id, String year,String mon,String day) {
    super(name, age, id);
    this.date = new String[3];
    this.date[0] = year;
    this.date[1] = mon;
    this.date[2] = day;
}

public Employee() {
}

}

class Faculty extends Employee{

public String getWork() {
    return work;
}

public void setWork(String work) {
    this.work = work;
}

private String work;
public Faculty(String name, int age, String id, String year, String mon, String day,String work) {
    super(name, age, id, year, mon, day);
    this.work = work;
}

public Faculty() {
    super();
}

public void show(){
    System.out.printf("我是%s，年龄%d岁。工号是%s，%s年%d月%d日入职。是一名教师，%s职称。",
            getName(),getAge(),getId(),getDate()[0],Integer.parseInt(getDate()[1]),Integer.parseInt(getDate()[2]),work);
    System.out.println();
}

}
class Staff extends Employee{
private String work;

public Staff(String name, int age, String id, String year, String mon, String day, String work) {
    super(name, age, id, year, mon, day);
    this.work = work;
}

public String getWork() {
    return work;
}

public void setWork(String work) {
    this.work = work;
}

public Staff(String work) {
    this.work = work;
}
public void show(){
    System.out.printf("我是%s，年龄%d岁。工号是%s，%s年%d月%d日入职。是一名%s。",
            getName(),getAge(),getId(),getDate()[0],Integer.parseInt(getDate()[1]),Integer.parseInt(getDate()[2]),work);
    System.out.println();
}

}

分析：

主程序（Main Class）

public class Main {
    public static void main(String[] args) {
     
        Scanner in = new Scanner(System.in);

        // 创建三个角色对象：一个教师，一个学生，一个职员
        Faculty fac = new Faculty("张三", 32, "33006", "2019", "10", "25", "讲师");
        Student stu = new Student("李四", 19, "20201103", "202011");
        Staff sta = new Staff("王五", 27, "32011", "2015", "06", "17", "教务员");

        // 调用每个对象的 show 方法，打印他们的信息
        fac.show();
        sta.show();
        stu.show();
    }
}

角色类（Role Class）

class Role {
    private String name;
    private int age;
    private String id;
    private String gender;

    // 各种 getter 和 setter 方法
    // 构造方法
    public Role(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Role() {
    }
}

Role 类是所有角色的基类，包含了基本的属性：姓名、年龄、ID 和性别（性别属性在子类中没有使用）。

学生类（Student Class）

class Student extends Role {
    private String classId;

    // 构造方法
    public Student(String name, int age, String id, String classId) {
        super(name, age, id);
        this.classId = classId;
    }

    // 显示学生信息的方法
    public void show() {
        System.out.println("我是" + getName() + "，年龄" + getAge() + "岁。学号是" + getId() + "，来自" + getClassId() + "班。");
    }
}

Student 类继承自 Role 类，增加了一个 classId 属性，表示班级编号。它有一个 show 方法用于打印学生的信息。

员工类（Employee Class）

class Employee extends Role {
    private String date[];

    // 构造方法
    public Employee(String name, int age, String id, String year, String mon, String day) {
        super(name, age, id);
        this.date = new String[3];
        this.date[0] = year;
        this.date[1] = mon;
        this.date[2] = day;
    }
}

Employee 类也是继承自 Role 类，增加了一个 date 数组属性，用于记录入职日期（年、月、日）。

教师类（Faculty Class）

class Faculty extends Employee {
    private String work;

    // 构造方法
    public Faculty(String name, int age, String id, String year, String mon, String day, String work) {
        super(name, age, id, year, mon, day);
        this.work = work;
    }

    // 显示教师信息的方法
    public void show() {
        System.out.printf("我是%s，年龄%d岁。工号是%s，%s年%d月%d日入职。是一名教师，%s职称。",
                getName(), getAge(), getId(), getDate()[0], Integer.parseInt(getDate()[1]), Integer.parseInt(getDate()[2]), work);
        System.out.println();
    }
}

Faculty 类继承自 Employee 类，增加了一个 work 属性，表示职称。它有一个 show 方法用于打印教师的信息。

职员类（Staff Class）

class Staff extends Employee {
    private String work;

    // 构造方法
    public Staff(String name, int age, String id, String year, String mon, String day, String work) {
        super(name, age, id, year, mon, day);
        this.work = work;
    }

    // 显示职员信息的方法
    public void show() {
        System.out.printf("我是%s，年龄%d岁。工号是%s，%s年%d月%d日入职。是一名%s。",
                getName(), getAge(), getId(), getDate()[0], Integer.parseInt(getDate()[1]), Integer.parseInt(getDate()[2]), work);
        System.out.println();
    }
}

Staff 类也是继承自 Employee 类，增加了一个 work 属性，表示职务。它有一个 show 方法用于打印职员的信息。

我段代码定义了一个简单的角色系统，包含学生、教职员工和职员三种角色。每个角色类都有自己的属性和方法，用于存储和展示角色的信息。在主程序中，创建了几个角色对象并调用它们的 show 方法打印出它们的信息,实现了题目要求

此题不难。

5-1

智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。

1、控制设备模拟

本题模拟的控制设备包括：开关、分档调速器、连续调速器。

开关：包括0和1两种状态。

开关有两个引脚，任意一个引脚都可以是输入引脚，而另一个则是输出引脚。开关状态为0时，无论输入电位是多少，输出引脚电位为0。当开关状态为1时，输出引脚电位等于输入电位。
分档调速器

按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器

没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚，一个固定的输入（引脚编号为1）、一个输出引脚（引脚编号为2）。当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。

所有控制设备的初始状态/档位为0。

控制设备的输入引脚编号为1，输出引脚编号为2。

2、受控设备模拟

本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。

灯有两种工作状态：亮、灭。在亮的状态下，有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态：停止、转动。风扇的转速会因引脚的电位差的不同而有区别。
本次迭代模拟两种灯具。

白炽灯：

亮度在0~200lux（流明）之间。
电位差为0-9V时亮度为0,其他电位差按比例，电位差10V对应50ux，220V对应200lux，其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯：

亮度为180lux。
只有两种状态，电位差为0时，亮度为0，电位差不为0，亮度为180。
本次迭代模拟一种吊扇。

工作电压区间为80V-150V，对应转速区间为80-360转/分钟。80V对应转速为80转/分钟，150V对应转速为360转/分钟，超过150V转速为360转/分钟（本次迭代暂不考虑电压超标的异常情况）。其他电压值与转速成正比，输入输出电位差小于80V时转速为0。
输入信息：

1、设备信息

分别用设备标识符K、F、L、B、R、D分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇。

设备标识用标识符+编号表示，如K1、F3、L2等。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。

三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件：

不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入，包含在连接信息中。

2、连接信息

一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。

格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。
约束条件：

本次迭代不考虑两个输出引脚短接的情况
考虑调速器输出串联到其他控制设备（开关）的情况
不考虑调速器串联到其他调速器的情况。
不考虑各类控制设备的并联接入或反馈接入。例如，K1的输出接到L2的输入，L2的输出再接其他设备属于串联接线。K1的输出接到L2的输出，同时K1的输入接到L2的输入，这种情况属于并联。K1的输出接到L2的输入，K1的输入接到L2的输出，属于反馈接线。
3、控制设备调节信息

开关调节信息格式：

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

分档调速器的调节信息格式：

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

连续调速器的调节信息格式：

+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

4、电源接地标识：VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。

输入信息以end为结束标志，忽略end之后的输入信息。

输出信息：

按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。

输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
本题不考虑输入电压或电压差超过220V的情况。

本题只考虑串联的形式，所以所有测试用例的所有连接信息都只包含两个引脚

本题电路中除了开关可能出现多个，其他电路设备均只出现一次。
电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

家居电路模拟系列所有题目的默认规则：

1、当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2、所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。

3、连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4、对于调速器，其输入端只会直连VCC，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。

家居电路模拟系列1-4题目后续迭代设计：

1、电路结构变化：

迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系

电路结构变化示意图见图1。

2、输入信息的变化

串联线路信息：用于记录一段串联电路的元件与连接信息。

例如： #T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]
#T1:[IN K1-1] [K1-2 M1-IN][M1-OUT D2-1] [D2-2 GND]
并联线路信息：用于记录一段并联电路所包含的所有串联电路信息。

例如：#M1:[T1 T2 T3]
以上格式仅做参考，格式细节可能会调整，以具体发布的为准。

3、计算方式的变化

迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。

4、电路元件的变化

每次迭代会增加1-2个新的电路元件。

image.png

图1：电路结构示意图

设计建议：

1、电路设备类：描述所有电路设备的公共特征。

2、受控设备类、控制设备类：对应受控、控制设备

3、串联电路类：一条由多个电路设备构成的串联电路，也看成是一个独立的电路设备

其他类以及类的属性、方法自行设计。

image.png

图2：建议设计类图

输入样例1:
在这里给出一组输入。例如：

[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]

K1

end
输出样例1:
在这里给出相应的输出。例如：

@K1:closed
@D2:360
输入样例2:
在这里给出一组输入。例如：

[VCC K1-1]
[K1-2 D2-1]
[D2-2 GND]

K1

K1

end
输出样例2:
在这里给出相应的输出。例如：

@K1:turned on
@D2:0
输入样例3:
在这里给出一组输入。例如：

[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]

F1+

end
输出样例3:
在这里给出相应的输出。例如：

@F1:1
@D2:0
输入样例4:
在这里给出一组输入。例如：

[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]

F1+

F1+

end
输出样例4:
在这里给出相应的输出。例如：

@F1:2
@D2:288
输入样例5:
在这里给出一组输入。例如：

[VCC F1-1]
[F1-2 D2-1]
[D2-2 GND]

F1+

F1+

F1+

end
输出样例5:
在这里给出相应的输出。例如：

@F1:3
@D2:360

输入样例6:
在这里给出一组输入。例如：

[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]

L1:1.00

end
输出样例6:
在这里给出相应的输出。例如：

@L1:1.00
@D2:360
输入样例7:
在这里给出一组输入。例如：

[VCC L1-1]
[L1-2 D2-1]
[D2-2 GND]

L1:0.68

end
输出样例7:
在这里给出相应的输出。例如：

@L1:0.68
@D2:358
输入样例8:
在这里给出一组输入。例如：

[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]

L1:0.68

end
输出样例8:
在这里给出相应的输出。例如：

@L1:0.68
@B2:149
输入样例9:
在这里给出一组输入。例如：

[VCC L1-1]
[L1-2 B2-1]
[B2-2 GND]

L1:1.00

end
输出样例9:
在这里给出相应的输出。例如：

@L1:1.00
@B2:200
输入样例10:
在这里给出一组输入。例如：

[VCC L1-1]
[L1-2 R2-1]
[R2-2 GND]

L1:1.00

end
输出样例10:
在这里给出相应的输出。例如：

@L1:1.00
@R2:180

我的代码：

import java.lang.module.FindException;
import java.util.*;

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 tempStr;
// 串联电路的连接信息
ArrayList machineInfo = new ArrayList<>();
// 对电路元件的配置修改信息
ArrayList circuitInfo = new ArrayList<>();

    String Eregex = "([A-Z]\\d+-\\d+)";
    Pattern Ept = Pattern.compile(Eregex);

    String Cregex = "#([^\\s]+)";
    Pattern Cpt = Pattern.compile(Cregex);

    while (true) {
        tempStr = in.nextLine();

        if (tempStr.equals("end")) {
            break;
        }

// 电路信息
Matcher eMat = Ept.matcher(tempStr);
while (eMat.find()) {
machineInfo.add(eMat.group(1));
}
// 元件信息
Matcher cMat =Cpt.matcher(tempStr);
while(cMat.find()){
circuitInfo.add(cMat.group(1));
}

    }
    //电路元件信息只能判断对哪些数据进行了修改，不能判断有哪些元件


    HashSet cset = new HashSet<>();
    for(String s : circuitInfo) {
        cset.add(s);
    }
    Iterator<String> cit = cset.iterator();
    int cIndex = 0;
    String[] cSet = new String[cset.size()];
    while (cit.hasNext()){
        String str = cit.next();
        cSet[cIndex++] = str;
    }


    HashSet eset = new HashSet<>();
    for(String s:machineInfo){
        eset.add(s.substring(0,2));
    }
    Iterator<String> eit = eset.iterator();
    int eIndex = 0;
    String[] eSet = new String[eset.size()];
    while (eit.hasNext()){
        String str = eit.next();
        eSet[eIndex++] = str;
    }


    ElecCircuit ec = new ElecCircuit();
    //电路元件配置

    //用电器配置
    for (int i=0;i< eset.size();i++){


        String machineName = eSet[i].substring(0,2);
        char machineType = machineName.toCharArray()[0];

       switch (machineType){
           case 'B':{
               WhiteLamp wl = new WhiteLamp();
               wl.setName(machineName);
               ec.addEm(wl);
           }break;
           case 'R':{
               DaylightLamp dl = new DaylightLamp();
               dl.setName(machineName);
               ec.addEm(dl);
           }break;
           case 'D':{
               Fan f = new Fan();
               f.setName(machineName);
               ec.addEm(f);
           }break;
           case 'K':{
               On_off of = new On_off();
               of.setOpen(true);
               of.setName(machineName);
               ec.addOn_off(of);
           }break;
           case 'F':{
               perStepper ps = new perStepper();
               ps.setName(machineName);
               ec.addPstepper(ps);

           }break;

           case 'L': {
               eveStepper es = new eveStepper();
               es.setName(machineName);
               ec.addEstepper(es);
           }break;

           default:break;
       }

    }

    //电路元件配置修改
    for (int InfoIndex = 0; InfoIndex < circuitInfo.size(); InfoIndex++) {
        String sit = circuitInfo.get(InfoIndex);
        String elecName = sit .substring(0,2);

        if(sit.toCharArray()[0] == 'K'){
            //初始状态是断开的，电路断开（保护电路）,要按一下
            for (int ofIndex = 0; ofIndex < ec.getOn_off().size(); ofIndex++) {
                if(ec.getOn_off(ofIndex).getName().equals(elecName)){
                        ec.getOn_off(ofIndex).setOpen(!ec.getOn_off(ofIndex).getIsOpen());
                        break;
                }
            }
        } else if(sit.toCharArray()[0] == 'F'){
            for (int gpIndex = 0; gpIndex < ec.getPstepper().size(); gpIndex++) {
                if(ec.getPstepper(gpIndex).getName().equals(elecName)){
                    if(sit.toCharArray()[2]=='+'){
                        ec.getPstepper(gpIndex).addStep();
                    } else if (sit.toCharArray()[2] =='-'){
                        ec.getPstepper(gpIndex).downStep();
                    }
                    break;
                }
            }
        } else if(sit.toCharArray()[0] == 'L'){
            double num = Double.parseDouble(sit.toString().substring(3));
            for (int geIndex = 0; geIndex < ec.getEstepper().size(); geIndex++) {
                if(ec.getEstepper(geIndex).getName().equals(elecName)){
                    ec.getEstepper(geIndex).setPara(num);
                    break;
                }
            }
        }
    }

    //调配电路

    setCirVolt(ec,220.0,0);
    showAllInfo(ec);
    in.close();
}
public static void setCirVolt(ElecCircuit ec, double ovolt,int emIndex){
   double volt = ovolt;
   double para = 1;


    if(allClose(ec.getOn_off()) == false) {
        ovolt = 0;
    }
    for (int geIndex = 0; geIndex < ec.getEstepper().size(); geIndex++) {
        para *= ec.getEstepper(geIndex).getPara();
    }
    for (int gpIndex = 0; gpIndex < ec.getPstepper().size(); gpIndex++) {
        para *= ec.getPstepper(gpIndex).getPara();
    }

    ovolt *= para;

    ec.getEm(emIndex).setVolt(ovolt);


}
public static void  showAllInfo(ElecCircuit ec){

    for (int index = 0; index < ec.getOn_off().size(); index++) {
        ec.getOn_off().get(index).showInfo();
    }

    for (int i = 0; i < ec.getPstepper().size(); i++) {
        ec.getPstepper(i).showInfo();
    }

    for (int i = 0; i < ec.getEstepper().size(); i++) {
        ec.getEstepper(i).showInfo();
    }

    for (int i = 0; i < ec.getEm().size(); i++) {
        ec.getEm(i).showInfo();
    }
}


public static boolean allClose(ArrayList<On_off> of){
    for (int i = 0; i < of.size(); i++) {
        if(of.get(i).getIsOpen()==true){
            return false;
        }
    }
    return true;
}

}
class ElecCircuit{

private ArrayList<On_off> on_off;
private ArrayList<perStepper> pstepper;
private ArrayList<eveStepper> estepper;
private ArrayList<ElecMachine> em;




public ElecCircuit(){
    on_off = new ArrayList<>();
    pstepper =  new ArrayList<>();
    estepper = new ArrayList<>();
    em = new ArrayList<>();
}

public ArrayList<On_off> getOn_off() {
    return on_off;
}


public void setOn_off(ArrayList<On_off> on_off) {
    this.on_off = on_off;
}
public void  addOn_off(On_off of){
    if(on_off==null){
        on_off =new ArrayList<>();
    }
    on_off.add(of);
}
public On_off getOn_off(int index) {
    if(on_off == null){
        return null;
    }
    if(index>=0 && index<on_off.size()){
        return on_off.get(index);
    }
    return null;

}

public ArrayList<eveStepper> getEstepper() {
    return estepper;
}

public void setEstepper(ArrayList<eveStepper> stepper) {
    this.estepper = stepper;
}
public void addEstepper(eveStepper es){
    if(estepper == null){
        estepper = new ArrayList<>();
    }
    estepper.add(es);
}
public eveStepper getEstepper(int index) {
    if(estepper == null){
        return null;
    }
    if(index>=0 && index<estepper.size()){
        return estepper.get(index);
    }
    return null;
}


public ArrayList<perStepper> getPstepper() {
    return pstepper;
}

public void setPstepper(ArrayList<perStepper> stepper) {
    this.pstepper = stepper;
}
public void addPstepper(perStepper ps){
    if(pstepper == null){
        pstepper = new ArrayList<>();
    }
    pstepper.add(ps);
}
public perStepper getPstepper(int index){
    if(pstepper == null){
        return null;
    }
    if(index>=0 && index<pstepper.size()){
        return pstepper.get(index);
    }
    return null;
}

public ArrayList<ElecMachine> getEm() {
    return em;
}
public ElecMachine getEm(int index){
    if(em == null){
        return null;
    }
    if(index>=0 && index<em.size()){
        return em.get(index);
    }
    return null;
}


public void setEm(ArrayList<ElecMachine> em) {
    this.em = em;
}
public void  addEm(ElecMachine em){
    this.em.add(em);
}

}
class HasName{
private String name;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

}
class On_off extends HasName{
private boolean isOpen;
public void showInfo(){
if(isOpen){
System.out.println("@"+getName()+":turned on");
} else {
System.out.println("@"+getName()+":closed");
}
}

public On_off() {
}

public On_off(boolean isOpen) {
    this.isOpen = isOpen;
}

public boolean getIsOpen() {
    return isOpen;
}

public void setOpen(boolean open) {
    isOpen = open;
}

}
/////调速器
abstract class Stepper extends HasName{
//参数
private double para;

public Stepper(double para) {
    this.para = para;
}

public double getPara() {
    return para;
}

public void setPara(double para) {
    this.para = para;
}

public Stepper() {
}
public abstract void showInfo();

}
class perStepper extends Stepper{
private int step;
public void addStep(){
if(step<3){
step++;
}
caculatePara();
}
public void downStep(){
if(step>0){
step--;
}
caculatePara();
}
public perStepper(){
step = 0;
caculatePara();
}

@Override
public void showInfo() {
    System.out.println("@"+getName()+":"+step);
}

private void caculatePara(){
    switch (step){
        case 0:
            setPara(0);break;
        case 1:
            setPara(0.3);break;
        case 2:
            setPara(0.6);break;
        case 3:
            setPara(0.9);break;
        default:break;
    }

}

}
class eveStepper extends Stepper{
public eveStepper(){
}

@Override
public void showInfo() {
    System.out.printf("@%s:%.2f",getName(),getPara());
    System.out.println();
}

public eveStepper(double p){
    super(p);
}

}

abstract class ElecMachine extends HasName{

private double volt;
public abstract void showInfo();

public double getVolt() {
    return volt;
}

public void setVolt(double volt) {
    this.volt = volt;
}

}

abstract class Lamp extends ElecMachine{
private double brightness;

public double getBrightness() {
    return brightness;
}

public void setBrightness(double brightness) {
    this.brightness = brightness;
}

public abstract void caculateBri();

}
//三个用电器调用 调速器 的参数计算它们的效能
class WhiteLamp extends Lamp{

@Override
public void showInfo() {
    caculateBri();
    System.out.printf("@%s:%d",getName(),(int)getBrightness());
    System.out.println();
}

@Override
public void caculateBri() {
    //0~9v :0
    //10v :50
    //220v :200
    //1.4v/lux
    double volt = getVolt();
    if(volt<=9){
        setBrightness(0.0);
    } else if(volt>=220){
        setBrightness(200.0);
    } else {
        setBrightness(50+(volt-10)*((150.0)/210));
    }
}

}

class DaylightLamp extends Lamp{
public DaylightLamp(){
}

public DaylightLamp(double bright){
    setBrightness(bright);
}



@Override
public void showInfo() {
    caculateBri();
    System.out.printf("@%s:%d",getName(),(int)getBrightness());
    System.out.println();
}

@Override
public void caculateBri() {
    double volt = getVolt();
    if(volt>0){
        setBrightness(180);
    } else{
        setBrightness(0);
    }
}

}

class Fan extends ElecMachine{
private double rspeed;

public Fan(){
}
public Fan(double rspeed){
    this.rspeed = rspeed;
}
public void  caculateRsp(){
    //<80 v :0
    //80~150 :80+p
    //>=150 :360
        // 4r/v
    double volt = getVolt();
    if(volt<80){
        rspeed  = 0;
    } else if(volt>=150){
        rspeed = 360;
    } else {
        rspeed = (int) (80 + 4*(volt-80));
    }

}

public double getRspeed() {
    return rspeed;
}

public void setRspeed(double rspeed) {
    this.rspeed = rspeed;
}

@Override
public void showInfo() {
    caculateRsp();
    System.out.printf("@%s:%d",getName(),(int)getRspeed());
    System.out.println();
}

}

/*

*/

新出现的大作业：

主要步骤为：
1.提取信息->2.创建电路->3.改变电路信息->4.打印电路信息
其中的1.提取信息的正则表达式是个难点
注意事项：
1.创建电路的成员类型分配是个难点
2.改变电路信息里多个开关是个潜在测试点，还有各个调速器的对电压的参数的分配也是个难点
3.打印电路信息里需要注意的是所有数据成员为确保精度都是用double 类型声明，但最后输出结果的时候要强转为int 类型（不然样例7和样例8总有一个通不过）

其他地方因为题目给出的示例足够多，所以只要对着样例反复调试一个一个修正即可。

5-2

功能：
使用集合存储多个学生的信息（有序);
获取学生总数，并按照存储顺序;
按照存储顺序获取各个学生的信息并逐条输出
备注：请学生复制以下代码到编程区进行改错。
//1考查集合导包
class Student{

private String no;
private String name;

public Student(String no, String name) {
super();
this.no = no;
this.name = name;
}
public Student() {
super();
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Student [no=" + no + ", name=" + name + "]";
}
}

public class Main {

public static void main(String[] args) {
// 创建学生对象
Student stu1 = new Student("1001","zs");
Student stu2 = new Student("1002","ls");

//2考查集合接口的实例化
//创建有序集合List，并向集合中添加学生，
List students=new List();
students.add(stu1);
students.add(stu2);

//计算学生人数,显示学生信息                    
for(int i=0;i<students.size();i++) {
    //3考查遍历方法和向下转型
    Student stu=students.get(i);
    System.out.println("no:"+stu.getNo()+"\t name:"+stu.getName());
}            

}
}

输入格式:
无

输出格式:
no:1001 name:zs
no:1002 name:ls

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

no:1001 name:zs
no:1002 name:ls

分析：
一道简单题

1. 导入必要的类：

   import java.util.ArrayList;
   import java.util.Scanner;
   

   • ArrayList 是 Java 集合框架中的一个类，用于存储有序的对象列表。
   • Scanner 用于从控制台读取输入，但在这段代码中并没有实际使用。

2. 定义主类 Main 和入口方法 main：

   class Main {
       public static void main(String[] args) {
           // 创建学生对象
           Student stu1 = new Student("1001", "zs");
           Student stu2 = new Student("1002", "ls");
   

   • Main 类包含 main 方法，这是 Java 程序的入口点。
   • 创建了两个 Student 对象 stu1 和 stu2，分别表示学号为 "1001"、姓名为 "zs" 的学生和学号为 "1002"、姓名为 "ls" 的学生。

3. 创建 ArrayList 并添加学生对象：

           ArrayList<Student> students = new ArrayList<>();
           students.add(stu1);
           students.add(stu2);
   

   • 创建了一个 ArrayList<Student> 对象 students，用于存储学生对象。
   • 将前面创建的 stu1 和 stu2 添加到 students 列表中。

4. 遍历 ArrayList 并显示学生信息：

           for (int i = 0; i < students.size(); i++) {
               Student stu = students.get(i);
               System.out.println("no:" + stu.getNo() + "     name:" + stu.getName());
           }
       }
   }
   

   • 使用 for 循环遍历 students 列表。
   • 在每次循环中，通过 students.get(i) 获取当前索引 i 处的学生对象 stu。
   • 使用 System.out.println 输出学生的学号和姓名。

5. 定义 Student 类：

   class Student {
       private String no;
       private String name;
   
       public Student(String no, String name) {
           this.no = no;
           this.name = name;
       }
   
       public Student() {
       }
   
       public String getNo() {
           return no;
       }
   
       public void setNo(String no) {
           this.no = no;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public String toString() {
           return "Student [no=" + no + ", name=" + name + "]";
       }
   }
   

   • Student 类包含两个私有属性 no（学号）和 name（姓名）。
   • 提供了一个构造方法，用于初始化学号和姓名。
   • 提供了默认构造方法。
   • 提供了 getNo 和 getName 方法用于获取学号和姓名。
   • 提供了 setNo 和 setName 方法用于设置学号和姓名。
   • 重写了 toString 方法，返回学生对象的字符串表示形式。

总结：
我这段代码创建了一个学生类 Student，并在 Main 类中创建了两个学生对象，然后将这些对象添加到一个 ArrayList 中。最后，遍历这个列表并打印出每个学生的学号和姓名，实现题目要求

5-3

功能需求：
使用集合存储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

分析：

1. 导入相关包

import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;

这些导入语句引入了 Java 标准库中的一些类，例如 Collection、ArrayList、Scanner 和 Iterator，这些类在后续的代码中将被使用。

2. 定义员工类

class Employee {
    private String name;
    private int age;

    public Employee() {
    }

    public Employee(String name, int age) {
        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;
    }
}

Employee 类表示一个员工对象，包含两个私有属性 name（名字）和 age（年龄）。这个类还提供了构造函数、getter 和 setter 方法，用于初始化和访问这些属性。

3. 主函数

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Collection<Employee> c = new ArrayList<>();

Main 类包含程序的入口点 main 方法。首先，创建一个 Scanner 对象 sc 用于从控制台读取输入。然后，创建一个 ArrayList 对象 c，用于存储 Employee 对象。

4. 创建3个员工对象并添加到集合中

        for (int i = 0; i < 3; i++) {
            String employeeName = sc.next();
            int employeeAge = sc.nextInt();
            Employee employee = new Employee(employeeName, employeeAge);
            c.add(employee);
        }

通过一个 for 循环，程序读取用户输入的员工名字和年龄，创建 Employee 对象，并将这些对象添加到集合 c 中。这个循环运行三次，因此将创建并添加三个员工对象。

5. 遍历集合并打印员工信息

        Iterator<Employee> it = c.iterator();

        while (it.hasNext()) {
            Employee e = it.next();
            System.out.println(e.getName() + "---" + e.getAge());
        }
    }
}

创建一个迭代器 it 用于遍历集合 c。通过 while 循环和 it.hasNext() 方法，程序检查集合中是否还有未遍历的元素。然后，通过 it.next() 方法获取下一个 Employee 对象，并打印其名字和年龄。

总结

俺这段代码实现了以下功能：

1. 定义了一个 Employee 类，用于表示员工对象，包含名字和年龄属性。
2. 在 main 方法中，使用 Scanner 从控制台读取用户输入，创建三个 Employee 对象，并将它们存储在一个 ArrayList 中。
3. 使用迭代器遍历集合，并打印每个员工的名字和年龄。

然后满足了题目要求.

6-1

智能家居是在当下家庭中越来越流行的一种配置方案，它通过物联网技术将家中的各种设备（如音视频设备、照明系统、窗帘控制、空调控制、安防系统、数字影院系统、影音服务器、影柜系统、网络家电等）连接到一起，提供家电控制、照明控制、电话远程控制、室内外遥控、防盗报警、环境监测、暖通控制、红外转发以及可编程定时控制等多种功能和手段。与普通家居相比，智能家居不仅具有传统的居住功能，兼备建筑、网络通信、信息家电、设备自动化，提供全方位的信息交互功能。请根据如下要去设计一个智能家居强电电路模拟系统。以下题目介绍中加粗的部分为本次迭代在“家居强电电路模拟程序-1”的基础上增加的功能要求。

1、控制设备

本题模拟的控制设备包括：开关、分档调速器、连续调速器。

开关：包括0和1两种状态。

开关有两个引脚，任意一个引脚都可以是输入引脚，而另一个则是输出引脚。开关状态为0时，无论输入电位是多少，输出引脚电位为0。当开关状态为1时，输出引脚电位等于输入电位。
分档调速器

按档位调整，常见的有3档、4档、5档调速器，档位值从0档-2（3/4）档变化。本次迭代模拟4档调速器，每个档位的输出电位分别为0、0.3、0.6、0.9倍的输入电压。
连续调速器

没有固定档位，按位置比例得到档位参数，数值范围在[0.00-1.00]之间，含两位小数。输出电位为档位参数乘以输入电压。
所有调速器都有两个引脚，一个固定的输入（引脚编号为1）、一个输出引脚（引脚编号为2）。当输入电位为0时，输出引脚输出的电位固定为0，不受各类开关调节的影响。

所有控制设备的初始状态/档位为0。

控制设备的输入引脚编号为1，输出引脚编号为2。
所有开关的电阻为 0。

2、受控设备

本题模拟的受控设备包括：灯、风扇。两种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。

灯有两种工作状态：亮、灭。在亮的状态下，有的灯会因引脚电位差的不同亮度会有区别。
风扇在接电后有两种工作状态：停止、转动。风扇的转速会因引脚间电位差的不同而有区别。
本次迭代模拟两种灯具。

白炽灯：

亮度在0~200lux（流明）之间。
电位差为0-9V时亮度为0,其他电位差按比例，电位差10V对应50ux，220V对应200lux，其他电位差与对应亮度值成正比。白炽灯超过220V。
日光灯：

亮度为180lux。
只有两种状态，电位差为0时，亮度为0，电位差不为0，亮度为180。
本次迭代模拟一种吊扇。

工作电压区间为80V-150V，对应转速区间为80-360转/分钟。80V对应转速为80转/分钟，150V对应转速为360转/分钟，超过150V转速为360转/分钟（本次迭代暂不考虑电压超标的异常情况）。其他电压值与转速成正比，输入输出电位差小于80V时转速为0。
本次迭代模拟一种落地扇。

工作电压区间为 [80V,150V]，对应转速区间为 80-360 转/分钟。电压在[80,100)V 区间对应转速为 80 转/分 钟，[100-120)V 区间对应转速为 160 转/分钟，[120-140)V 区间对应转速为 260 转/分钟，超过 140V 转速 为 360 转/分钟（本次迭代暂不考虑电压超标的异常情况）输入信息：
本次迭代考虑电阻：白炽灯的电阻为 10，日光灯的电阻为 5，吊扇的电阻为 20，落 地扇的电阻为 20

3、输入信息

1）输入设备信息

分别用设备标识符K、F、L、B、R、D、A分别表示开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇。

设备标识用标识符+编号表示，如K1、F3、L2等。
引脚格式：设备标识-引脚编号，例如：K1-1标识编号为1的开关的输入引脚。

三种控制开关的输入引脚编号为1，输出引脚编号为2。
受控设备的两个引脚编号分别为1、2。
约束条件：

不同设备的编号可以相同。
同种设备的编号可以不连续。
设备信息不单独输入，包含在连接信息中。

2）输入连接信息

一条连接信息占一行，用[]表示一组连接在一起的设备引脚，引脚与引脚之间用英文空格" "分隔。

格式："["+引脚号+" "+...+" "+引脚号+"]"
例如：[K1-1 K3-2 D5-1]表示K1的输入引脚，K3的输出引脚，D5的1号引脚连接在一起。
约束条件：

不考虑调速器串联到其他调速器的情况。
不考虑调速器串联到其他调速器的情况。
考虑各类设备的并联接入。例如，K1 的输出接到 L2 的输入，L2 的输出再接其他设备属于串联接线。K1 的输出接到 L2 的输出，同时 K1 的输入接到 L2 的输入，这种情况属于并联。
本次迭代的连接信息不单独输入，包含在线路信息中。

3）输入控制设备调节信息

开关调节信息格式：

+设备标识K+设备编号，例如：#K2，代表切换K2开关的状态。

分档调速器的调节信息格式：

+设备标识F+设备编号+"+" 代表加一档，例如：#F3+，代表F3输出加一档。

+设备标识F+设备编号+"-" 代表减一档，例如：#F1-，代表F1输出减一档。

连续调速器的调节信息格式：

+设备标识L+设备编号+":" +数值 代表将连续调速器的档位设置到对应数值，例如：#L3:0.6，代表L3输出档位参数0.6。

4）电源接地标识：

VCC，电压220V，GND，电压0V。没有接线的引脚默认接地，电压为0V。

5）输入串联电路信息

一条串联电路占一行，串联电路由按从靠电源端到接地端顺序依次输入的 n 个连接 信息组成，连接信息之间用英文空格" "分隔。

串联电路信息格式：

"#T"+电路编号+":"+连接信息+" "+连接信息+...+" "+连接信息
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一个串联电路的第一个引脚是 IN，代表起始端，靠电源。最后一个引脚是 OUT，代表结尾端， 靠接地。
约束条件：

不同的串联电路信息编号不同。
输入的最后一条电路信息必定是总电路信息，总电路信息的起始引脚是 VCC，结束引脚是 GND。
连接信息中的引脚可能是一条串联或并联电路的 IN 或者 OUT。例如：

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

6）输入并联电路信息

一条并联电路占一行，并联电路由其包含的几条串联电路组成，串联电路标识之间用英文空格" "分隔。

格式：

"#M"+电路编号+":"+”[”+串联电路信息+" "+....+" "+串联电路信息+”]”
例如：#M1:[T1 T2 T3]
该例声明了一个并联电路，由 T1、T2、T3 三条串联电路并联而成，三条串联电路的 IN 短 接在一起构成 M1 的 IN，三条串联电路的 OUT 短接在一起构成 M1 的 OUT。
约束条件：

本次迭代不考虑并联电路中包含并联电路的情况，也不考虑多个并联电路串联的情况。
本题不考虑输入电压或电压差超过220V的情况。

输入信息以end为结束标志，忽略end之后的输入信息。

本题中的并联信息所包含的串联电路的信息都在并联信息之前输入，不考虑乱序输入的情况。
只要不造成短路而产生无穷大的电流烧坏电路，都是合理情况，在测试点的考虑范围之内。本次大作业不考虑短路的情况，测试点中不包括短路的电路。

本题不考虑一条串联电路中包含其他串联电路的情况。例如：

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2两条串联电路实际是T3的一个部分，本题不考虑这种类型的输入，而是当将T1\T2的所有连接信息直接包含在T3中定义。
下次迭代中需要考虑这种类型的输入。
4、输出信息：

按开关、分档调速器、连续调速器、白炽灯、日光灯、吊扇、落地扇的顺序依次输出所有设备的状态或参数。每个设备一行。同类设备按编号顺序从小到大输出。

输出格式：@设备标识+设备编号+":" +设备参数值（控制开关的档位或状态、灯的亮度、风扇的转速，只输出值，不输出单位）
连续调速器的档位信息保留两位小数，即使小数为0，依然显示两位小数.00。
开关状态为0（打开）时显示turned on，状态为1（合上）时显示closed
如：
@K1:turned on
@B1:190
@L1:0.60
5、家居电路模拟系列所有题目的默认规则：

1）当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2）所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

3）连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4）调速器的输入端只会直连VCC，不会接其他设备。整个电路最多只有连接在电源上的一个调速器，且不包含在并联单路中。

6、家居电路模拟系列1-4题目后续迭代设计：

1）电路结构变化：

迭代1：只有一条线路，所有元件串联
迭代2：线路中包含一个并联电路
迭代3：线路中包含多个串联起来的并联电路
迭代4：并联电路之间可能出现包含关系

电路结构变化示意图见图1。

2）计算方式的变化

迭代1只包含1个受控元件，不用计算电流，之后的电路计算要包含电流、电阻等电路参数。

3）电路元件的变化

每次迭代会增加1-2个新的电路元件。

image.png

图1：电路结构示意图

设计建议：

1、电路设备类：描述所有电路设备的公共特征。

2、受控设备类、控制设备类：对应受控、控制设备

3、串联电路类：一条由多个电路设备构成的串联电路，也看成是一个独立的电路设备

4、并联电路类：继承电路设备类，也看成是一个独立的电路设备

其他类以及类的属性、方法自行设计。

image.png

图2：建议设计类图

输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。

输出格式:
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。

输入样例1:
在这里给出一组输入。例如：

T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]

T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]

M1:[T1 T2]

T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]

K1

end
输出样例1:
在这里给出相应的输出。例如：

@K1:closed
@K2:turned on
@L1:0.00
@D1:0
@D2:0
@D3:0
输入样例2:
在这里给出一组输入。例如：

T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]

T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]

M1:[T1 T2]

T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]

K1

L1:1.00

end
输出样例2:
在这里给出相应的输出。例如：

@K1:closed
@K2:turned on
@L1:1.00
@D1:0
@D2:200
@D3:200
输入样例3:
在这里给出一组输入。例如：

T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT]

T2:[IN K2-1] [K2-2 D1-1] [D1-2 OUT]

M1:[T1 T2]

T3:[VCC L1-1] [L1-2 M1-IN] [M1-OUT D3-1] [D3-2 GND]

K1

K2

L1:1.00

end
输出样例3:
在这里给出相应的输出。例如：

@K1:closed
@K2:closed
@L1:1.00
@D1:0
@D2:0
@D3:346

分析：
这次示例比较少，在原有的基础上建立并联类,电路系统类，
以下是注意事项：
1.要考虑短路与断路的情况，不然拿不到最后30分

2.分配电压要小心小心再小心，不然电压用电阻比例分配电压可能会无穷大。（说你呢并联电路）

3.其他通过不了的点去问你的同学！！！即使他们不会帮你看代码也会给你写几个测试案例，让你看看自己的问题。（在下最后20分就是靠我可爱的同学写的案例修改代码通过的）

总结：
我学会了继承与多态和综合地管理数据，但对于多态的声明切换，还需要再熟悉熟悉。