BLOG-3

通过对最后三次大作业中的题目集的学习，我有以下心得：

1.三次题目集的知识点我觉得有这些（1）：输入语句的使用。

　　　　　　　　　　　　　　　   （2）：java中多个if（）判断语句的使用。

　　　　　　　　　　　　　　　　（3）：java中的if（）和else语句的嵌套使用。

　　　　　　　　　　　　　　　   （3）：java中的四则运算。

　　　　　　　　　　　　　　　   （4）：java中的for()循环语句的使用。

　　　　　　　　　　　　　　　　（5）：java中的switch()语句的使用。

　　　　　　　　　　　　　　　　（6）：java中的一些对字符串处理的方法，例如：a.substring(0,2)，该方法的作用是将字符串a中的第一二位的字符提取出来。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 c.equals(s)，该方法是对字符串进行比对的方法，如果字符串c与字符串s相等，则返回true，否则返回false。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　a.charAt(i)，该方法是对字符串提取的作用，它可以将字符串a中的第i为提取出来。

　　　　　　　　　　　　　　　　 （7）：在第一次作业的7-8中，我发现原来java中的浮点数据会有误差，在完成作业的时候应该考虑到精度问题。并且还学会了java中的一中数学处理方法，Math.abs(),该　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　   　　　　　　　　　　　　　　　　　　　方法是对括号内的数进行取绝对值的处理。

　　　　　　　　　　　　　　　　（8）：我学会了对一道很复杂的题目进行面对对象的程序设计，并且明白面对对象的程序设计与面对过程的程序设计直接的差别。

　　　　　　　　　　　　　　　　（9）：我学会了如何通过基年法来判断该天是周几和通过基年法计算两个日期之间相差的天数。

　　　　　　　　　　　　　　　　（10）：java中的分割字符串的方法a.split(" ")，该方法的作用是将字符串a按空格进行分割。

　　　　　　　　　　　　　　　　（11）：java中的Arrays.sort（），该方法是将括号内的数进行排序处理。

　　　　　　　　　　　　　　　　（12）：java中对数据进行封装（private）

　　　　　　　　　　　　　　　　（13）含参构造和无参构造。

　　　　　　　　　　　　　　　　  （14）正则表达式的使用。在一些需要对输入进行判断时我们就可以用到正则表达式。

　　　　　　　　　　　　　　　　（15）继承的使用（父类与子类）继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

　　　　　　　　　　　　　　　　　　继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

　　　　　　　　　　　　　　　　　（16）在这几次的大作业学习和期中考试当中，我也充分的理解了类与类之间的关系：

　　　　　　　　　　　　　　　　　　　　　　继承关系：继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。

　　　　　　　　　　　　　　　　　　　　　　实现关系：实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。

　　　　　　　　　　　　　　　　　　　　　　依赖关系：依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

　　　　　　　　　　　　　　　　　　　　　　关联关系：关联体现的是两个类之间语义级别的一种 强依赖关系，关联可以是单向、双向的。

　　　　　　　　　　　　　　　　　　　　　　聚合关系：聚合是关联关系的一种特例，它体现的是整体与部分的关系，即 has-a 的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于　　　　　　　　　　　　　　　　　　  　　　　　　　　　　　　　　　　　　　　　　　　　　  多个整体对象，也可以为多个整体对象共享。

　　　　　　　　　　　　　　　　　　　　　　组合关系：组合也是关联关系的一种特例，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也 　　 　　  　　　　　　　　　　　　　　　　　　　　　　　　　　 就意味着部分的生命周期结束。

　　　　　　　　　　　　　　　　（17）再这几次大作业当中，我还学会了如何使用重构排序，因为每次作业当中都要对学号进行排序，对课程名称进行排序，还要对班级号进行排序。

　　　　这三次大次作业的题量还好，难度也不高，难的可能就是最后一次。最简单的是倒数第二次，这次作业是我花时间最短，得分最高得一次。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　设计与分析

 

第四次大作业：我设计了7个类，类图如下：

 

此外，我还加入了一些我觉得需要的类：

