类族成员统计Java语言

设计一个父类Father，从Father派生出子类Son，继续从Son派生出类Grandson。像这样题一般的思路是什么

统计当前类及子类对象思路：利用构造代码块在构造方法执行前执行的特性，记录创建的对象，从而进行统计。示例代码如下：

public class Father {

    private static List<Father> objects = new ArrayList<>();

    {
        objects.add(this);
    }

    public static Map<String, Integer> getObjectCount() {
        Map<String, Integer> map = new HashMap<>();
        for (Father object : objects) {
            String name = object.getClass().getName();
            Integer count = map.getOrDefault(name, 0) + 1;
            map.put(name, count);
        }
        return map;
    }
}

public class Son extends Father{
}

public class Grandson extends Son {
}

测试代码如下：

public class Test {

    public static void main(String[] args) {
        Father father = new Father();
        Son son1 = new Son();
        Son son2 = new Son();
        Grandson grandson = new Grandson();
        System.out.println(Father.getObjectCount());
    }
}

打印结果如下：

{com.zzuhkp.demo.Father=1, com.zzuhkp.demo.Grandson=1, com.zzuhkp.demo.Son=2}

代码如下：

public class Father {

    private String name;
    private int age;
    private int sex;

    public Father() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
}

public class Son extends Father{

    private String fatherName;

    public Son() {
    }

    public Son(String name, int age, int sex, String fatherName) {
        super(name, age, sex);
        this.fatherName = fatherName;
    }

    public String getFatherName() {
        return fatherName;
    }

    public void setFatherName(String fatherName) {
        this.fatherName = fatherName;
    }

    public String getMyselfName(String name){
        return name;
    }
}

public class Grandson extends Son{

    public Grandson() {
    }

    public Grandson(String name, int age, int sex, String fatherName) {
        super(name, age, sex, fatherName);
    }
}

@Test
    public void testClass(){
        Father father = new Father("张三",59,1);
        Son son = new Son("张三三",36,1,"张三");
        Grandson grandson = new Grandson("张三三三",36,1,"张三三");
    }

这不就是类的继承？

光是类的继承，需要啥思路，按照语法写就是

Son 继承 Father，Grandson再继承Son 不需要其他啥思路吧

设计一个父类Father，从Father派生出子类Son，继续从Son派生出类Grandson。用多种方式建立各类对象，最后统计出类族中建立的各类对象以及该类后代对象的数目

java本身就有这样的继承能力，直接写父类、子类、孙子就好了啊！这和统计有什么关系呢？

考查Java面向对象设计，类继承

设计代码如下：

public class Answer7679792 {

    public static void main(String[] args) {
        // 多态特性
        Father father = new Father("father");
        Father son = new Son("son");
        Father grandson = new Grandson("grandson");

        Son son2 = new Son("son2");
        Son grandson2 = new Grandson("grandson2");

        Grandson grandson3 = new Grandson("grandson3");

        System.out.println(father.getName());
        System.out.println(son.getName());
        System.out.println(grandson.getName());

        System.out.println(son2.getName());
        System.out.println(grandson2.getName());

        System.out.println(grandson3.getName());
    }
}

class Father {

    private String name;

    public Father(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Son extends Father {

    public Son(String name) {
        super(name);
    }
}

class Grandson extends Son {

    public Grandson(String name) {
        super(name);
    }
}

运行结果如下：

father
son
grandson
son2
grandson2
grandson3

如有帮助，请采纳，十分感谢！

派生继承，多态，虚函数表，积累指针指向哪个虚函数