前言
三次题目集难度逐渐增大，前面的小题都是送分题，不用多说，难点在于最后一个大题。
大题十分考验类的各司其职，难度功能慢慢增加。
知识点主要是
1.类的分装
2.arraylist集合的使用
3.以及正则表达式的使用，不使用正则表达式也可以写，但是过多的if和else的判断语句会使得我们的代码显得格外杂乱。
题量中规中矩，但该花的时间还是很多的，万万不能赶在最后几个小时完工，这是血的教训。
设计与分析
import java.util.*;

public class Main{
public static void main(String[] args) {

	 ArrayList<String> list = new ArrayList<String>();
	 Scanner sc = new Scanner(System.in);
	
	 String line = null ;
	 while(!"end".equals(line = sc.nextLine())){
	 list.add(line);
	 }
	String []str=new String[list.size()*2];
	for(int i=0;i<list.size()*2;i=i+2) {
		int index=list.get(i).indexOf("[");
		int index1=list.get(i).indexOf(" ");
		int index2=list.get(i).indexOf("]");
		str[i]=list.get(i).substring(index,index1);
		str[i+1]=list.get(i).substring(index1+1,index2);
	}
	for(int i=0;i<list.size()*2;i++) {
	int index=str[i].indexOf('-');
 if(str[i].substring(0,index-1).equals('K')) {
	 String k=str[i].substring(0,index);
	 Kaiguan K=new Kaiguan();
	 K.setName(k);
	 if(K.isCondition()) {
		 K.setConditionelse("turned on");
	 }
	 else
		 K.setConditionelse("closed");
	 K.display();
 }
	
	
	}
	
	
      }

}
class Fendang{
private String name;
private Famvote vote1;
private int gear;
private Count count;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void ingear() {
gear=0;
for(int i=0;i<count.getCount();i++)
{
gear++;
}
}
public Fendang() {

}
public Fendang(Famvote vote1,int gear,Count count) {
	this.vote1=vote1;
	this.gear=gear;
	this.count=count;
}
public void setVote() {
switch(gear) 
{case 0:
	vote1.setVote(vote1.getVote()*0);
	break;
case 1:
	vote1.setVote(vote1.getVote()*0.3);
	break;
case 2:
	vote1.setVote(vote1.getVote()*0.6);
	break;
case 3:
	vote1.setVote(vote1.getVote()*0.9);
	break;
}

}
public int getGear() {
return gear;
}
public void setGear(int gear) {
this.gear = gear;
}

}
class Lianxu{
private String name;
private double gearnum;
private Famvote vote2;
public Lianxu() {

}
public Lianxu(double gearnum,Famvote vote2) {
	this.gearnum=gearnum;
	this.vote2=vote2;
}

public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public double getGearnum() {
	return gearnum;
}
public void setGearnum(double gearnum) {
	this.gearnum = gearnum;
}
public void setVote() {
	vote2.setVote(gearnum*vote2.getVote());
}

}
class Kaiguan{
private boolean condition;
private String name;
private String conditionelse;
public Kaiguan() {

}

public String getConditionelse() {
return conditionelse;
}

public void setConditionelse(String conditionelse) {
this.conditionelse = conditionelse;
}

public String getName() {
return name;
}

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

public Kaiguan(boolean condition) {
this.condition=condition;
}
public boolean isCondition() {
return condition;
}

public void setCondition(boolean condition) {
	this.condition = condition;
}
public void changecondition() {
	if(condition==false) {
		condition=true;
	}
	else
		condition=false;
}
public void display() {
	System.out.print("@"+name+":"+conditionelse);
}

}

class Famvote{
private double vote;
public Famvote(){

}
public Famvote(double vote) {
this.vote=vote;
}
public double getVote() {
return vote;
}
public void setVote(double vote) {
this.vote = vote;
}

}
class Count{
private char changegear;
private int count;
public void total() {
count=0;
if(changegear=='+') {
count++;
}
else
count--;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}

}
class Bailight{
private String name;
private double lightlevel;
private int vote;
}
class Rilight{
private String name;
private double lightlevel;
private int vote;
}

class Fan{
private String name;
private int vote;
private int vlevel;
}

采坑心得

其次，主函数所承担的职责过多，并且各种循环以及判断语句使得代码显得十分臃肿。