1.

class Compaerstudent implements Comparator<XueSheng>

{

@Override

public int compare(XueSheng a,XueSheng b)

{

return a.xuehao-b.xuehao;

}

}

这个类的作用是对学生的学号进行排序，按学号从小到大进行排序

class Compaerclass implements Comparator<BanJi>

{

@Override

public int compare(BanJi a,BanJi b)

{

return a.banhao-b.banhao;

}

}

这个类的作用是对班级号进行排序，班级由低到高排序输出

class Compaerkebiao implements Comparator<KeBiao>

{

@Override

public int compare(KeBiao o1, KeBiao o2) {

 

try {

Comparator compator = Collator.getInstance(Locale.CHINA);

if (compator.compare(o1.kecheng.name, o2.kecheng.name) < 0) {

return -1;

} else if (compator.compare(o1.kecheng.name, o2.kecheng.name) > 0) {

return 1;

}

} catch (Exception e) {

}

return 0;

}

 

}

 这个类的作用是对课程信息进行排序，单门课程成绩按课程名称的字符顺序输出

代码如下：

 

import java.util.Comparator;
import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
KeBiao[] a=new KeBiao[20];//课表数组
XuanKe[] b=new XuanKe[20];//选课数组
BanJi []d=new BanJi[20];//班级数组
Scanner input=new Scanner(System.in);
String c=input.nextLine();
int i=0;//课表数量
int j=1;//选课数量
int k=0;//班级数量
int m=0;
int n=0;
int l=0;
int t=0;//学生数量
int y=0;
boolean newbanji=true;
boolean newxuesheng=true;
while(!c.equals("end"))
{
String arr[]=c.split(" ");
if(!arr[0].matches("[0-9]{8}"))//添加课表
{
a[i]=new KeBiao();
a[i].kecheng.name=arr[0];
a[i].kecheng.xingzhi=arr[1];
a[i].kecheng.kaohefashi=arr[2];
for(y=0;y<i;y++)
{
if(a[i].kecheng.name.equals(a[y].kecheng.name)&&a[y].flag==0)//课程名重复按第一条
{
//System.out.println(11);
a[i].flag=1;
}
}
if(arr[2].equals("考试"))
{
a[i].kecheng.psqz=Float.parseFloat(arr[3]);//float化平时权重
a[i].kecheng.qmqz=Float.parseFloat(arr[4]);//float化期末权重
}
if(arr[2].equals("实验"))
{

int g=4;
a[i].kecheng.f=Integer.parseInt(arr[3]);//实验课次数
if(a[i].kecheng.f<4||a[i].kecheng.f>9)
{
a[i].flag=1;
System.out.println("wrong format");
}
if(arr.length<4+a[i].kecheng.f&&a[i].flag==0)
{
System.out.println(arr[0]+" : "+"number of scores does not match");//输入的分项成绩数量值和分项成绩权重的个数不匹配
a[i].flag=1;//这个课表无效
}
if(arr.length==4+a[i].kecheng.f&&a[i].flag==0)
{
for(int h=0;h<Integer.parseInt(arr[3]);h++)
{
a[i].kecheng.sy[h]=Float.parseFloat(arr[g]);//float化实验成绩权重
a[i].sum+=Float.parseFloat(arr[g]);
g++;
}
// System.out.println(i);
// System.out.println(a[i].sum);
if(a[i].sum<0.999||a[i].sum>1.001)
{
System.out.println(arr[0]+" : "+"weight value error");
}
}
}
if(arr[i].equals("必修")&&!arr[2].equals("考试"))//必修课考核方式必须为考试
{
System.out.println(arr[0]+" : "+"course type & access mode mismatch");
a[i].flag=1;//这个课表无效
}
if(arr[i].equals("实验")&&!arr[2].equals("实验"))//实验课考核方式必须为实验
{
System.out.println(arr[0]+" : "+"course type & access mode mismatch");
a[i].flag=1;//这个课表无效
}
i++;
//System.out.println(i);
}

else //选课
{
//System.out.println(111);
int flag4=1;
int flag=1;//开班级flag
b[j]=new XuanKe();//选课数组
b[j].student.xuehao=Integer.parseInt(arr[0]);//学生学号
b[j].student.name=arr[1];//学生姓名
b[j].kecheng.name=arr[2];//课程名字

int flag1=1;//查找课表flag

//System.out.println(arr[3]);
for(l=0;l<i;l++)
{
if(b[j].kecheng.name.equals(a[l].kecheng.name))
{
//System.out.println(11122);
b[j].kecheng.kaohefashi=a[l].kecheng.kaohefashi;//考察方式赋值
if(a[l].flag==0)//这门课存在
{
flag1=0;//找到了赋值为0
}
if(b[j].kecheng.kaohefashi.equals("实验")&&arr.length>13)//实验次数大于9
{
newbanji=false;
newxuesheng=false;
System.out.println("wrong format");
break;
}
if(b[j].kecheng.kaohefashi.equals("实验")&&arr.length<7)//实验次数小于4
{
if(Integer.parseInt(arr[3])<4)
{
newbanji=false;
newxuesheng=false;
System.out.println("wrong format");
break;
}

}

}

}
//flag1=1;//查找课表flag
if(!arr[0].matches("[0-9]{8}")||arr[1].length()>10||arr[2].length()>10)//前三位有错
{
newbanji=false;
newxuesheng=false;
System.out.println("wrong format");
}
if(arr[0].matches("[0-9]{8}")&&arr[1].length()<=10&&arr[2].length()<=10)//前三位没错
{
if(arr.length==4&&!arr[3].matches("[0-9]{1}|[0-9]{2}|100"))//考察课成绩越界
{
b[j].flag1=1;//成绩无效
newbanji=false;//不开班级
newxuesheng=false;//不开学生
System.out.println("wrong format");
}
if(arr.length==5)
{
if(!arr[3].matches("[0-9]{1}|[0-9]{2}|100")||!arr[4].matches("[0-9]{1}|[0-9]{2}|100"))//考试课成绩越界
{
b[j].flag1=1;//成绩无效
newbanji=false;//不开班级
newxuesheng=false;//不开学生
System.out.println("wrong format");
}
}
if(arr.length>5)//实验课成绩越界
{
for(y=4;y<arr.length;y++)
{
if(!arr[y].matches("[0-9]{1}|[0-9]{2}|100"))
{
b[j].flag1=1;//成绩无效
newbanji=false;//不开班级
newxuesheng=false;//不开学生
System.out.println("wrong format");
break;
}
}
}
}
if(arr[0].matches("[0-9]{8}")&&arr[1].length()<=10&&arr[2].length()<=10)//前三位没错
{
for(l=0;l<i;l++)//在课表中查找选课信息
{
if(b[j].kecheng.name.equals(a[l].kecheng.name))//如果课程名字等于课表名字(找到了)
{
b[j].kecheng.kaohefashi=a[l].kecheng.kaohefashi;//考察方式赋值
//System.out.println(a[l].kecheng.f);
if(a[l].flag==0)//这门课存在
{
//System.out.println(1233333);
flag1=0;//找到了赋值为0
}
if(b[j].kecheng.kaohefashi.equals("考察")&&arr.length!=4&&a[l].flag==0&&newbanji==true&&newxuesheng==true)//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配
{
//b[j].flag1=0;//该条成绩记录的成绩无效
System.out.println(b[j].student.xuehao+" "+b[j].student.name+" : "+"access mode mismatch");
}
if(b[j].kecheng.kaohefashi.equals("考察")&&arr.length==4&&a[l].flag==1&&newbanji==true&&newxuesheng==true)//课表无效
{
b[j].flag1=0;//该条成绩记录的成绩无效
}
if(b[j].kecheng.kaohefashi.equals("考试")&&arr.length!=5&&a[l].flag==0&&newbanji==true&&newxuesheng==true)//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配
{
//b[j].flag1=0;//该条成绩记录的成绩无效
System.out.println(b[j].student.xuehao+" "+b[j].student.name+" : "+"access mode mismatch");
}
if(b[j].kecheng.kaohefashi.equals("考试")&&arr.length!=5&&a[l].flag==1&&newbanji==true&&newxuesheng==true)//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配
{
b[j].flag1=0;//该条成绩记录的成绩无效
//System.out.println(1);
//System.out.println(b[j].student.xuehao+" "+b[j].student.name+" : "+"access mode mismatch");
}
if(b[j].kecheng.kaohefashi.equals("实验")&&arr.length!=a[l].kecheng.f+3&&a[l].flag==0&&newbanji==true&&newxuesheng==true )//如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配
{
System.out.println(b[j].student.xuehao+" "+b[j].student.name+" : "+"access mode mismatch");
b[j].flag1=0;//该条成绩记录的成绩无效
}

}

}
if(flag==1&&b[j].flag==0&&newbanji==true&&newxuesheng==true)//既没有找到，成绩数量也对不上，按第一天输出
{
System.out.println(b[j].kecheng.name+" "+"does not exist");
flag4=0;
}
if(flag4==1&&flag1!=0&&b[j].flag==1&&newbanji==true&&newxuesheng==true)//单纯没有找到且这条成绩记录有效
{
System.out.println(b[j].kecheng.name+" "+"does not exist");
}

if(j==1&&b[j].flag1!=0)//第一条选课记录
{
b[j].flag=1;//这个同学有多少条重复数据
}
// System.out.println(b[j].flag1);
// System.out.println(b[j].student.xuehao);
for(m=1;m<=j;m++)//成绩重复
if(b[j].student.xuehao==b[m].student.xuehao&&b[j].kecheng.name.equals(b[m].kecheng.name))//这条成绩有效才查重复
{
// System.out.println(123);
// System.out.println(b[j].flag);
b[j].flag++;//这个同学有多少条重复数据
// System.out.println(b[j].flag);
// System.out.println("/n");
break;
}
}
if(j==1&&newbanji&&newxuesheng)
{
//System.out.println(1223);
d[0]=new BanJi();//new第一个班级
d[0].banhao=Integer.parseInt(arr[0])/100;//添加班号
d[0].xssl++;
d[0].student[d[0].xssl]=new XueSheng();//new第一个班级里的第一个学生
d[0].student[d[0].xssl].xuehao=Integer.parseInt(arr[0]);//学生学号
d[0].student[d[0].xssl].name=arr[1];//学生姓名
k++;
}
if(j>1&&newbanji&&newxuesheng)//从第二个数据开始处理
{
if(d[0]==null)
{
//System.out.println(1223);
d[0]=new BanJi();//new第一个班级
d[0].banhao=Integer.parseInt(arr[0])/100;//添加班号
d[0].xssl++;
d[0].student[d[0].xssl]=new XueSheng();//new第一个班级里的第一个学生
d[0].student[d[0].xssl].xuehao=Integer.parseInt(arr[0]);//学生学号
d[0].student[d[0].xssl].name=arr[1];//学生姓名
k++;
}
for(t=0;t<k;t++)
{
if(Integer.parseInt(arr[0])/100==d[t].student[d[t].xssl].xuehao/100)//如果班级号不一样，则开新的班级,如果班级号一样，将这个学生放到这个班级里去
{
flag=0;
if(Integer.parseInt(arr[0])!=d[t].student[d[t].xssl].xuehao)//学号不同学生数量加一
{
d[t].xssl++;//对应班级里的学生数量加1
d[t].student[d[t].xssl]=new XueSheng();//这个班级里new一个新的学生
d[t].student[d[t].xssl].xuehao=Integer.parseInt(arr[0]);//学生学号
d[t].student[d[t].xssl].name=arr[1];//学生姓名
}
break;
}
}
//System.out.println(flag);
if(flag==1)//开新的班级
{
//System.out.println(112);
d[k]=new BanJi();//new 一个新的班级
d[k].banhao=Integer.parseInt(arr[0])/100;
d[k].xssl++;
d[k].student[d[k].xssl]=new XueSheng();//这个班级里new一个新的学生
d[k].student[d[k].xssl].xuehao=Integer.parseInt(arr[0]);//学生学号
d[k].student[d[k].xssl].name=arr[1];//学生姓名
k++;//班级数加1
}
}
//System.out.println(k);
if(newbanji&&newxuesheng)
{
// System.out.println(b[1].flag1);
//System.out.println(d[1].xssl);
for(l=0;l<i;l++)//在课表中查找选课信息
{
if(b[j].kecheng.name.equals(a[l].kecheng.name))//如果课程名字等于课表名字
{
for(m=0;m<k;m++)
for(n=1;n<=d[m].xssl;n++)
if(b[j].student.xuehao==d[m].student[n].xuehao&&b[j].flag==2)//课表存在，这个学生选课数量加一且不重复
{
//System.out.println(123344);
if(b[j].flag1==1)//这条成绩记录有效
{
//System.out.println(123);
d[m].student[n].xksl++;//这个学生的选课数量加1//&&b[j].flag==1
a[l].xkrs++;//选课人数加1
b[j].flag3=0;
}
//System.out.println(b[j].flag3);
if(b[j].flag1==0&&b[j].flag3==1)//
{
d[m].student[n].xksl++;//这个学生的选课数量加1
}
}
if(a[l].flag==0) {
b[j].kecheng.kaohefashi=a[l].kecheng.kaohefashi;//考察方式赋值
if(b[j].kecheng.kaohefashi.equals("考察")&&arr.length==4)//考察的总成绩直接等于期末成绩
{
int e=Integer.parseInt(arr[3]);
if(e>=0&&e<=100)
{
if(b[j].flag1==1) {//这条成绩有效
if(b[j].flag==2) {//成绩重复了则不加进去
a[l].kcqmcj+=e;//将期末成绩加到这门课里进去
b[j].student.chengji.qmcj=e;//考察的话成绩就等于期末成绩
a[l].kcsum+=b[j].jskccj();
for(m=0;m<k;m++)//1.将同学的成绩从选课中放到班级中去 2.将相同学生的成绩加到一块去
for(n=1;n<=d[m].xssl;n++)
if(b[j].student.xuehao==d[m].student[n].xuehao)//比学号
{
d[m].student[n].sum1+=b[j].jskccj();//这个学生的成绩加起来
break;
}
}
}
}
}




if(b[j].kecheng.kaohefashi.equals("考试")&&arr.length==5)//考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，
{
int e=Integer.parseInt(arr[3]);
int f=Integer.parseInt(arr[4]);
if(e>=0&&e<=100&&f>=0&&f<=100)
{
if(b[j].flag1==1) {
if(b[j].flag==2) {//重复成绩只加一遍
a[l].kcpscj+=e;//将平时成绩加进去课表
a[l].kcqmcj+=f;//将期末成绩加进去课表
b[j].student.chengji.pscj=e;//考察的话成绩就等于期末成绩
b[j].student.chengji.qmcj=f;//考察的话成绩就等于期末成绩
a[l].kcsum+=(int)(e*a[l].kecheng.psqz+f*a[l].kecheng.qmqz);
for(m=0;m<k;m++)
for(n=1;n<=d[m].xssl;n++)
if(b[j].student.xuehao==d[m].student[n].xuehao&&b[j].flag==2)//比学号
{
d[m].student[n].sum1+=(int)(e*a[l].kecheng.psqz+f*a[l].kecheng.qmqz);//这个学生的成绩加起来
break;
}
}
}
}
}





if(b[j].kecheng.kaohefashi.equals("实验"))//考察的总成绩直接等于期末成绩
{
b[j].sycs=Integer.parseInt(arr[3]);
int []e=new int[10];
int r=0;
for(y=3;y<arr.length;y++)
{

e[r]=Integer.parseInt(arr[y]);
//System.out.println(e[r]);
r++;
}
if(b[j].flag1==1) {//这条成绩有效
if(b[j].flag==2) {//成绩重复了则不加进去
for(y=0;y<r;y++)
{
//System.out.println(1223);
b[j].student.chengji.sycj+=e[y]*a[l].kecheng.sy[y];
}
a[l].sycj+=(int)(b[j].student.chengji.sycj);//将期末成绩加到这门课里进去
// System.out.println(a[l].sycj);
// System.out.println(a[l].xkrs);
for(m=0;m<k;m++)//1.将同学的成绩从选课中放到班级中去 2.将相同学生的成绩加到一块去
for(n=1;n<=d[m].xssl;n++)
if(b[j].student.xuehao==d[m].student[n].xuehao)//比学号
{
d[m].student[n].sum1+=b[j].student.chengji.sycj;//这个学生的成绩加起来
break;
}
}
}

}





}
}
}
}
j++;//选课数量加一
}
c=input.nextLine();
}
//System.out.println(d[0].student[1].sum1);
// System.out.println(d[0].student[1].xksl);
// System.out.println(d[0].student[2].xksl);
// System.out.println(d[1].student[1].xksl);
// System.out.println(d[1].student[2].xksl);
Arrays.sort(d,0,k,new Compaerclass());//排序班级
for(int p=0;p<k;p++)
{
Arrays.sort(d[p].student,1,d[p].xssl+1,new Compaerstudent());//排序班级里的学生
}
Arrays.sort(a,0,i,new Compaerkebiao());//排序课表
// for(m=0;m<k;m++)//将同一个班级里的学生成绩加起来
// for(n=1;n<=d[m].xssl;n++)

