- 答题判断程序4
- 题目分析：：
答题判断程序4是接着答题判断程序3的，增加了多选题和填空题，进行了多个同学多张试卷的排序。对于多选题和填空题，这和单选题是一样的，题目设置依旧不变，只是在答案部分多添加了一个ansersArrayList存储答案，在检测答题情况的时候遍历该List判断是部分正确还是完全正确。多个同学多张试卷的情况可以通过对学号大小排序以及试卷编号大小排序进行，先进行学生的多张试卷排序，小的在前，大的在后，在进行学生学号排序，依旧是小的在前大的在后，最后输出时先进行学生输出，输出后输出学生的多张试卷，然后再进行下一个学生的试卷输出。 - 题目设计：
接着答题判断程序3，依旧是问题类，试卷类，答卷类；填空题类和多选题类继承问题类，其中增加了ArrayList存储其问题的多个答案以便于检测答题情况时判断是部分正确还是完全正确或者错误。把主函数的单个学生student改成ArrayList存储多个学生的信息，然后依次读入每个学生的信息并添加到ArrayList中，试卷类添加识别到的每一张试卷，遍历试卷List找到对应学号的学生，创建ArrayList存储，在ArrayList中对试卷编号排序，最后对学生ArrayList的学号由小到大排序，最后遍历输出学生信息及其试卷信息即可完成排序。 - 类说明：
新增加的多选题类和填空题类：
点击查看代码
class ZQuestion extends Question
{
ZQuestion(String content, String answer) {
super(content, answer);
}
ArrayList<String> z_answersArray = new ArrayList<>();
void add_zAnswersArray(String answer)
{
z_answersArray.add(answer);
}
public ArrayList<String> getAnswersArray() {
return z_answersArray;
}
public void setAnswersArray(ArrayList<String> answersArray) {
this.z_answersArray = answersArray;
}
}
class KQuestion extends Question
{
KQuestion(String content, String answer) {
super(content, answer);
}
ArrayList<String> k_answersArray = new ArrayList<>();
void add_kAnswersArray(String answer)
{
k_answersArray.add(answer);
}
public ArrayList<String> getK_answersArray() {
return k_answersArray;
}
public void setK_answersArray(ArrayList<String> k_answersArray) {
this.k_answersArray = k_answersArray;
}
}
- 家居强电电路模拟程序1
- 题目分析：
家居强电电路模拟程序1是读入一段串联电路和其中控制设备的状态，输出控制设备和被控制设备的状态；由于题目一开始是先给一串串联电路，[]内存储电路的引脚1和引脚2，一连串的[]内多个设备相互的引脚有连接，从而形成了一串串联电路，而后读入控制设备的名称，改变其状态。由此，既然对于[]内的内容使用正则表达式即可提取，再用split方法可以将各个设备名称存储，所以使用ArrayList对于此题来说是最好的。各个控制设备在改变状态之后使用update方法更新自己的电压即可计算每一个设备的实时电压。每个设备的规定方法按照题意写出即可。由于最后需要排序输出，在存储设备信息时会在Main函数中单独存储每个设备的ArrayList以便于排序输出。 - 题目设计：
本题设置两个大类，Control和BeControlled两个大类表示控制设备和被控制设备，这两个大类中将其相同变量表示出，如有特殊变量，在自己类中继续表示即可。控制设备（开关、分档调速器、连续调速器）分别按照题意设置，然后利用更新方法更新自己的实时状态。而被控制设备（吊扇、日光灯、白炽灯）类中就设置其相应拥有的共同变量，额外变量每个类自己单独设置，其相应的输出数值对应相应的方法写出即可。对于排序依次输出，存储每个类的单独ArrayList，写出sort函数帮助排序，随之按照顺序遍历链表依次输出。 - 类说明：
控制类（Control类以及开关、分档调速器、连续调速器类）：
点击查看代码
class Control {
String name;
double c1;
double c2;
public void show() {
}
public double getC2() {
return this.c2;
}
}
class K extends Control {
int state;
int count;
public K(String name) {
this.name = name;
}
public void upKState() {
count++;
if (count % 2 == 0)
state = 0;
else
state = 1;
}
@Override
public double getC2() {
if (this.state == 0)
this.c2 = 0;
if (this.state == 1)
this.c2 = this.c1;
return this.c2;
}
@Override
public void show() {
if (state == 0)
System.out.println("@" + this.name + ":" + "turned on");
if (state == 1)
System.out.println("@" + this.name + ":" + "closed");
}
}
class F extends Control {
int gearF = 0;
public F(String name) {
this.name = name;
}
@Override
public double getC2() {
switch (this.gearF) {
case 0:
this.c2 = 0;
break;
case 1:
this.c2 = 0.3 * this.c1;
break;
case 2:
this.c2 = 0.6 * this.c1;
break;
case 3:
this.c2 = 0.9 * this.c1;
break;
}
return this.c2;
}
public void addGearF() {
if(this.gearF<3)
this.gearF++;
}
public void delGearF() {
if(this.gearF>0)
this.gearF--;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%d\n", this.gearF);
}
}
class L extends Control {
double gearL;
public L(String name) {
this.name = name;
}
@Override
public double getC2() {
return this.c1 * gearL;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%.2f\n", gearL);
}
}
被控制类（BeControlled类以及白炽灯、日光灯、吊扇类）：
点击查看代码
class BeControlled {
String name;
double c1, c2;
double d = Math.abs(c1 - c2);
public void show() {
}
public double getC2() {
return this.c1;
}
}
class B extends BeControlled {
double lum;
public B(String name) {
this.name = name;
}
public double getC2() {
return this.c1;
}
public double getLum() {
if (d < 10)
lum = 0;
else if (d >= 10 && d <= 200)
lum = ((d - 10) / 210) * (200 - 50) + 50;
else if(d>200)
lum = 200;
return lum;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%d\n", (int)this.lum);
}
}
class R extends BeControlled {
double lum;
public R(String name) {
this.name = name;
}
public double getC2() {
return this.c1;
}
public double getLum() {
if (d == 0)
lum = 0;
else
lum = 180;
return lum;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%d\n",(int)this.lum);
}
}
class D extends BeControlled {
double r=0;
public D(String name) {
this.name = name;
}
public double getD_R() {
if (this.c1 < 80)
r = 0;
else if (this.c1 >= 80 && this.c1 <= 150)
r = ((this.c1 - 80) / (150 - 80)) * (360 - 80) + 80;
else
r = 360;
return r;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%d\n", (int)r);
}
}
- 家居强电电路模拟程序2
- 题目分析：
家居强电电路模拟程序2是接着1增加了并联电路，在串联电路中接入并联电路，添加了一个落地扇类（属于被控制设备类，记得在排序类中增加其排序方法），设置各个控制设备的状态，计算总电阻，分压、电位差以及各个控制设备和被控设备的状态。此时输入的读入也许需要有所修改，输入读入时要包括并联电路的情况，而并联电路又是由串联电路组成的，所以需要电路模拟1的Main函数修改成串联电路类，再增添一个并联电路类，读入时增加并联电路读入的部分和落地扇的存储，其中一个重要的问题就是计算电阻，并联电路的加入让电阻的计算不再是简单的加减，而是需要公式计算，最后读入更改的控制设备，更新控制设备的状态，还要进行主电路电阻的计算更新电阻，每一个设备的分压由其电阻所占总电阻比例与总电压相乘得到分压，这样就可以得到所有设备的状态，进行各个设备状态的输出。 - 题目设计：
控制设备类不变，被控制设备类增加落地扇类，增加其相应的变量成员方法以及排序方法。增加串联电路类和并联电路类；串联电路增加所有设备的ArrayList，包括串联电路，由于并联电路是由串联电路组成的，所以并联电路拥有串联电路的ArrayList即可，当然，两条电路都要加上总电阻这个成员变量，实现总电阻的计算，用相应的方法去实现。 - 类说明：
被控制设备增加的落地扇类：
点击查看代码
class A extends BeControlled {
double r = 0.0;
int R = 20;
public A(String name) {
this.name = name;
}
public double getA_R() {
if (this.c1 < 80)
r = 0.0;
else if (this.c1 <= 99)
r = 80;
else if (this.c1 <= 119)
r = 160;
else if (this.c1 <= 139)
r = 260;
else
r = 360;
return r;
}
@Override
public void show() {
System.out.printf("@" + this.name + ":" + "%d\n", (int) r);
}
}
串联电路类（T）：
点击查看代码
class T {
String name;
double T_R = 0.0;
int state = 1;
double initialVolt;
double finalVolt;
ArrayList<String> connection = new ArrayList<>();
ArrayList<K> k = new ArrayList<>();
ArrayList<F> f = new ArrayList<>();
ArrayList<L> l = new ArrayList<>();
ArrayList<B> b = new ArrayList<>();
ArrayList<R> r = new ArrayList<>();
ArrayList<D> d = new ArrayList<>();
ArrayList<A> a = new ArrayList<>();
ArrayList<T> t = new ArrayList<>();
ArrayList<M> m = new ArrayList<>();
public double getFinalVolt() {
return initialVolt;
}
public double getT_R() {
double total = 0;
for (int i = 0; i < this.b.size(); i++) {
total += this.b.get(i).R;
}
for (int i = 0; i < this.r.size(); i++) {
total += r.get(i).R;
}
for (int i = 0; i < this.d.size(); i++) {
total += this.d.get(i).R;
}
for (int i = 0; i < this.a.size(); i++) {
total += this.a.get(i).R;
}
for (int i = 0; i < this.t.size(); i++) {
total += this.t.get(i).getT_R();
}
for (int i = 0; i < this.m.size(); i++) {
total += this.m.get(i).getM_R();
}
return total;
}
public int getState() {
for (int i = 0; i < k.size(); i++) {
if (k.get(i).state == 0)
state = 0;
}
for (int i = 0; i < f.size(); i++) {
if (f.get(i).gearF == 0)
state = 0;
}
for (int i = 0; i < l.size(); i++) {
if (l.get(i).gearL == 0)
state = 0;
}
return state;
}
public void calculate() {
double volt = initialVolt;
for (int i = 1; i < connection.size() - 1; i++) {
String name = connection.get(i);
for (int j = 0; j < k.size(); j++) {
if (k.get(j).name.equals(name)) {
k.get(j).c1 = volt;
if (i == connection.size() - 2)
k.get(j).c2 = 0;
else
k.get(j).c2 = k.get(j).getC2();
volt = k.get(j).c2;
}
}
for (int j = 0; j < f.size(); j++) {
if (f.get(j).name.equals(name)) {
f.get(j).c1 = volt;
if (i == connection.size() - 1)
f.get(j).c2 = 0;
else
f.get(j).c2 = f.get(j).getC2();
volt = f.get(j).c2;
}
}
for (int j = 0; j < l.size(); j++) {
if (l.get(j).name.equals(name)) {
l.get(j).c1 = volt;
if (i == connection.size() - 2)
l.get(j).c2 = 0;
else
l.get(j).c2 = l.get(j).getC2();
volt = l.get(j).c2;
}
}
for (int j = 0; j < b.size(); j++) {
if (b.get(j).name.equals(name)) {
double per = (double) b.get(j).R / this.T_R;
b.get(j).c1 = volt * per;
b.get(j).c2 = 0;
b.get(j).d = b.get(j).c1 - b.get(j).c2;
b.get(j).lum = b.get(j).getLum();
}
}
for (int j = 0; j < r.size(); j++) {
if (r.get(j).name.equals(name)) {
double per = (double) r.get(j).R / this.T_R;
r.get(j).c1 = volt * per;
r.get(j).c2 = 0;
r.get(j).d = r.get(j).c1 - r.get(j).c2;
r.get(j).lum = r.get(j).getLum();
}
}
for (int j = 0; j < d.size(); j++) {
if (d.get(j).name.equals(name)) {
double per = (double) d.get(j).R / this.T_R;
d.get(j).c1 = volt * per;
d.get(j).c2 = 0;
d.get(j).r = d.get(j).getD_R();
}
}
for (int j = 0; j < a.size(); j++) {
if (a.get(j).name.equals(name)) {
double per = (double) a.get(j).R / this.T_R;
a.get(j).c1 = volt * per;
a.get(j).c2 = 0;
a.get(j).r = a.get(j).getA_R();
}
}
for (int j = 0; j < t.size(); j++) {
if (t.get(j).name.equals(name)) {
double per = (double) t.get(j).T_R / this.T_R;
t.get(j).initialVolt = volt * per;
t.get(j).calculate();
}
}
for (int j = 0; j < m.size(); j++) {
if (m.get(j).name.equals(name)) {
for (int k = 0; k < m.get(j).finalT.size(); k++) {
double per = (double) m.get(j).M_R / this.T_R;
m.get(j).finalT.get(k).initialVolt = volt * per;
m.get(j).finalT.get(k).calculate();
}
}
}
}
}
}
并联电路类（M）：
点击查看代码
class M {
double M_R;
int state;
String name;
ArrayList<T> initialT = new ArrayList<>();
ArrayList<T> finalT = new ArrayList<>();
public double getM_R() {
double total = 0;
for (int i = 0; i < finalT.size(); i++) {
total += (1.0 / (finalT.get(i).T_R));
}
double R = 1.0 / total;
return R;
}
public ArrayList<T> getFinalT() {
ArrayList<T> Final = new ArrayList<>();
for (int i = 0; i < initialT.size(); i++) {
if (initialT.get(i).state == 1) {
Final.add(this.initialT.get(i));
} else if (initialT.get(i).state == 0) {
initialT.get(i).initialVolt = 0.0;
initialT.get(i).calculate();
}
}
return Final;
}
public int getState() {
for (int i = 0; i < initialT.size(); i++) {
if (initialT.get(i).state == 1)
this.state = 1;
}
return this.state;
}
}
- 答题判断程序4
答题判断程序因为一开始写的时候只注意到了名字的存储，从而忽略了排序的问题，因为我使用了HashMap，排序肯定是没有ArrayList方便的，所以一开始对于存储对象的选择是要慎重的。然后是多选题和填空题正确情况的判断，我想到是遍历答案ArrayList从而判断结果，但其实使用字符串的equals函数和contains函数会更加便捷，不仅如此，这样还能够减少代码冗余。 - 家居强电电路模拟程序1
这部分的踩坑点就是更新控制设备的状态以及。最开始所有设备的输出全部都是0.0。在eclipseDebug后才发现是存储控制设备的状态后并未保存状态，导致电路不通。 - 家居强电电路模拟程序2
模拟程序2因为需要计算总电阻，但是电路既有串联的又有并联的，导致总电阻不好算，电阻又是由串联和并联的相加，就得设置一个getR方法计算一条并联的总电阻或一条串联的总电阻，继而相加得到主电路的总电阻，依旧要记得实时更新控制设备状态，分压时是根据该电阻占据该条电路的百分比计算的，而该电压也就是引脚之间的电位差，这样一切就可以衔接起来了。但容易踩坑的是要及时更新该条路的电阻，主电路的电阻要在其中报狂的所有电路的总电阻更新之后再更新，这样才能保证正确性。
- 答题判断程序4
答题判断程序4的改进建议就是可以将HashMap转化成ArrayList，在相应的类中存储String name即可，这样可以大大提高代码效率，不需要再在判断答题情况时不断遍历答案的ArrayList表了。 - 家居强电电路模拟程序1
家具强电电路模拟程序1所写的大多是题目要求的，所以需要改进的可能就只有排序输出那一段，我自作主张写了各个设备相应的函数，而且是函数内容相同，只是形参的类型不同，这样导致了代码的大量冗余，完全可以用ArrayList中的sort方法排序。 - 家居强电电路模拟程序2
家居强电电路模拟程序2是接着1写的，为了方便，我就将排序方法单独写了个类Sort，现在看来完全没有必要，只要利用ArrayList的sort方法即可。但是拎一个值得改进的地方就是对于一条电路是否通路的判断，我一开始在每条电路上都设置了state，导致判断的时候依旧需要循环遍历，这个非常多与，其实只要再串联电路类和并联电路类中增加state状态即可，这样只要判断那一段电路的state就行，而不用每个控制设备都判断，太麻烦了。