OO第二次博客作业
OO第二次博客作业
目录
1.前言
2.设计与分析
3.采坑心得
4.改进建议
5.总结
1.前言
面向对象设计（Object-Oriented Design，简称OOD）是一种软件设计方法，它基于面向对象编程（Object-Oriented Programming，简称OOP）的原则，将软件系统的设计表示为一组对象及其相互作用。面向对象设计的核心思想是将现实世界中的问题抽象成对象，每个对象都有其属性和方法，对象之间通过消息传递进行交互。
面向对象设计的关键概念包括：
1.类（Class）：类是创建对象的模板或蓝图，它定义了对象的结构和行为。类包含属性和方法，属性用于描述对象的状态，方法用于定义对象的操作。
2.对象（Object）：对象是类的实例，它是根据类定义创建的具体实体。每个对象都有其独特的属性值和方法执行。
3.封装（Encapsulation）：封装是面向对象设计的基本原则之一，它意味着将对象的内部状态（属性）和对外提供的服务（方法）封装在一起，隐藏对象的内部细节，仅通过接口与外界交互。
4.继承（Inheritance）：继承允许新的类（子类）继承一个已存在类（父类）的属性和方法。子类可以扩展父类的行为，也可以添加新的属性和方法。
5.多态（Polymorphism）：多态性允许不同类的对象对同一消息做出响应，并以不同的方式执行相应的操作。这使得同一个接口可以有多种不同的实现。
面向对象设计的过程通常包括以下步骤：
1.需求分析：理解并分析用户需求，确定系统必须完成哪些任务。
2.抽象：将现实世界的实体抽象成类，确定类的属性和方法。
3.设计类：定义类及其属性和方法，确定类之间的继承和关联关系。
4.创建对象：根据类的设计创建对象，并实现对象之间的交互。
5.测试和验证：通过编写测试用例来验证设计是否满足需求，确保系统的正确性和健壮性。
面向对象设计的好处包括提高软件的可重用性、可维护性和可扩展性，同时也使得软件系统更加模块化和易于理解。通过使用面向对象设计，开发者可以构建出更加灵活、易于管理和更新的软件系统。
2.设计与分析
1.第四次pta作业：
设计思路：设计试卷，学生，删除的题目，答卷和题目五个类，再设计选择题，填空题，计算题三个题型继承题目类。
代码：
class Question{
private int numbering;
private String question;
private String standard;
}
class Compute extends Question{
public Compute(){
super();
}
public Compute(int numbering,String question,String standard){
super(numbering,question,standard);
}
}
class Choose extends Question{
public Choose(){
}
public Choose(int numbering,String question,String standard){
super(numbering,question,standard);
}
}
class Vacancy extends Question{
public Vacancy(){
}
public Vacancy(int numbering,String question,String standard){
super(numbering,question,standard);
}
}
class TestPaper{
private int papernum;
private int[] numberings;
private int[] grade;
private int T;
}
class Student{
private String[] studentnum;
private String[] name;
}
class AnswerPaper{
private int answernum;
private String studentnum;
private int[] numbering;
private String[] answer;
private int A;
}
class Delete{
private int numbering;
}
设计思路：用正则表达式实现接收输入，用作后续的处理。
代码：
String line = scan.nextLine();
Pattern pattern1 = Pattern.compile("#N:(\\s+)?(\\d+)(\\s+)?#Q:(\\s+)?(.+)(\\s+)?#A:(\\s+)?(\\S+)(\\s+)?");
Matcher matcher1 = pattern1.matcher(line);
Pattern pattern2 = Pattern.compile("#S:(\\d+)((\\s+)#A:(\\S+))*");
Matcher matcher2 = pattern2.matcher(line);
Pattern pattern3 = Pattern.compile("#T: *(\\d+)((\\s+)(\\d+)-(\\d+))*");
Matcher matcher3 = pattern3.matcher(line);
Pattern pattern4 = Pattern.compile("#X:((\\s+)?(\\S+)(\\s+)(\\S+))+");
Matcher matcher4 = pattern4.matcher(line);
Pattern pattern5 = Pattern.compile("#D:N-(\\d+)");
Matcher matcher5 = pattern5.matcher(line);
Pattern pattern6 = Pattern.compile("#Z:(\\d+)\\s+#Q:(.+)#A:(.+)");
Matcher matcher6 = pattern6.matcher(line);
Pattern pattern7 = Pattern.compile("#K:(\\d+)\\s+#Q:(.+)#A:(.+)");
Matcher matcher7 = pattern7.matcher(line);
Pattern pattern8 = Pattern.compile("#A:(.+)(\\s+)?");
Matcher matcher8 = pattern8.matcher(line);
Pattern pattern9 = Pattern.compile("#S:(\\d+)(\\s+)(\\S+)(\\s+)");
Matcher matcher9 = pattern9.matcher(line);
设计思路：最后循环输出。
代码：
if(num4 > 0){
for(int i = 0; i < num2;i++){
for (int j = 0;j < num4;j++){
testPapers[i].setGrade1(deletes[j].getNumbering()-1,0);//将删除的题目的分数设置为0
}
}
}
for(int i = 0; i < num2;i++){
for(int j = 0; j < z;j++){
total += testPapers[i].getGrade1(j);
}
if(total != 100){
System.out.println("alert: full score of test paper"+testPapers[i].getPapernum()+" is not 100 points");
}
}
int p = 0;
for(int i = 0; i < num5;i++) {
for (int j = 0; j < num2; j++) {
if (answerPapers[i].getAnswernum() == testPapers[j].getPapernum()){
p = 1;
}
}
}
for(int i = 0; i < num5;i++){
for (int j = 0; j < num2;j++){
if(p == 0){
System.out.println("The test paper number does not exist");
}
else {//答卷对应试卷
for (int k = 0; k < testPapers[i].getT(); k++) {
int q = 0;
for (int k2 = 0; k2 < num1; k2++) {
if (questions[k2].getNumbering() == testPapers[j].getNumbering1(k)) {
q = 1;
}
if(q == 1){
break;
}
}
if (q == 0) {
System.out.println("non-existent question~0");
gets[k] = 0;
}
if (q == 1) {
if(num4 > 0){
for (int j1 = 0; j1 < num4; j1++) {
if (testPapers[j].getNumbering1(k) == deletes[j1].getNumbering()) {
System.out.println("the question " + testPapers[i].getNumbering1(k) + " invalid~0");
gets[k] = 0;
} else {
if (answerPapers[i].getA() >= testPapers[j].getT()) {
if (test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 1) {//standard按照answer的编号输
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~true");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1);
}
else if(test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 0){
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~partially correct");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1) / 2;
}
else {
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~false");
gets[k] = 0;
}
} else {
for (int n = 0; n < answerPapers[i].getA(); n++) {
if (test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 1) {//standard按照answer的编号输
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~true");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1);
}
else if(test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 0){
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~partially correct");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1) / 2;
}
else {
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~false");
gets[k] = 0;
}
}
for (int m = answerPapers[i].getA(); m < testPapers[j].getT(); m++) {
System.out.println("answer is null");
gets[m] = 0;
}
}
}
get += gets[k];
}
}
else {
if (answerPapers[i].getA() >= testPapers[j].getT()) {
if (test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 1) {//standard按照answer的编号输
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~true");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1);
}
else if(test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 0){
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~partially correct");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1) / 2;
}
else {
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~false");
gets[k] = 0;
}
} else {
for (int n = 0; n < answerPapers[i].getA(); n++) {
if (test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 1) {//standard按照answer的编号输
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~true");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1);
}
else if(test(questions[testPapers[j].getNumbering1(k) - 1].getStandard(), answerPapers[i].getAnswer1(answerPapers[i].getNumbering1(k) - 1)) == 0){
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~partially correct");
gets[k] = testPapers[j].getGrade1(testPapers[j].getNumbering1(k) - 1) / 2;
}
else {
System.out.println(questions[testPapers[j].getNumbering1(k) - 1].getQuestion() + "~" + answerPapers[i].getAnswer1(k) + "~false");
gets[k] = 0;
}
}
for (int m = answerPapers[i].getA(); m < testPapers[j].getT(); m++) {
System.out.println("answer is null");
gets[m] = 0;
}
}
}
get += gets[k];
}
}
int st = 1;
for(int l1 = 0; l1 < num3; l1++){
for (int l2 = 0;l2 < o;l2++) {
if (answerPapers[i].getStudentnum().equals(students[l1].getStudentnum1(l2))){
st = 0;
System.out.print(students[l1].getStudentnum1(l2)+" "+students[l1].getName1(l2)+": ");
for (int l3 = 0; l3 < z; l3++) {
if (l3 < z - 1) {
System.out.print(gets[l3] + " ");
}
if (l3 == z - 1) {
System.out.print(gets[l3]);
}
}
System.out.println("~" + get);
get = 0;
}
}
}
if(st == 1){
System.out.println(answerPapers[i].getStudentnum()+" not found");
}
}
分析：第四次作业中，我有以下几个缺点：
1.不了解基本概念：Java是一门面向对象编程语言，因此了解基本概念，如类、对象、继承、封装、多态等，是必要的。如果您不了解这些基本概念，可以尝试阅读Java的入门书籍或在线资源，并多练习相关的实例代码。
2.代码不够可读：可读性是编写高质量代码的重要特征。可以通过使用有意义的变量名和函数名、添加注释和文档、遵循代码风格指南等方式来提高代码的可读性。
3.缺乏编程习惯：编程习惯可以帮助您编写更加可靠和可维护的代码。例如，可以尝试使用try-catch语句来处理异常，使用循环和条件语句来控制程序流程，使用集合和数组来存储数据等。
4.不了解设计模式：设计模式是一种解决常见问题的解决方案，可以帮助您编写更加可扩展和可维护的代码。如果您不熟悉设计模式，可以尝试阅读相关书籍或在线资源，并多练习相关的实例代码。
5.缺乏测试：测试是确保代码正确性和可靠性的重要手段。可以尝试编写单元测试和集成测试，以帮助您发现并修复代码中的错误。
总之，要想提高自己的Java编程能力，需要多练习，多学习，并多思考。不断地总结自己的不足和优点，并从中学习和提高自己。同时，也可以寻找志同道合的伙伴，一起交流和学习，共同进步。
2.第五次pta作业：
设计思路：设计开关，控制器，受控设备，连接线四个类，其中控制器包括了分档控制器和连续控制器两个子类，受控设备包括了白炽灯，日光灯和吊扇三个子类。
代码：
abstract class Control{
protected double pressure;
}
class K{
private String name;
private int k;
}
class F extends Control{
private String name;
private int f=0;
}
class L extends Control{
private String name;
private double l;
}
abstract class By{
protected int lux;
}
class B extends By{
private String name;
}
class R extends By{
private String name;
}
class D extends By{
private String name;
}
class Link{
private String foot1;
private String foot2;
}
class Links{
private ArrayList<F> fs;
private ArrayList<L> ls;
private ArrayList<B> bs;
private ArrayList<R> rs;
private ArrayList<D> ds;
private ArrayList<K> ks;
}
设计思路：用正则表达式实现接收输入，用作后续的处理
代码：
Pattern pattern1 = Pattern.compile("\\[(\\S+)(\\s+)(\\S+)\\]");
Matcher matcher1 = pattern1.matcher(line);
Pattern pattern2 = Pattern.compile("#L(\\d+):[0-9]+.[0-9]{2}$");
Matcher matcher2 = pattern2.matcher(line);
Pattern pattern3 = Pattern.compile("#K(\\d+)");
Matcher matcher3 = pattern3.matcher(line);
Pattern pattern4 = Pattern.compile("#F(\\d+)(\\+|\\-)");
Matcher matcher4 = pattern4.matcher(line);
设计思路：最后调用方法，循环输出。
代码：
if (ks.size() > 0){
for (K k : ks){
System.out.println(k.toString());
}
for (K k : ks){
if (k.getK() == 0){
pressure = 0;
break;
}
else {
pressure = pressure;
}
}
}
if (controls.size() > 0){
for (Control control : controls){
System.out.println(control.toString());
for (By by : bies){
by.Lux(control.get(pressure));
}
}
}
else {
for (By by : bies){
by.Lux(pressure);
}
}
分析：在第五次作业中，有了前面的经验，我从一开始就非常关注作业的要求和要求的实现方法。我会认真阅读作业说明，并确保我完全理解了作业的要求和要求的实现方法。如果有任何疑问，我会及时咨询那些优秀学生，认真听他们的解析，并确保我得到了满意的解答。
在规划任务时，我会根据作业要求，规划任务的步骤和时间表。我会确保我有足够的时间来完成每个步骤，并且我会尽力地利用我的时间来完成作业。
在设计解决方案时，我会根据作业要求，设计一个解决方案。我会在纸上或在电子设备上进行草图和设计，并确保我的解决方案符合作业要求。
在编写代码时，我会遵循良好的编程习惯，例如使用有意义的变量名、注释和格式化代码。我会一步一步地编写代码，并确保每一步都符合我的设计。
在测试和调试时，我会编写测试用例来测试我的代码，并确保我的代码符合作业要求。如果我的代码出现问题，我会耐心地调试我的代码，直到我的代码符合作业要求。
在提交作业时，我会确保我已经按照作业要求完成了所有步骤，并且已经测试和调试过代码。我会仔细地检查我的代码，并确保我的代码符合作业要求。
总的来说，我在做Java作业时，我会尽力地完成任务，并确保我的代码符合作业要求。我会保持积极态度和好奇心，不断地学习和探索。即使遇到困难，我也会保持耐心和毅力，继续努力地学习和解决问题。
3.第六次pta作业：
设计思路：在第五次作业的基础上，增加落地扇、串联电路和并联电路三个类，并且给各个电器都设置电阻以便求他们各自的分压
代码：
abstract class By implements Comparable{
protected double pressure;
protected int lux;
protected String name;
protected int r;
}
class B extends By{
private int r = 10;
}
class R extends By{
private int r = 5;
}
class D extends By{
private int r = 20;
}
class A extends By{
private int r = 20;
}
class T {
private String name;
private ArrayList<K> ks;
private ArrayList<By> bies;
private ArrayList<Control> controls;
private ArrayList<String> namem;
private int state;
private int r;
}
class M{
private String name;
private ArrayList<T> ts;
}
设计思路：用正则表达式来获取每一行的输入，再存进数组里
代码：
Pattern pattern1 = Pattern.compile("\\[(\\S+)(\\s+)(\\S+)\\]");
Matcher matcher1 = pattern1.matcher(line);
Pattern pattern = Pattern.compile("#T(\\d+):(\\[(\\S+)(\\s+)(\\S+)\\](\\s+)?)*");
Matcher matcher = pattern.matcher(line);
Pattern patternm = Pattern.compile("#M(\\d+):\\[((\\S+)(\\s+)?)*\\]");
Matcher matcherm = patternm.matcher(line);
Pattern pattern2 = Pattern.compile("#L(\\d+):(\\S+)");
Matcher matcher2 = pattern2.matcher(line);
Pattern pattern3 = Pattern.compile("#K(\\d+)");
Matcher matcher3 = pattern3.matcher(line);
Pattern pattern4 = Pattern.compile("#F(\\d+)(\\+|\\-)");
Matcher matcher4 = pattern4.matcher(line);
设计思路：分情况对所得数据运用算法
代码：
if (ks.size() > 0){
Collections.sort(ks);
for (K k : ks){
System.out.println(k.toString());
}
}
if (controls.size() > 0){
Collections.sort(controls);
for (Control control : controls){
if(control.name.contains("F")) {
System.out.println(control.toString());
}
if(control.name.contains("L")) {
System.out.println(control.toString());
}
}
}
（部分）
设计思路：排序并按题目所给顺序输出
代码：
Collections.sort(bies);
for (By by : bies){
if(by.name.contains("B")) {
by.Lux(by.getPressure());
}
}
for (By by : bies){
if(by.name.contains("R")) {
by.Lux(by.getPressure());
}
}
for (By by : bies){
if(by.name.contains("D")) {
by.Lux(by.getPressure());
}
}
for (By by : bies){
if(by.name.contains("A")) {
by.Lux(by.getPressure());
}
}
分析：对于这次的作业，虽然中间磕磕碰碰，但是由于有一定的经验，经历重重困难，最后得以解决，并总结出以下一些思路：
1.不轻言放弃：每次作业都是一次挑战，放弃就等于失败。
2.勤能补拙：也许在编程方面天资不行，靠时间去堆也能取得不错的成绩。
3.查漏补缺：每次作业都是对前面的补充，只有搞懂了前面的作业，后面才能更好地解决问题。
4.保持自信：如果开始就认为自己不行，那肯定写不出，只有保持自信，才有做下去的动力。
3.采坑心得
1.第四次pta作业：前面的失利，让我的自信心有点受挫，同时题目也不简单，设计的类也不完善，导致没有拿到满意的分数
后续修修改改，但时间问题，不得已借用前面不完整的类结构，最后得分不佳。
2.第五次pta作业：经过老师的一段鸡汤，加上期中考试的得意，再加上题目重置，难度降低，在种种buff的叠加下拿到了满分
后续由于老师透露了之后的题型，我对此下功夫，为后续打基础
3.第六次pta作业：虽然第五次作业中，我对这次作业进行了粗略的思考，但是起初并没有太大的成效
在一遍遍尝试后，我开始重新审题，才发现了诸多问题
再在此基础上修修改改后完成作业
4.改进建议
1.审题！审题！审题！题目审不好，不仅会让信心递减，更会消磨做下去的斗志。
2.记住单一职责，合理运用封装、继承、多态。
3.动手前，设计好所需的类，做好设计，是好的程序员的第一步，也是根基。
5.总结
在这三次作业中，最主要的问题还是设计问题，其次就是审题，再者就是能力问题，为此，我要做出如下的策略：
1.花更多的时间去设计，而不是提笔就写。
2.一定要先审题，不然后续的编写会在你不知情的情况下出现很多错误。
3.认真对待每次作业，并为下一次做准备，争取把自己的编程能力培养上来。
浙公网安备 33010602011771号