//System.out.println(k);
for(m=0;m<k;m++)//输出学生信息
for(n=1;n<=d[m].xssl;n++)
{
if(d[m].student[n].sum1==0)//如果学生没有成绩
System.out.println(d[m].student[n].xuehao+" "+d[m].student[n].name+" "+"did not take any exams");
else
{
System.out.println(d[m].student[n].xuehao+" "+d[m].student[n].name+" "+d[m].student[n].sum1/(d[m].student[n].xksl-1));
}
}
for(m=0;m<i;m++)//i为课表数量//输出课表信息
{
if(a[m].flag==0)
{
{
if(a[m].kecheng.kaohefashi.equals("考察"))
{
if(a[m].kcpscj==0&&a[m].kcqmcj==0&&a[m].sycj==0)//某门课程没有成绩
System.out.println(a[m].kecheng.name+" "+"has no grades yet");
else
System.out.println(a[m].kecheng.name+" "+a[m].zpjf());
}
if(a[m].kecheng.kaohefashi.equals("考试")&&(a[m].kecheng.psqz+a[m].kecheng.qmqz)==1)
{
if(a[m].kcpscj==0&&a[m].kcqmcj==0&&a[m].sycj==0)//某门课程没有成绩
System.out.println(a[m].kecheng.name+" "+"has no grades yet");
else
System.out.println(a[m].kecheng.name+" "+a[m].zpjf());
}
if(a[m].kecheng.kaohefashi.equals("实验")&&a[m].sum==1)
{
if(a[m].kcpscj==0&&a[m].kcqmcj==0&&a[m].sycj==0)//某门课程没有成绩
{
//System.out.println(1111);
System.out.println(a[m].kecheng.name+" "+"has no grades yet");
}
else
System.out.println(a[m].kecheng.name+" "+a[m].sypjf());
}
}
}
}
//System.out.println(d[0].student[1].xksl);
for(m=0;m<k;m++)//将同一个班级里的学生成绩加起来
for(n=1;n<=d[m].xssl;n++)
{
d[m].sum+=d[m].student[n].sum1/(d[m].student[n].xksl-1);
}
for(m=0;m<k;m++)//输出班级信息
{
if(d[m].sum==0)
System.out.println(d[m].banhao+" "+"has no grades yet");
else
System.out.println(d[m].banhao+" "+d[m].sum/((d[m].xssl)));
//}
}
}
}

