Java类的继承、抽象类的使用

假定根据学生的3门学位课程的分数决定其是否可以毕业，对于本科生，如果3门课程的平均分数超过60分即能毕业，而对于研究生,则需要平均分超过80分并且论文合格才能毕业。
通过子类和继承来实现
1)设计一个Student描述学生的共同特征和行为（学号，三门课程成绩；设置成绩，计算平均成绩)。
2)设计一个描述本科生的类ndergraduate,该类继承并扩展Student类（增加方法：判断是否毕业）.
3)设计一个描述研究生的类Graduate,该类继承并扩展Student类。（增加属性：论文是否合格；增加方法：判断是否毕业）。
4)设计一个测试类StudentDemo,分别创建本科生和研究生这两个类的对象，并输出相关信息

Student类

package my_homework;

public class Student {
    public String name;
    public double score[];

    Student() {
        ;
    }

    Student(String name, double s1, double s2, double s3) {
        this.name = name;
        score = new double[3];
        score[0] = s1;
        score[1] = s2;
        score[2] = s3;
    }

    Student(String name) {
        this.name = name;
    }

    public double[] getScore() {
        return score;
    }

    public String getName() {
        return name;
    }

    public void set_scores(double s1, double s2, double s3) {
        score[0] = s1;
        score[1] = s2;
        score[2] = s3;
    }
    public double get_ave(){
        return (score[0]+score[1]+score[2])/3.0;
    }
}

Undergraduate类

package my_homework;

public class Undergraduate extends Student{
    Undergraduate(String name, double s1, double s2, double s3){
        super(name, s1, s2, s3);
    }

    public boolean is_graduate(){
        if(get_ave()>60) return true;
        return false;
    }
}

Graduate类

package my_homework;

public class Graduate extends Student{
    public boolean is_hege;
    Graduate(String name, double s1, double s2, double s3,double lunwen){
        super(name, s1, s2, s3);
        if(lunwen>80) is_hege=true;
        else is_hege=false;
    }

    public boolean is_graduate(){
        return is_hege&&(get_ave()>60);
    }

    public void setIs_hege(boolean is_hege) {
        this.is_hege = is_hege;
    }

    public boolean getIs_hege(){
        return is_hege;
    }
}

StudentDemo类

package my_homework;

public class StudentDemo {
    public static void main(String args[]) {
        //本科生
        Undergraduate undergraduate = new Undergraduate("XiaoMing", 91.5, 88.0, 99.5);
        System.out.println("该本科生姓名：" + undergraduate.getName());
        double t[]=undergraduate.getScore();
        System.out.print("      成绩：");
        for(int i=0;i<3;i++){
            System.out.print(t[i]+",");
        }
        System.out.println();
        System.out.println("      平均分为："+undergraduate.get_ave());
        System.out.println("该本科生成绩有误，修正第二门成绩为90.0,重新设置成绩");
        undergraduate.set_scores(91.5,90.0,99.5);
        System.out.println("该本科生姓名：" + undergraduate.getName());
        t=undergraduate.getScore();
        System.out.print("      成绩：");
        for(int i=0;i<3;i++){
            System.out.print(t[i]+",");
        }
        System.out.println();
        System.out.println("      平均分为："+undergraduate.get_ave());
        if(undergraduate.is_graduate()) System.out.println("该本科生可以毕业");
        else System.out.println("该本科生不可以毕业");
        System.out.println("================================");
        //研究生
        Graduate graduate = new Graduate("WangRuo", 66.5, 45.5, 60.0,96);
        System.out.println("该研究生姓名："+graduate.getName());
        System.out.print("      成绩：");
        t=graduate.getScore();
        for(int i=0;i<3;i++){
            System.out.print(t[i]+",");
        }
        System.out.println();
        System.out.println("该研究生平均分为："+graduate.get_ave());
        if(graduate.getIs_hege()) System.out.println("该研究生论文成绩合格");
        else System.out.println("该研究生论文成绩不合格");
        if(graduate.is_graduate()) System.out.println("该研究生可以毕业");
        else System.out.println("该研究生不可以毕业");
    }
}

在前面的基础上
1)为Student类增加方法，判断学生是否毕业
2)在Undergraduate和Graduate类中，分别重写该方法

在Student类中加上：

    public boolean is_graduate(){
        if(get_ave()>60) return true;
        else return false;
    }

即可
（Undergraduate和Graduate类中原本用的判断毕业函数就是这个）
（这时子类不能直接调用父类中的判断毕业函数，因为已经重写，但是在子类中可以通过super调用父类中的方法或者变量）

在前面的基础上修改：
1）定义Student类为abstract类，有抽象的方法isGraduate
2）Student的两个子类Undergraduate，Graduate重写抽象的方法
3）通过上转型对象调用子类重写的方法

Student类变为：

package my_homework;

abstract class Student {
    public String name;
    public double score[];

    Student() {
        ;
    }

    Student(String name, double s1, double s2, double s3) {
        this.name = name;
        score = new double[3];
        score[0] = s1;
        score[1] = s2;
        score[2] = s3;
    }

    Student(String name) {
        this.name = name;
    }

    public double[] getScore() {
        return score;
    }

    public String getName() {
        return name;
    }

    public void set_scores(double s1, double s2, double s3) {
        score[0] = s1;
        score[1] = s2;
        score[2] = s3;
    }
    public double get_ave(){
        return (score[0]+score[1]+score[2])/3.0;
    }

    public boolean is_graduate(){
        if(get_ave()>60) return true;
        else return false;
    }

    abstract boolean isGraduate();

}

Undergraduate类添加：

    boolean isGraduate() {
        if(get_ave()>60) return true;
        return false;
    }

Graduate类添加：

    boolean isGraduate() {
        return is_hege&&(get_ave()>60);
    }

StudentDemo类：

        //通过上转型对象调用子类重写的方法
        //调用本科生类
        Student u1=new Undergraduate("HuaHua",92.5,93.5,94.5);
        if(u1.isGraduate())  System.out.println("该学生可以毕业");
        else System.out.println("该学生不可以毕业");
        //调用研究生类
        Student u2=new Graduate("LuoLuo",96.5,68.5,90.5,88.0);
        if(u2.isGraduate()) System.out.println("该学生可以毕业");
        else System.out.println("该学生不可以毕业");

---