我的第二次oop
阅读目录
前言
第四次PTA
第五次PTA
第六次PTA
总结
前言
一：对于java的进一步认识
Java是一种强大、跨平台的编程语言，它以面向对象为核心，拥有自动内存管理、丰富的API和广泛的社区支持。Java的广泛应用领域包括Web开发、移动应用开发、企业级应用以及大数据处理等，其易用性和高性能使得它成为现代软件开发的首选之一。
二：对于三次PTA的理解
1.第四次PTA的作业是答题判题的最后一次迭代了，就证明了基本上它已经被完善了，难度也来到了这道题的最高处。
2.第五次PTA的作业是新的一次迭代的大类题了，肯定的第一次嘛，相对的是都会简单一点的，主要是起一个带我们进入这道大题的作用。
3.第六次PTA的作业进一步加大了这道题的难度，导致有很多同学都放弃了，无作为（虽然我也不是很好，但是我至少努力到了最后一刻）。
第四次PTA
设计与分析
这次作业是答题判题的最后一次PTA了也就是完善版了（虽然看的出来其实这道题的迭代还没有到最完善的地步，但他确实是答题判题的最后一次作业了，有可能是因为有学生反应太难了吧）、
以下是我这次作业类的设计
Question类（这是个父类）：
只是简单的定义了子类的共同属性。
Question1类（子类）：
Question2类（子类）：
Question3类（子类）：
以上是关于Question的所用
Student类：
StudentAnswer类：（代码有点长就发代码）
点击查看代码
class StudentAnswer{
private int num;
private String id;
private int[] questionNum = new int[100];
private String[] questionAnswer = new String[100];
public StudentAnswer(){
}
public StudentAnswer(int num, String id, int[] questionNum, String[] questionAnswer){
this.num = num;
this.id = id;
this.questionNum = questionNum;
this.questionAnswer = questionAnswer;
}
public int getNum(){
return num;
}
public String getId(){
return id;
}
public int[] getQuestionNum(){
return questionNum;
}
public String[] getQuestionAnswer(){
return questionAnswer;
}
public void setNum(int num){
this.num = num;
}
public void setId(String id){
this.id = id;
}
public void setQuestionNum(int[] questionNum){
this.questionNum = questionNum;
}
public void setQuestionAnswer(String[] questionAnswer){
this.questionAnswer = questionAnswer;
}
public int getaAllQuestionNum(){
int n;
for(n = 0; n < 100; n++){
if(getQuestionNum()[n] == 0){
return n;
}
}
return 0;
}
}
Test类：
点击查看代码
class Text{
private int textNum;
private int[] questionNum = new int[100];
private int[] questionScore = new int[100];
public Text(){
}
public Text(int textNum, int[] questionNum, int[] questionScore){
this.textNum = textNum;
this.questionNum = questionNum;
this.questionScore = questionScore;
}
public int getTextNum(){
return textNum;
}
public int[] getQuestionNum(){
return questionNum;
}
public int[] getQuestionScore(){
return questionScore;
}
public void setTextNum(int textNum){
this.textNum = textNum;
}
public void setQuestionNum(int[] questionNum){
this.questionNum = questionNum;
}
public void setQuestionScore(int[] questionScore){
this.questionScore = questionScore;
}
public int getaAllQuestionNum(){
int n;
for(n = 0; n < 100; n++){
if(getQuestionNum()[n] == 0){
return n;
}
}
return 0;
}
}
Delete类：
allJudgment类：
这个类是基本上所有判断方法的集合，有点长，我一点一点的说明。
这个是所有类的关联。
点击查看代码
public int questionErrorJudgment(int questionNum){
for(int i = 0; i < kindNum.getNum()[2]; i++){
if(question[i].getErrorNum() == questionNum){
System.out.println("non-existent question~0");
return 0;
}
}
return 1;
}
public int questionAndDeleteJudgment(int questionNum){
int n = 0;
for(int i = 0; i < kindNum.getNum()[2]; i++){
if(delete[i].getQuestionNum() == questionNum){
System.out.println("the question " + questionNum + " invalid~0");
return 0;
}
}
return 1;
}
public int questionAndTextJudgment(int questionNum, int textNum){
int n = 0;
for(int i = 0; i < studentAnswer[textNum-1].getaAllQuestionNum(); i++){
if(studentAnswer[textNum-1].getQuestionNum()[i] != questionNum){
n++;
}
}
int m = 0;
for(int i = 0; i < kindNum.getNum()[0]; i++){
if(question[i + 1].getQuestionNum() != questionNum){
m++;
}
}
if(n == studentAnswer[textNum-1].getaAllQuestionNum() && m == kindNum.getNum()[0]){
System.out.println("non-existent question~0");
return 0;
}
return 1;
}
public void studentAndAnswerJudgment(){
int x = 0, y = 0, z = 0, n = 0, a = 0;
int score = 0;
for(int i = 0; i < kindNum.getNum()[1]; i++){
for(int j = 0; j < kindNum.getNum()[4]; j++){
if(studentAnswer[i].getNum() == text[j].getTextNum()){
int[] error = new int[text[i].getaAllQuestionNum()];
for(int k = 0; k < text[i].getaAllQuestionNum(); k++){
x = 0;
a = questionAndTextJudgment(text[i].getQuestionNum()[k],text[j].getTextNum());
for(int l = 0; l < studentAnswer[j].getaAllQuestionNum(); l++){
if(text[i].getQuestionNum()[k] == studentAnswer[j].getQuestionNum()[l]){
y = questionAndDeleteJudgment(text[i].getQuestionNum()[k]);
z = questionErrorJudgment(text[i].getQuestionNum()[k]);
if (y == 1&&z == 1) {
for(int t = 0; t < kindNum.getNum()[0]; t++){
if(question[t + 1].getQuestionNum() == text[i].getQuestionNum()[k]){
System.out.print(question[t + 1].getQuestion() + "~" + studentAnswer[j].getQuestionAnswer()[l] + "~");
}
}
if(studentAnswer[j].getQuestionAnswer()[l].equals(question[text[i].getQuestionNum()[k]].getAnswer())){
System.out.println("true");
score += text[i].getQuestionScore()[studentAnswer[j].getQuestionNum()[l]-1];
error[text[i].getQuestionNum()[k] - 1] = 1;
}
else if (question[text[i].getQuestionNum()[k]].getAnswer().contains(studentAnswer[j].getQuestionAnswer()[l])){
System.out.println("partially correct");
score += text[i].getQuestionScore()[studentAnswer[j].getQuestionNum()[l]-1] / 2;
error[text[i].getQuestionNum()[k] - 1] = 2;
}
else{
System.out.println("false");
error[text[i].getQuestionNum()[k] - 1] = 0;
score += 0;
}
}
}
else{
x++;
}
}
if(x == studentAnswer[j].getaAllQuestionNum()&&y == 1&&a == 1){
System.out.println("answer is null");
score += 0;
}
}
System.out.print(studentAnswer[j].getId() + " ");
for(n = 0; n < kindNum.getNum()[3]; n++){
if(studentAnswer[j].getId().equals(student[n].getId())){
System.out.print(student[n].getName() + ": ");
for(int m = 0; m < text[i].getaAllQuestionNum(); m++){
if((m + 1) == text[i].getaAllQuestionNum()){
if(error[m] == 0){
System.out.println("0~" + score);
}
else if(error[m] == 1){
System.out.println(text[i].getQuestionScore()[text[i].getQuestionNum()[m]-1] + "~" + score);
}
else{
System.out.println(text[i].getQuestionScore()[text[i].getQuestionNum()[m]-1] / 2 + "~" + score);
}
}
else{
if(error[m] == 0){
System.out.print("0 ");
}
else if(error[m] == 1){
System.out.print(text[i].getQuestionScore()[text[i].getQuestionNum()[m]-1] + " ");
}
else{
System.out.print(text[i].getQuestionScore()[text[i].getQuestionNum()[m]-1] / 2 + " ");
}
}
}
break;
}
}
if(n == kindNum.getNum()[3]){
System.out.println("not found");
}
}
}
}
}
这是大部分的判断方法，还有的在Main里。
Main类:
点击查看代码
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = 0;
int[] topic1 = new int[100];
int[] score1 = new int[100];
String question = new String();
String answer1 = new String();
int[] questionNum = new int[100];
String[] questionAnswer = new String[100];
Question[] questions = new Question[100];
Text[] text = new Text[100];
Student[] students = new Student[100];
Delete[] delete = new Delete[100];
StudentAnswer[] studentAnswers = new StudentAnswer[100];
for (int i = 0; i < 100; i++) {
questions[i] = new Question();
text[i] = new Text();
students[i] = new Student();
delete[i] = new Delete();
studentAnswers[i] = new StudentAnswer();
}
int num1 = 0, num2 = 0, num3 = 0, num4 = 0, num5 = 0;
int j = 0, k = 0, l = 0;
while(true){
String all = sc.nextLine();
if(all.equals("end"))
break;
if(all.charAt(1) == 'N'){
String[] textDelete = all.split("#N:| ");
int c = Integer.parseInt(textDelete[1]);
String regex = ("^#N:\\s*(\\d+) #Q\\s*:(.+) #A:\\s*(.+)");
Question question1 = new Question1();
if(all.matches(regex)){
Pattern pattern1 = Pattern.compile(regex);
Matcher matcher = pattern1.matcher(all);
if (matcher.find()){
m = Integer.parseInt(matcher.group(1).trim());
question = matcher.group(2).trim();
answer1 = matcher.group(3).trim();
num1++;
}
question1.setQuestionNum(m);
question1.setQuestion(question);
((Question1)question1).setAnswer(answer1);
questions[m] = question1;
}
else{
System.out.println("wrong format:" + all);
question1.setErrorNum(c);
}
}
if(all.charAt(1) == 'T'){
int score = 0;
String[] textPaper = all.split("#T:| |-");
m = Integer.parseInt(textPaper[1]);
for(int i = 2; i < textPaper.length; i++){
if(i % 2 == 1){
score1[j] = Integer.parseInt(textPaper[i]);
score += score1[j];
j++;
}
if(i % 2 == 0){
topic1[k] = Integer.parseInt(textPaper[i]);
k++;
}
}
if(score != 100){
System.out.println("alert: full score of test paper" + m + " is not 100 points");
}
text[num2].setTextNum(m);
text[num2].setQuestionNum(topic1);
text[num2].setQuestionScore(score1);
num2++;
}
if(all.charAt(1) == 'D'){
String[] textDelete = all.split("#D:N-| |N-");
m = Integer.parseInt(textDelete[1]);
delete[num3].setQuestionNum(m);
num3++;
}
if(all.charAt(1) == 'X'){
String[] studentID = all.split("#X:| |-");
for(int i = 1; i < studentID.length; i = i + 2){
String studentId = studentID[i];
String studentName = studentID[i+1];
students[num4].setId(studentId);
students[num4].setName(studentName);
num4++;
}
}
if(all.charAt(1) == 'S') {
String[] studentPaper1= all.split("#S:| #A:");
String[] studentPaper2= studentPaper1[1].split(" ");
m = Integer.parseInt(studentPaper2[0]);
String ID = studentPaper2[1];
for(int z = 2; z < studentPaper1.length; z++){
String[] studentPaper3= studentPaper1[z].split("-");
questionNum[l] = Integer.parseInt(studentPaper3[0]);
questionAnswer[l] = studentPaper3[1].trim();
l++;
}
studentAnswers[num5].setNum(m);
studentAnswers[num5].setId(ID);
studentAnswers[num5].setQuestionNum(questionNum);
studentAnswers[num5].setQuestionAnswer(questionAnswer);
num5++;
}
if(all.charAt(1) == 'Z') {
String[] questionAndAnswer1 = all.split("#Z:| #A:| #Q:");
m = Integer.parseInt(questionAndAnswer1[1]);
String questionMuch = questionAndAnswer1[2];
String answerMuch = questionAndAnswer1[3];
Question question2 = new Question2();
question2.setQuestionNum(m);
question2.setQuestion(questionMuch);
((Question2)question2).setAnswer(answerMuch);
questions[m] = question2;
num1++;
}
if(all.charAt(1) == 'K') {
String[] questionAndAnswer2 = all.split("#K:| #A:| #Q:");
m = Integer.parseInt(questionAndAnswer2[1]);
Question question3 = new Question3();
question3.setQuestionNum(m);
question3.setQuestion(questionAndAnswer2[2]);
((Question3)question3).setAnswer(questionAndAnswer2[3]);
questions[m] = question3;
num1++;
}
}
int[] num = new int[5];
num[0] = num1;
num[1] = num2;
num[2] = num3;
num[3] = num4;
num[4] = num5;
allKindNum kindNum = new allKindNum(num);
allJudgment judgment = new allJudgment(questions,text,students,delete,studentAnswers,kindNum);
judgment.studentAndTextJudgment();
judgment.studentAndAnswerJudgment();
}
}
PowerDesigner输出例如：
可以看出答题判题的最后一次作业的类图还是挺复杂的。
下面是SourceMonitor的测试结果：
而这也就是这道题最后的表现了。
代码我就不一步一步的分析了主要是时间有点久远了，现在在去看这些代码太耽误时间了，就自行判断，本人就只做最后的总结和反思了。
！！！以上代码皆为不完全正确代码仍有许多问题需要处理。！！！（好难！）
踩坑心得
1.如上一次所说的，将这类题吃透，显然我还是没有做到，依旧只是达到了合格的水平远远达不到掌握的程度。
2.正如上一次所答的一样这次的PTA我在很早是就和同学一起讨论了只不过，碍于自己想标新立异的思想下，未完成此任务。
3.这次考虑到在#~之前是可以输入如何东西的，但是不会报输入格式错误的问题，但是又有了新的问题的出先，新的问题总是出行和被解决中，旧的问题还在堆积中。
4.有了前几次的经验，这次在理解时是透彻了，可以理解很多情况是什么样子的，但是自己的想法实现起来又显得十分冗杂，导致的代码的可读性不高，总是在用最基础的知识去解决复杂的问题，这就很难受了。
改进建议
1.下次的PTA要早做打算，是新的一次迭代了，相对的，第一次的难度是不高的，争取取得高分。
2.和同学讨论并不是抄袭，而是你们一起解决问题，这种技能的培养是十分重要的，这有助于在我们今后的日常生活中提高我们的办事效率。
3.在课下的闲暇时间里加强对java的学习，更加熟悉java的使用。
第五次PTA
设计与分析
这次是新的作业的迭代了
以下是类的分析
Device类：（抽象类）
ElectricalAppliance类：（抽象类）
Control类：（抽象类）
Switch类：
Fan类：
IncandescentLamp类：
FluorescentLamp类：
BinningGovernor类：
ContinuousGovernor类：
Mian类。
分析：
其中ElectricalAppliance类和Control类是Device类的子类；
Switch类、BinningGovernor类和ContinuousGovernor类是Control类的子类；
最后FluorescentLamp类、IncandescentLamp类和Fan类是ElectricalAppliance类的子类。
PowerDesigner输出例如：
看的出第一的迭代类图还是比较简单的，但相对的不第一次的PTA难度还是上升了的。
接下来的是SourceMonitor的测试结果：
输入是全部放在Main类中了，代码如下：
点击查看代码
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num1 = 0,num2 = 0;
int n = 0;
double gears = 0, voltage = 0;
String all = "";
String[] device = new String[100];
while (true){
all = sc.nextLine();
if(all.equals("end"))
break;
if(all.charAt(0) == '['){
String all1 = "";
Pattern pattern = Pattern.compile("\\[(.+)\\]");
Matcher matcher = pattern.matcher(all);
while (matcher.find()) {
all1 = matcher.group(1);
}
String[] all2 = all1.split(" |-");
if(all2[0].charAt(0) == 'V'){
voltage = 220;
device[n] = all2[1];
n++;
continue;
}
device[n] = all2[2];
n++;
if(all2[2].charAt(0) == 'G'&&n > 1){
device[n] = all2[0];
continue;
}
}
if(all.charAt(0) == '#'){
if(all.charAt(1) == 'K'){
num1++;
}
if(all.charAt(1) == 'F'){
if(all.charAt(3) == '+'){
num2++;
}
else
num2--;
}
if(all.charAt(1) == 'L'){
String[] lian = all.split("#L|:");
gears = Double.parseDouble(lian[2]);
}
}
}
ArrayList<Device> devices = new ArrayList<>();
for(int i = 0; i < n; i++){
if(device[i].charAt(0) == 'K'){
Switch aSwitch = new Switch(device[i],1,2);
for (int j = 0; j < num1; j++) {
aSwitch.changeState();
}
devices.add(aSwitch);
}
if(device[i].charAt(0) == 'F'){
BinningGovernor binningGovernor = new BinningGovernor(device[i],1,2);
if(num2 >= 4){
num2 = 3;
}
if(num2 < 0){
num2 = 0;
}
binningGovernor.setGears(num2);
devices.add(binningGovernor);
}
if(device[i].charAt(0) == 'L'){
ContinuousGovernor continuousGovernor = new ContinuousGovernor(device[i],1,2,gears);
devices.add(continuousGovernor);
}
if(device[i].charAt(0) == 'B'){
IncandescentLamp incandescentLamp = new IncandescentLamp(device[i],1,2);
devices.add(incandescentLamp);
}
if(device[i].charAt(0) == 'R'){
FluorescentLamp fluorescentLamp = new FluorescentLamp(device[i],1,2);
devices.add(fluorescentLamp);
}
if(device[i].charAt(0) == 'D'){
Fan fan = new Fan(device[i],1,2);
devices.add(fan);
}
}
for (int i = 0; i < devices.size(); i++) {
if(devices.get(i) instanceof Control){
voltage = ((Control)devices.get(i)).computeVoltage(voltage);
devices.get(i).toPrintln(voltage);
}
}
for (int i = 0; i < devices.size(); i++) {
if(devices.get(i) instanceof Control){
continue;
}
devices.get(i).toPrintln(voltage);
}
}
代码是有点侥幸的心理在里面的，所以代码是有一点长的。
踩坑心得
1.因为是第一次迭代，题目难度不算很大，只是题目理解上还是有点不清楚，在同学的帮助下才最终理解的。
2.写作业的时间有点晚了，时间也不太充足，所以最后也没有到满分，差了三分，但是这三分是知道该怎么改的，但是有点多，复杂，所以就没有再花时间在这个上面了。
改进建议
1.下次的PTA要早一点着手准备开始写了，不能再像这次的一样，急急忙忙的写了，时间肯定是不够的。
2.多问问同学，一起讨论讨论，进步会更快。
3.java的这个作业PTA的难度还是有点，尽力去做吧。
第六次PTA
设计与分析
这次的迭代怎么说呢，感觉难度其实并没有加大多少，感觉是可以拿捏它的，结果最后反被拿捏了。
所建类分析：
Device类：（抽象类）
ElectricalAppliance类：（抽象类）
Control类：（抽象类）
Switch类：
Fan类：
IncandescentLamp类：
FluorescentLamp类：
BinningGovernor类：
ContinuousGovernor类：
FloorFan类：
Concatenation类：
点击查看代码
class Concatenation {//串联
private ArrayList<ParallelConnection> parallelConnection ;
private ArrayList<String> device = new ArrayList<>();
public Concatenation() {
}
public Concatenation(ArrayList<ParallelConnection> parallelConnection, ArrayList<String> device) {
this.parallelConnection = parallelConnection;
this.device = device;
}
public ArrayList<String> getDevice() {
return device;
}
public void setDevice(ArrayList<String> device) {
this.device = device;
}
public void setParallelConnection(ArrayList<ParallelConnection> parallelConnection) {
this.parallelConnection = parallelConnection;
}
public ArrayList<ParallelConnection> getParallelConnection() {
return parallelConnection;
}
public double totalResistance(ArrayList<String> aSwitches,int[] num) {
double resistance = 0;
for (int i = 0; i < device.size(); i++) {
switch (device.get(i).charAt(0)){
case 'K':resistance = resistance + 0;
break;
case 'B':resistance = resistance + 10;
break;
case 'R':resistance = resistance + 5;
break;
case 'D':resistance = resistance + 20;
break;
case 'A':resistance = resistance + 20;
break;
case 'M':resistance = resistance + ShuntResistance(aSwitches,num);
break;
default:
break;
}
}
return resistance;
}
public double ShuntResistance(ArrayList<String> aSwitches,int[] num){
double resistance = 0, resistance1 = 0;
for (int i = 0; i < parallelConnection.size(); i++) {
resistance += 1/parallelConnection.get(i).totalResistance(aSwitches,num);
}
resistance1 = 1/resistance;
return resistance1;
}
public double TributaryVoltage(ArrayList<String> aSwitches,int[] num){
double voltage = 0;
voltage = 220*(ShuntResistance(aSwitches,num)/totalResistance(aSwitches,num));
return voltage;
}
public double MainVoltage(ArrayList<String> aSwitches,int[] num){
double voltage = 0;
voltage = 220 - TributaryVoltage(aSwitches,num);
return voltage;
}
public void ToPrintln(ArrayList<String> aSwitches,int[] num){
ArrayList<String> device1 = new ArrayList<>();
int i,j,k;
for (i = 0; i < device.size(); i++) {
if(device.get(i).charAt(0) == 'M')
continue;
device1.add(device.get(i));
}
for (j = 0; j < parallelConnection.size(); j++) {
for (k = 0; k < parallelConnection.get(j).getDevice().size(); k++) {
device1.add(parallelConnection.get(j).getDevice().get(k));
}
}
char[] type = {'K','F','L','B','R','D','A'};
for (int l = 0; l < type.length; l++) {
for (int m = 0; m < device1.size(); m++) {
if(device1.get(m).charAt(0) == type[l]){
}
}
}
}
}
ParallelConnection类：
点击查看代码
class ParallelConnection{//并联类
private ArrayList<String> device = new ArrayList<>();
public ParallelConnection() {
}
public ParallelConnection(ArrayList<String> device) {
this.device = device;
}
public ArrayList<String> getDevice() {
return device;
}
public void setDevice(ArrayList<String> device) {
this.device = device;
}
public double totalResistance(ArrayList<String> aSwitches,int[] num) {
ArrayList<Device> devices = new ArrayList<>();
double resistance = 0;
int n = 0;
for (int i = 0; i < device.size(); i++) {
switch (device.get(i).charAt(0)){
case 'K':
n = 0;
Switch aSwitch = new Switch();
for (int j = 0; j < aSwitches.size(); j++) {
if(device.get(i).equals(aSwitches.get(j))){
aSwitch = new Switch(device.get(i),1,2,num[j]);
resistance = resistance + 0;
n = 1;
}
}
if(n == 1){
aSwitch = new Switch(device.get(i),1,2,0);
resistance = resistance + 0;
}
devices.add(aSwitch);
if (aSwitch.changeState() == 0){
n = 2;
}
break;
case 'B': resistance = resistance + 10;
break;
case 'R':resistance = resistance + 5;
break;
case 'D':resistance = resistance + 20;
break;
case 'A':resistance = resistance + 20;
break;
default:
break;
}
if (n == 2) {
resistance = 0;
break;
}
}
return resistance;
}
}
Mian类。
其中ElectricalAppliance类和Control类是Device类的子类；
Switch类、BinningGovernor类和ContinuousGovernor类是Control类的子类；
最后FluorescentLamp类、IncandescentLamp类、Fan类和FloorFan类是ElectricalAppliance类的子类。
Concatenation类和ParallelConnection类是独立出来的单独类，与其他类关联，其电路作用。
PowerDesigner输出例如：
因为一部分的原因，类图看着反而更加简单了，实际上一个会更加复杂才对。
接下来的是SourceMonitor的测试结果：
输入是全部放在Main类中了，代码如下：
点击查看代码
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
ArrayList<String> aSwitches = new ArrayList<>();
ArrayList<String> aSwitch = new ArrayList<>();
ArrayList<String> circuit2 = new ArrayList<>();
ArrayList<ParallelConnection> parallelConnections = new ArrayList<>();
Concatenation concatenation = new Concatenation();
int num1 = 0,num2 = 0;
int n = 0,m = 0;
double gears = 0;
String all = "";
while (true){
all = sc.nextLine();
if(all.equals("end")){
break;
}
if(all.charAt(1) == 'T'){
String circuit1 = "";
String regex = "\\[([^\\]]+)\\]";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(all);
int i = 1;
while (matcher.find()) {
circuit1 += matcher.group(1) + " ";
}
String[] circuit = circuit1.split("IN |-| OUT| ");
circuit[0] = String.valueOf(all.charAt(2));
ArrayList<String> device = new ArrayList<>();
for(int j = 0; j+3< circuit.length; j=j+4){
device.add(circuit[j+3]);
}
if(circuit1.charAt(0) == 'I' ){
ParallelConnection temp = new ParallelConnection();
temp.setDevice(device);
parallelConnections.add(temp);
}
if(circuit1.charAt(0) == 'V'){
concatenation.setDevice(device);
concatenation.setParallelConnection(parallelConnections);
}
}
if(all.charAt(1) == 'M'){
Pattern pattern1 = Pattern.compile("#M1:\\[([\\S]+)\\s+([\\S]+)\\]");
Matcher matcher1 = pattern1.matcher(all);
if (matcher1.find()) {
circuit2.add(matcher1.group(1));
circuit2.add(matcher1.group(2));
}
}
if(all.charAt(1) == 'K'){
String[] switch1 = all.split("#");
aSwitches.add(switch1[1]);
}
if(all.charAt(1) == 'F'){
if(all.charAt(3) == '+'){
num2++;
}
else
num2--;
}
if(all.charAt(1) == 'L'){
String[] lian = all.split("#L|:");
gears = Double.parseDouble(lian[2]);
}
}
int[] numK = new int[aSwitches.size()];
aSwitch.add(aSwitches.get(0));
numK[0] = 1;
for (int i = 0; i < aSwitches.size(); ) {
n = 1;
for (int j = i + 1; j < aSwitches.size(); j++) {
if(aSwitches.get(i).equals(aSwitches.get(j))){
for (int k = 0; k < aSwitch.size(); k++) {
if(aSwitch.get(k).equals(aSwitches.get(j))){
numK[k]++;
n++;
}
}
}
else{
for (int k = 0; k < aSwitch.size(); k++) {
if(!aSwitch.get(k).equals(aSwitches.get(j))){
aSwitch.add(aSwitches.get(j));
numK[k+1] = 1;
break;
}
}
break;
}
}
if(n != 0){
i = i + n;
}
else {
i++;
}
}
concatenation.ToPrintln(aSwitches,numK);
}
提示：这道题的代码很low，应该狠狠的反思自己。
踩坑心得
1.因为没有处理好电器的名字和创建数数据的关系，导致的之后在使用的时候会很麻烦，会显得代码很难看，很垃圾。
2.在本人尽力的拯救和抢救下，悬着的心终于死了。
3.下次的作业一定要将电器名字和电器的类联系处理好，要将电器跟着代码走不能等到最后再来处理。
改进建议
1.下次的PTA要再想好了类图之间的关系和建立数组再去开始写，不能随便就开始，想到什么就写什么，这遇见简单的编程还好，但是如果遇见了复杂的或者说遇见了像作业一样的迭代的话会很麻烦，基本上每次都需要重新思考，会浪费很多时间，一定要有大体的思路了再去写 。
2.PTA的难度是有的，如果你想拿到高分的话就一定是要付出努力和汗水的，不能随随便便就了事了。
总结
1.PTA的难度是有的，如果你想拿到高分的话就一定是要付出努力和汗水的，不能随随便便就了事了。
2.三次题集的难度是有目共睹的，不能像第一次一样按照自己的想法随便编写，需要严格按照要求来，有自己的想法固然是好事，但一定是要在要求下才可以，用得好是锦上添花，否则就变成了不按照规则办事，适得其反，一定要循规蹈矩的一步一步的往前走。
3.如果以后有机会遇见迭代的题时，一定要一步一步走踏实了，建好基础才可以在后面的题目中走的更远，爬的更高。
4.理论上来说一道题类建的越多就应该越简单，但是还是要根据题目来建立，不管任何盲目的建立只会使代码更加混乱。
5.类一定要履行单一职责原则这样会使代码更加清晰明了，不至于将自己写昏。
浙公网安备 33010602011771号