继承覆盖综合练习 （答案+解析）

7-2 jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company

定义Person抽象类，Student类、Company类，Employee类。

Person类的属性：String name, int age, boolean gender
Person类的方法:

public Person(String name, int age, boolean gender);
public String toString(); //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false

Student类继承自Person，属性:String stuNo, String clazz
Student类的方法:

//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);
public String toString(); //返回 “Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。

Company类属性：String name
Company类方法:

public Company(String name);
public String toString(); //直接返回name
public boolean equals(Object obj);//name相同返回true

Employee类继承自Person，属性：Company company, double salary
Employee类方法：

//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);
public String toString(); //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数

编写equals方法重要说明：

对Employee的company属性的比较。要考虑传入为null的情况。如果company不为null且传入为null，返回false
对所有String字符类型比较时，也要考虑null情况。

提示

1. 排序可使用Collections.sort
2. equals方法要考虑周全

#main方法说明

1. 创建若干Student对象、Employee对象。 输入s，然后依次输入name age gender stuNo
   clazz创建Student对象。 输入e，然后依次输入name age gender salary
   company创建Employee对象。 然后将创建好的对象放入List
   personList。输入其他字符，则结束创建。

创建说明:

1. 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
2. 对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable< Person >或Comparator< Person >
3. 接受输入，如果输入为exit则return退出程序，否则继续下面步骤。
4. 将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。
5. 输出字符串stuList，然后输出stuList中的每个对象。
6. 输出字符串empList，然后输出empList中的每个对象。

1-3为一个测试点 4-6为一个测试点

import java.text.DecimalFormat;
import java.util.*;

abstract class Person{
    String name;
    String cha;//定义了输入对象的类型，'s'或'e'
    int age;
    boolean gender;
    public Person(String cha,String name, int age, boolean gender){
        this.name=name;
        this.age=age;
        this.gender=gender;
        this.cha=cha;
    }
    public String getName(){
        return this.name;
    }//将来需要根据姓名进行排序

    public int getAge() {
        return age;
    }//将来需要根据年龄进行排序

    public String getCha() {
        return cha;
    }//将来会根据对象的类型分配到不同的数组中

    public String toString(){
        return name+'-'+age+'-'+gender;
   }//返回"name-age-gender"格式的字符串


    @Override
    public boolean equals(Object o) {
        Person person = (Person) o;
        if (this == o) return true;
        if (o == null) return false;
        if (person.name==null||this.name==null) return false;
        return age == person.age && gender == person.gender && name.equals(person.name);
    }//重载了equals方法
}

class Student extends Person{
    String stuNo;
    String clazz;
    public Student(String cha,String name, int age, boolean gender, String stuNo, String clazz){
        super(cha,name,age,gender);
        this.stuNo=stuNo;
        this.clazz=clazz;
    }

    public String toString(){
        return "Student"+':'+super.toString()+'-'+stuNo+'-'+clazz;
    }//返回 “Student:person的toString-stuNo-clazz”格式的字符串

    @Override
    public boolean equals(Object o) {
        if (super.equals(o)) {//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。

            Student student = (Student) o;
            if (this == o) return true;
            if (!super.equals(o)) return false;//我觉得这一句可以删掉，明显和if语句的判断语句重合了
            return Objects.equals(stuNo, student.stuNo) && Objects.equals(clazz, student.clazz);
        }
        else {
            return false;
        }
    }
 }

class Company{
    String name;
    public Company(String name){
        this.name=name;
    }
    public String toString(){
        return name;
    }         //直接返回name

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Company)) return false;
        Company company = (Company) o;
        return Objects.equals(name, company.name);
    } //name相同返回true

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
   }

class Employee extends Person{
    Company company;
    double salary;
    public Employee(String cha,String name, int age, boolean gender, double salary, Company company){
        super(cha,name,age,gender);//使用super复用Person类的相关有参构造函数
        this.salary=salary;
        this.company=company;

    }
    public String toString(){
        return "Employee:"+super.toString()+'-'+company+'-'+salary;
    }         //返回"Employee:person的toString-company-salary"格式的字符串

    @Override
    public boolean equals(Object o) {
        if (super.equals(o)) { //首先调用父类的equals方法,如果返回true。再比较company与salary。
            if (this == o) return true;
            if (!(o instanceof Employee)) return false;
            if (!super.equals(o)) return false;
            Employee employee = (Employee) o;
            Double newSalary1 = Double.valueOf(new DecimalFormat("#.#").format(employee.salary));
            Double newSalary2 = Double.valueOf(new DecimalFormat("#.#").format(this.salary));
			//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#")，保留1位小数
            return Double.compare(newSalary1,newSalary2) == 0 && Objects.equals(company, employee.company);
        }
        else
            return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), company, salary);
    }

   

}

public class Main {
    public static void main(String []args){
        Scanner sc = new Scanner(System.in);
        String next=sc.next();
        List<Person> personList=new ArrayList<Person>();
        List<Student> stuList=new ArrayList<Student>();
        List<Employee> empList=new ArrayList<Employee>();
        while (next.equals("s")||next.equals("e")) {
            if (next.equals("s")) {//如果为‘s’则新建Studen对象
                Student student = new Student(next,sc.next(), sc.nextInt(), sc.nextBoolean(), sc.next(), sc.next());
                personList.add(student);//将student对象加入到personList中
                next=sc.next();
            } else {//如果为‘e’则新建Employee对象
                String name=sc.next();int age=sc.nextInt();Boolean gender=sc.nextBoolean();double salary=sc.nextDouble();
                Company company=new Company(sc.next());
                Employee employee = new Employee(next,name,age,gender,salary,company);
                personList.add(employee);//将employee对象加入到personList中
                next=sc.next();
            }
        }
        personList.sort(Comparator.comparing(Person::getName).thenComparingInt(Person::getAge));//对personList数组进行排序

        for (int i=0;i<personList.size();i++){
            System.out.println(personList.get(i).toString());
            if(personList.get(i).getCha().equals("s")){//如果cha为‘s‘则分配到stuList中
                int flag=0;
                for (int j=0;j<stuList.size();j++){//判断是否有两个内容相同的对象
                    if (personList.get(i).equals(stuList.get(j))) {
                        flag = 1;
                        break;
                    }
                }
                if(flag==0){
                    stuList.add((Student) personList.get(i));
                }
            }
            else {//如果cha为‘e’则分配到empList中
                int flag=0;
                for (int j=0;j<empList.size();j++){//判断是否有两个内容相同的对象
                    if(personList.get(i).equals(empList.get(j))) {
                        flag = 1;
                        break;
                    }
                }
                if (flag==0){
                    empList.add((Employee)personList.get(i));
                }
            }
        }
        String nextStep = sc.next();
        if (nextStep.equals("exit")||nextStep.equals("return")){//判断下一步是否要继续进行
            return;
        }
        else {//输出stuList与empList中的内容
            System.out.println("stuList");
            for (int i = 0; i < stuList.size(); i++) {
                System.out.println(stuList.get(i).toString());
            }
            System.out.println("empList");
            for (int i = 0; i < empList.size(); i++) {
                System.out.println(empList.get(i).toString());
            }
        }
    }
}

✌️