class BanJi {
int banhao=0;
int xssl=0;//学生数量
int i=0;
int j=0;
int k=0;//班级数量
int sum=0;//班级总分
XueSheng []student=new XueSheng[100];
}
class ChengJi {
int pscj=0;//平时成绩
int qmcj=0;//期末成绩
int sycj=0;;//实验成绩
}
class Compaerstudent implements Comparator<XueSheng>
{
@Override
public int compare(XueSheng a,XueSheng b)
{
return a.xuehao-b.xuehao;
}
}
class Compaerclass implements Comparator<BanJi>
{
@Override
public int compare(BanJi a,BanJi b)
{
return a.banhao-b.banhao;
}
}
class Compaerkebiao implements Comparator<KeBiao>
{
@Override
public int compare(KeBiao o1, KeBiao o2) {

try {
Comparator compator = Collator.getInstance(Locale.CHINA);
if (compator.compare(o1.kecheng.name, o2.kecheng.name) < 0) {
return -1;
} else if (compator.compare(o1.kecheng.name, o2.kecheng.name) > 0) {
return 1;
}
} catch (Exception e) {
}
return 0;
}

}
class KaoCha extends ChengJi{
int qmcj=0;//期末成绩
}
class KaoShi extends ChengJi{
int pscj=0;//平时成绩
int qmcj=0;//期末成绩
}
class KeBiao {
KeCheng kecheng=new KeCheng();
float sum=0;//计算权重和
int kcpscj=0;//课程平时成绩
int kcqmcj=0;//课程期末成绩
int kcsum=0;//课程总成绩
int sycj=0;//实验成绩
int xkrs=0;//选课人数
int flag=0;//等于0表示这个课表有用
int jsqmpjf() {//期末成绩平均分
return (int)kcqmcj/xkrs;
}
int jspspjf() {//平时成绩平均分
return (int)kcpscj/xkrs;
}
int qmpjf() {//考试平均分
return (int)((int)(kcpscj*0.3+kcqmcj*0.7)/xkrs);
}
int zpjf() {//考察平均分
return (int)kcsum/xkrs;
}
int sypjf() {//考察平均分
return (int)sycj/xkrs;
}
}
class KeCheng {
String name=""; //课程名字
String xingzhi="";//课程性质
int f=0;//成绩数量；
String kaohefashi="";
float psqz=0;
float qmqz=0;
float []sy=new float[10];
}
class XuanKe {
KeCheng kecheng =new KeCheng();
XueSheng student=new XueSheng();
ChengJi chengji=new ChengJi();
int flag1=1;//判断这条记录是否有效
int flag=1;//学生重复数据数
int flag3=1;
int i=0;
int sycs=0;//实验次数
int jskccj()//计算考察成绩
{
student.sum=student.chengji.qmcj;
return student.sum;
}
//int jskscj()//计算考试成绩
//{
// student.sum=(int)(student.chengji.qmcj*0.7+student.chengji.pscj*0.3);
// return student.sum;
//}
//int jssycj()//计算实验成绩
//{
// student.sum=(int)(student.chengji.sycj/sycs);
// return student.sum;
//}
}
class XueSheng {
int xuehao=0;
String name="";
int sum=0;//选课里的成绩
int sum1=0;//班级里的成绩
int xksl=1;//选课的数量（默认为1）
ChengJi chengji=new ChengJi();
}

 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　主要困难

