Java language programming：面向对象-继承覆盖综合练习

404ZenMaster.

于 2024-07-09 16:06:31 发布

阅读量706

点赞数 9

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/m0_73426276/article/details/140298593

版权

题目：定义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情况。

提示
排序可使用Collections.sort
equals方法要考虑周全
main方法说明

创建若干Student对象、Employee对象。
输入s，然后依次输入name age gender stuNo clazz创建Student对象。
输入e，然后依次输入name age gender salary company创建Employee对象。
然后将创建好的对象放入List personList。输入其他字符，则结束创建。
创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable或Comparator
接受输入，如果输入为exit则return退出程序，否则继续下面步骤。
将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。
输出字符串stuList，然后输出stuList中的每个对象。
输出字符串empList，然后输出empList中的每个对象。
1-3为一个测试点
4-6为一个测试点

输入样例：
s zhang 23 false 001 net15
e wang 18 true 3000.51 IBM
s zhang 23 false 001 net15
e bo 25 true 5000.51 IBM
e bo 25 true 5000.52 IBM
e bo 18 true 5000.54 IBM
e tan 25 true 5000.56 IBM
e tan 25 true 5000.51 IBM
s wang 17 false 002 null
s wang 17 false 002 null
e hua 16 false 1000 null
s wang 17 false 002 net16
e hua 16 false 1000 null
e hua 18 false 1234 MicroSoft
!
continue

输出样例：
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:bo-25-true-IBM-5000.52
Employee:hua-16-false-null-1000.0
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Student:wang-17-false-002-null
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Employee:wang-18-true-IBM-3000.51
Student:zhang-23-false-001-net15
Student:zhang-23-false-001-net15
stuList
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Student:zhang-23-false-001-net15
empList
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Employee:wang-18-true-IBM-3000.51

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        List<Person> personList = new ArrayList<>();
        OUT:
        do {
            String str = in.next();
            switch (str) {
                case "s": {
                    String name, stuNo, clazz;
                    int age; boolean gender;
                    name = in.next();
                    age = in.nextInt(); gender = in.nextBoolean();
                    stuNo = in.next(); clazz = in.next();

                    if("null".equals(name)) {
                        name = null;
                    }
                    if("null".equals(stuNo)) {
                        stuNo = null;
                    }
                    if("null".equals(clazz)) {
                        clazz = null;
                    }
                    Student newStu = new Student(name, age, gender, stuNo, clazz);
                    personList.add(newStu);
                    break;
                }
                case "e": {
                    String name;
                    int age; boolean gender;
                    double salary; Company company;
                    name = in.next();
                    age = in.nextInt(); gender = in.nextBoolean();
                    salary = in.nextDouble();
                    company = new Company(in.next());

                    if("null".equals(company.toString())) {
                        company = new Company(null);
                    }

                    Employee newE = new Employee(name, age, gender, salary, company);
                    personList.add(newE);
                    break;
                }
                default:
                    break OUT;
            }
        }while(true);

        Collections.sort(personList);	
        for(Person p : personList) {
            System.out.println(p);
        }


        if("exit".equals(in.next())) {
            return;	
        }

        List<Student> stuList = new ArrayList<>();
        List<Employee> empList = new ArrayList<>();

        for(Person o : personList) {
            if(o instanceof Student && !stuList.contains(o)) {
                stuList.add((Student) o);
            }
            else if (o instanceof Employee && !empList.contains(o)) {
                empList.add((Employee) o);
            }
        }
        
        System.out.println("stuList");
        for(Student s : stuList) {
            System.out.println(s);
        }
        System.out.println("empList");
        for(Employee e : empList) {
            System.out.println(e);
        }

        in.close();
    }
}


abstract class Person implements Comparable<Person>{
    private String name;
    private int age;
    private boolean gender;

    public Person(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public String toString()  {
        return name+"-"+age+"-"+gender;
    }

    public boolean equals(Object obj) {
        Person other = (Person)obj;
        if(name.equals(other.name) && age == other.age && gender == other.gender) {
            return true;
        }
        else {
            return false;
        }
    }

    @Override
    public int compareTo(Person o) {
        int ret;
        if(name == o.name) {
            ret = 0;
        } else {
            ret = name.compareTo(o.name);
        }
        if(ret == 0) {
            Integer o1 = age;
            Integer o2 = o.age;
            ret = o1.compareTo(o2);
        }
        return ret;
    }
}

class Student extends Person{
    private String stuNo;
    private String clazz;
    
    public Student(String name, int age, boolean gender, String stuNo, String clazz) {
        super(name, age, gender);
        this.stuNo = stuNo;
        this.clazz = clazz;
    }
    public String toString() {
    
        return "Student:"+super.toString()+"-"+stuNo+"-"+clazz;
    }
    public boolean equals(Object obj) {
        Student other = (Student)obj;
        if(!super.equals(obj) ) {
            return false;
        }
        
        boolean ret1 = true;
        if(stuNo == other.stuNo) {

        } else if (stuNo == null || other.stuNo == null) {
            ret1 = false;
        } else if (!stuNo.equals(other.stuNo)) {
            ret1 = false;
        }
        boolean ret2 = true;
        if(clazz == other.clazz) {

        } else if (clazz == null || other.clazz == null) {
            ret2 = false;
        } else if (!clazz.equals(other.clazz)) {
            ret2 = false;
        }

        return ret1 && ret2;
    }

}

class Company {
    private String name;
    public Company(String name) {
        this.name = name;
    }
    public String toString() {
        if(name == null) {
            return "null";
        } else {
            return name;
        }
    }
    public boolean equals(Object obj) {
        Company other = (Company)obj;
        boolean ret = true;
        if(name == other.name) {

        } else if (name == null || other.name == null) {
            ret = false;
        } else if(!name.equals(other.name)) {
            ret = false;
        }
        return ret;
    }

}

class Employee extends Person {
    private Company company;
    private double salary;

    public Employee(String name, int age, boolean gender, double salary, Company company) {
        super(name, age, gender);
        this.salary = salary;
        this.company = company;
    }
    public String toString() {
        
        return "Employee:"+super.toString()+"-"+company.toString()+"-"+salary;
    }
    public boolean equals(Object obj) {
      

        Employee other = (Employee)obj;	
 
        boolean ret = true;
        if(!super.equals(obj)) {
            ret = false;
        }
   
        if(company == null && other.company == null) {
      
        } else if (company == null || other.company == null) {
            ret = false;
        } else if(!company.equals(other.company)) {
            ret = false;
        }
   
        DecimalFormat df = new DecimalFormat("#.#");
        if(!(df.format(salary)).equals(df.format(other.salary))) {
            ret = false;
        }
        return ret;
    }
}