、创建一个接口（Penson），一个抽象类(学生类)，一个子类(成绩)

创建一个接口（Penson），一个抽象类(学生类)，一个子类(成绩)
。
1、定义一个接口父类人类包括属性姓名和年龄和一个抽象
方法得到各自的信息；

2、定义一抽象类学生类包括一个
的信息；
3、定义个子类为成绩类包括继承抽象类完成接口
4、定义一个测试类；

// 定义接口Person
interface Person {
    String getName(); // 获取姓名
    int getAge(); // 获取年龄
    String getInfo(); // 获取个人信息
}

// 定义抽象类Student继承接口Person
abstract class Student implements Person {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    public abstract double getScore(); // 获取成绩

    public String getInfo() {
        return "姓名：" + this.name + "，年龄：" + this.age + "，成绩：" + this.getScore();
    }
}

// 定义子类Score继承抽象类Student，并实现接口Person
class Score extends Student {
    private double score;

    public Score(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return this.score;
    }
}

// 定义测试类Test
public class Test {
    public static void main(String[] args) {
        Person p = new Score("小明", 18, 90.5);
        System.out.println(p.getInfo());
    }
}

解析： 1. 接口Person定义了获取姓名、获取年龄、获取个人信息的方法。
2. 抽象类Student继承接口Person，并定义了获取成绩和获取个人信息的抽象方法。
3. 子类Score继承抽象类Student，并实现了获取成绩的方法。
4. 测试类Test中创建了Score对象，并通过Person接口获取个人信息并打印输出。

代码如下，望采纳

//定义接口Penson
interface Penson{
    public String getName();
    public int getAge();
    public void getInfo();
}

//定义抽象类学生类，实现Penson接口
abstract class Student implements Penson{
    private String name;
    private int age;
    
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return this.name;
    }
    
    public int getAge(){
        return this.age;
    }
    
    public abstract void getScore();
    
    public void getInfo(){
        System.out.println("姓名：" + this.name + "，年龄：" + this.age);
    }
}

//定义子类成绩类，继承抽象类学生类
class Score extends Student{
    private int score;
    
    public Score(String name, int age, int score){
        super(name, age);
        this.score = score;
    }
    
    public void getScore(){
        System.out.println("考试成绩：" + this.score);
    }
}

//定义测试类
public class Test{
    public static void main(String[] args){
        //创建成绩对象
        Score s = new Score("张三", 18, 90);
        
        //调用方法
        s.getInfo();
        s.getScore();
    }
}

//定义Penson接口
interface Penson {
    String getName();             //得到姓名
    int getAge();                 //得到年龄
    String getInfo();             //得到个人信息
}

//定义抽象类Student
abstract class Student implements Penson{
    protected String name;
    protected int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public abstract double getScore();
}

//定义成绩子类
class Grade extends Student {
    private double score;
    public Grade(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
    public double getScore() {
        return score;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getInfo() {
        return "姓名：" + name + "，年龄：" + age + "，分数：" + score;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Grade g = new Grade("Tom", 20, 98.5);
        System.out.println(g.getInfo());
    }
}

// Penson接口
interface Penson {
    String getName();  // 获取姓名
    int getAge();  // 获取年龄
    String getInfo();  // 获取信息
}

// 抽象类学生类
abstract class Student implements Penson {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    // 抽象方法获取信息
    public abstract String getInfo();
}

// 子类成绩类
class Grade extends Student {
    private float score;

    public Grade(String name, int age, float score) {
        super(name, age);
        this.score = score;
    }

    // 实现抽象方法获取信息
    public String getInfo() {
        return "Name: " + getName() + ", Age: " + getAge() + ", Score: " + this.score;
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 创建成绩对象
        Grade grade = new Grade("Tom", 18, 85.5f);
        // 输出成绩信息
        System.out.println(grade.getInfo());
    }
}