这三次作业当中的主要困难还是有关类的设计，我对类的设计还不是很熟悉，目前还停留在了c语言面向过程设计的地方，这导致我每次做题目时我都想用面向过程的方法来写题目，可是小题目还好，可是到了大题目的话我就有点稀里糊涂了，摸不着方向，不知道该从何先手。尤其点菜类那三道大题，我是一点头绪都没有。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　改进建议

在以后的写作业过程中，要多习惯使用面向对象的方法来解题，不应该老是想着用面向过程的方法来写题目。还是要多加练习，之前那几次大作业是我的态度不够端正才导致我的份数那么难看，以后的大作业我要好好端正我的态度，争取下次大作业的分数超过70分。加油！

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 总结

1.学到了什么：

　　　　　　　　　　　　　　　　（1）：输入语句的使用。

　　　　　　　　　　　　　　　   （2）：java中多个if（）判断语句的使用。

　　　　　　　　　　　　　　　　（3）：java中的if（）和else语句的嵌套使用，

　　　　　　　　　　　　　　　   （3）：java中的四则运算。

　　　　　　　　　　　　　　　   （4）：java中的for()循环语句的使用。

　　　　　　　　　　　　　　　　（5）：java中的switch()语句的使用。

　　　　　　　　　　　　　　　　（6）：java中的一些对字符串处理的方法，例如：a.substring(0,2)，该方法的作用是将字符串a中的第一二位的字符提取出来。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 c.equals(s)，该方法是对字符串进行比对的方法，如果字符串c与字符串s相等，则返回true，否则返回false。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　a.charAt(i)，该方法是对字符串提取的作用，它可以将字符串a中的第i为提取出来。