所以总的来说就是面对过程到面向对象的思想转变还没有转过来，以及没有使用正则表达式去简化自己的代码。
还有代码格式的习惯问题，也是使得我的代码可读性非常低的原因，这些都是需要在后面慢慢去调整过来的问题所在。
以及我在写代码时遇到的Java类封装的一些难点:
访问控制修饰符:正确使用访问控制修饰符(公共、私有、受保护、默认)是实现封装的关键。根据类的设计和要求，合理设置成员变量和方法的访问权限，控制对类内部细节的访问。
其次是数据隐藏和封装:将类的内部数据(成员变量)声明为private，可以通过公共getter和setter方法隐藏和封装数据，以访问和修改数据。但是，在设计getter和setter方法时，需要考虑数据一致性、安全性和合理性。
最后是暂时未涉及的异常处理：在封装类时，需要合理地处理异常。可以将可能抛出异常的方法声明为 throws 异常，以便调用者能够捕获和处理异常。同时，需要在类内部使用 try-catch 块来处理可能发生的异常，以避免程序崩溃。
与此同时还有下一次大作业可能会增加的类的继承和多态，需要提前进行学习。在封装类时，需要考虑类的继承关系和多态性。子类可以继承父类的成员变量和方法，但需要根据需要重新定义或覆盖父类的方法，以实现更具体的行为。同时，需要处理好父类和子类之间的访问权限和方法调用。
从面向过程到面向对象的转变需要注意的几个点总结一下，分别是这样的：理解对象和类的概念：面向对象编程的核心是对象和类，需要理解对象的属性和方法，以及类的定义和继承关系。对于习惯了面向过程编程的开发者来说，这需要一定的时间和努力来适应。
设计对象和类：在面向对象编程中，需要将问题分解为多个对象，并设计合适的类来表示这些对象。这需要开发者具备良好的面向对象设计能力，能够正确地识别对象和定义类。
理解封装和继承：封装和继承是面向对象编程的重要特性，需要理解封装的概念和作用，以及继承的原理和使用方法。对于习惯了面向过程编程的开发者来说，这需要一定的时间和努力来适应。处理多态性：多态性是面向对象编程的另一个重要特性，需要理解多态性的概念和作用，以及如何在代码中实现多态性。对于习惯了面向过程编程的开发者来说，这需要一定的时间和努力来适应。
理解面向对象编程的思想：面向对象编程是一种不同于面向过程编程的编程思想，需要理解面向对象编程的思想和原则，如封装、继承、多态性、抽象等。对于习惯了面向过程编程的开发者来说，这需要一定的时间和努力来适应。
第一次大作业
第一次大作业的难度其实是偏简单的，题目的设计大概也只是为了让我们这群学生慢慢熟悉从面向过程到面向对象的实质性转变，但是怎么说呢，如果用面向过程的思想来做也确实能做出来，但是在后面的添加功能也让我吃了很大的瘪。
第一个大问题：作为已经习惯了使用main函数来完成所有事情的我，实操起来是有点困难的
第二个大问题：并且这次作业实际上需要学习Arraylist的用法，我一开始并没有注意到，因此导致了第一次大作业的失分。
第三个大问题：几个类的分工合作在我的第一次大作业中并没有得到很好的体现，因此也让我在后面更加地发难。包括像试卷类，答案类我都没有做实质性的操作，这是在第一次大作业中的困难之处。
第二次大作业
第二次大作业在第一次的基础上新增了多个试卷以及多个答卷的功能，并且因为第一次的大作业的代码可读性以及修改性十分的低，代码分区的耦合性过高，导致我需要全盘重写，浪费了大量的时间，并且分数也并不理想。
第一个大问题：思路上出现问题，不知道如何将各个对应的功能分装到各个类当中，糊里糊涂地又将好几个功能装入了主函数当中，包括答案的比对，试卷问题和答案集合的封装。
第二个大问题：习惯性地将集合或者是数组在if语句中定义，导致了出判断语句后集合或者数组失去作用。
第三个大问题：在单试卷测试点中数组存在了越界地问题，但是多个试卷测试点却是正确输出，至今未找到问题所在。
第四个大问题：对正则表达式运用不熟练，导致过多地if和else语句导致代码十分杂乱，可读性低。
第三次大作业
增加删除功能，是我的薄弱点，不会写。
对前三次大作业的综合性总结：
难度适中，主要是一个面向过程到面向对象的思想的转变尤为困难，需要花时间去适应。
其次是时间的分配问题，题目的阅读也需要大量时间，所以需要安排充足的时间去完成代码的编写与调试，以及对代码可读性，耦合性的一些改善。
小小建议：时间太紧，平时要做的事情太多，感觉时时都在绷紧神经，对于像我这样资质平平的代码仔，压力还是有点大的。