　　　　　　　　　　　　　　　　 （7）：在第一次作业的7-8中，我发现原来java中的浮点数据会有误差，在完成作业的时候应该考虑到精度问题。并且还学会了java中的一中数学处理方法，Math.abs(),该　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　   　　　　　　　　　　　　　　　　　　　方法是对括号内的数进行取绝对值的处理。

　　　　　　　　　　　　　　　　（8）：我学会了对一道很复杂的题目进行面对对象的程序设计，并且明白面对对象的程序设计与面对过程的程序设计直接的差别。

　　　　　　　　　　　　　　　　（9）：我学会了如何通过基年法来判断该天是周几和通过基年法计算两个日期之间相差的天数。

　　　　　　　　　　　　　　　　（10）：java中的分割字符串的方法a.split(" ")，该方法的作用是将字符串a按空格进行分割。

　　　　　　　　　　　　　　　　（11）：java中的Arrays.sort（），该方法是将括号内的数进行排序处理。

　　　　　　　　　　　　　　　　（12）：java中对数据进行封装（private）

　　　　　　　　　　　　　　　　（13）含参构造和无参构造。

　　　　　　　　　　　　　　　　  （14）正则表达式的使用。在一些需要对输入进行判断时我们就可以用到正则表达式。

　　　　　　　　　　　　　　　　（15）继承的使用（父类与子类）继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

　　　　　　　　　　　　　　　　　　继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

　　　　　　　　　　　　　　　　　（16）在这几次的大作业学习和期中考试当中，我也充分的理解了类与类之间的关系：

　　　　　　　　　　　　　　　　　　　　　　继承关系：继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。

　　　　　　　　　　　　　　　　　　　　　　实现关系：实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。

　　　　　　　　　　　　　　　　　　　　　　依赖关系：依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

　　　　　　　　　　　　　　　　　　　　　　关联关系：关联体现的是两个类之间语义级别的一种 强依赖关系，关联可以是单向、双向的。

　　　　　　　　　　　　　　　　　　　　　　聚合关系：聚合是关联关系的一种特例，它体现的是整体与部分的关系，即 has-a 的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于　　　　　　　　　　　　　　　　　　  　　　　　　　　　　　　　　　　　　　　　　　　　　  多个整体对象，也可以为多个整体对象共享。

　　　　　　　　　　　　　　　　　　　　　　组合关系：组合也是关联关系的一种特例，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也 　　 　　  　　　　　　　　　　　　　　　　　　　　　　　　　　 就意味着部分的生命周期结束。

 

建议：我希望老师在课堂上能和我们一起写一些代码，将我们带入到写代码中去，这样就很有利于我们对面向对象这一方法的理解，而不是一直给我们灌输面向对象思想，这种对象很抽象，就算你举了春游的例子来帮助我们理解，可是看到的东西是要比听到的东西好很多的，所以我希望老师在课堂上能够加一下写代码的环节。谢谢老师！

实验的话我也希望老师能够讲解一些，而不是直接将实验甩给我们让我们自己思考，这对于我们这些基础比较差的同学来说真的很吃力。

 

希望老师能够看到我的建议，也希望老师在看到我的建议之后能够有所改变，谢谢老师！