Java程序设计2023-第三次上机练习

仅供参考，请勿CTRL+CV提交OJ

7-1jmu-Java-03面向对象基础-04-形状-继承

1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
是否应该声明为static?
输入样例:

4
rect
3 1
rect
1 5
cir
1
cir
2

输出样例:

38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape

import java.util.*;
abstract class Shape{
    static final double PI=3.14;
    public abstract double getPerimeter();
    public abstract double getArea();
    public static double sumAllArea(Shape []a,int n){
        double res=0;
        for(int i=0;i<n;i++){
            res+=a[i].getArea();
        }
        return res;
    }
    public static double sumAllPerimeter(Shape []a,int n){
        double res=0;
        for(int i=0;i<n;i++){
            res+=a[i].getPerimeter();
        }
        return res;
    }
}
class Rectangle extends Shape{
    private int width,length;
    public Rectangle(int width,int length){
        this.width=width;
        this.length=length;
    }
    public double getPerimeter(){
        return (width+length)*2;
    }
    public double getArea(){
        return width*length;
    }
    public String toString(){
        return "Rectangle [width="+width+", length="+length+"]";
    }
}
class Circle extends Shape{
    private int radius;
    public Circle(int radius){
        this.radius=radius;
    }
    public double getPerimeter(){
        return 2*PI*radius;
    }
    public double getArea(){
        return PI*radius*radius;
    }
    public String toString(){
        return "Circle [radius="+radius+"]";
    }
}
public class Main{
	public static void main(String args[]){
        Scanner in=new Scanner(System.in);
		String str=in.nextLine();
		int n=Integer.parseInt(str);
        Shape []a=new Shape[n];
		for(int i=0;i<n;i++){
            str=in.nextLine();
            if(str.equals("rect")){
                str=in.nextLine();
                String []strArr=str.split("\\s+");
                int []x=new int[2];
                for(int j=0;j<2;j++){
                    x[j]=Integer.parseInt(strArr[j]);
                }
                a[i]=new Rectangle(x[0],x[1]);
            }else{
                str=in.nextLine();
                int x=Integer.parseInt(str);
                a[i]=new Circle(x);
            }
        }
        System.out.println(Shape.sumAllPerimeter(a,n));
        System.out.println(Shape.sumAllArea(a,n));
        
        System.out.println(Arrays.toString(a));
        for(int i=0;i<n;i++)
        	System.out.println(a[i].getClass()+","+a[i].getClass().getSuperclass());
    }
}

7-3jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法:

public Integer push(Integer item);
//如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek();  //获得栈顶元素，如果为空，则返回null.
public boolean empty(); //如果为空返回true
public int size();      //返回栈中元素个数
定义IntegerStack的实现类ArrayIntegerStack，内部使用数组实现。创建时，可指定内部数组大小。

main方法说明
输入n，建立可包含n个元素的ArrayIntegerStack对象
输入m个值，均入栈。每次入栈均打印入栈返回结果。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值。
输入x，然后出栈x次，每次出栈均打印。
输出栈顶元素，输出是否为空，输出size
使用Arrays.toString()输出内部数组中的值。
思考
如果IntegerStack接口的实现类内部使用ArrayList来存储元素，怎么实现？测试代码需要进行什么修改？

输入样例

5
3
1 2 3
2

输出样例

1
2
3
3,false,3
[1, 2, 3, null, null]
3
2
1,false,1
[1, 2, 3, null, null]

import java.util.*;
interface IntegerStack{
    public Integer push(Integer item);
    //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
	public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
	public Integer peek();  //获得栈顶元素，如果为空，则返回null.
	public boolean empty(); //如果为空返回true
	public int size();      //返回栈中元素个数
}
class ArrayIntegerStack implements IntegerStack{
    private Integer[]a;
    private int mx;
    public static int p=0;
    public ArrayIntegerStack(int n){
        a=new Integer[n];
        mx=n;
    }
    //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
    public Integer push(Integer item){
        if(item==null)return null;
        if(p>=mx)return null;
        a[p]=item;
        p++;
        return item;
    }
     //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer pop(){
        if(p==0)return null;
        p--;
        return a[p];
    }  
    //获得栈顶元素，如果为空，则返回null.
    public Integer peek(){
        if(p==0)return null;
        return a[p-1];
    }
    //如果为空返回true
    public boolean empty(){
        if(p==0)return true;
        return false;
    }
    //返回栈中元素个数
    public int size(){
        return p;
    }
    public String toString(){
        return Arrays.toString(a);
    }
}
public class Main{
    public static void main(String args[]){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int n=Integer.parseInt(str);
        ArrayIntegerStack ais=new ArrayIntegerStack(n);
        str=in.nextLine();
        int m=Integer.parseInt(str);
        str=in.nextLine();
        String []s=str.split("\\s+");
        for(int i=0;i<m;i++){
            System.out.println(ais.push(Integer.parseInt(s[i])));
        }
        System.out.println(ais.peek()+","+ais.empty()+","+ais.size());
        System.out.println(ais.toString());
        
        str=in.nextLine();
        int x=Integer.parseInt(str);
        for(int i=0;i<x;i++){
            System.out.println(ais.pop());
        }
        System.out.println(ais.peek()+","+ais.empty()+","+ais.size());
        System.out.println(ais.toString());
    }
}

7-3教师类

设计一个教师类Teacher,要求：
属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应的get和set方法。
为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。
重写Teacher类的toString方法，通过该方法可以返回“no: , name:, age: **, seminary: **”形式的字符串。

输入格式:
两个教师对象的编号，姓名，年龄，学院

输出格式:
教师的信息
两个教师是否相等

输入样例:
在这里给出一组输入。例如：

1 Linda 38 SoftwareEngineering
2 Mindy 27 ComputerScience

输出样例:
在这里给出相应的输出。例如：

no: 1, name:Linda, age: 38, seminary: SoftwareEngineering
no: 2, name:Mindy, age: 27, seminary: ComputerScience
false

import java.util.*;
class Teacher{
    int no,age;
    String name,seminary;
    public Teacher(int aNo,String aName,int anAge,String aSeminary){
        no=aNo;age=anAge;
        name=aName;seminary=aSeminary;
    }
    public Teacher(){no=0;age=0;name="null";seminary="null";}
    public int getNo(){return no;}
    public int getAge(){return age;}
    public String getName(){return name;}
    public String getSeminary(){return seminary;}
    public void setNo(int aNo){no=aNo;}
    public void setAge(int anAge){age=anAge;}
    public void setName(String aName){name=aName;}
    public void setSeminary(String aSeminary){seminary=aSeminary;}
    public boolean equals(Teacher b){
        if(b.getNo()==no)return true;
        return false;
    }
    public String toString(){
        return "no: "+no+", name:"+name+", age: "+age+", seminary: "+seminary;
    }
}
public class Main{
    public static void main(String []args){
        Teacher[] tc=new Teacher[2];
        Scanner in=new Scanner(System.in);
        for(int i=0;i<2;i++){
            String str=in.nextLine();
            String []strArr=str.split("\\s+");            
            tc[i]=new Teacher(Integer.parseInt(strArr[0]),strArr[1],Integer.parseInt(strArr[2]),strArr[3]);
        }
        System.out.println(tc[0]);
        System.out.println(tc[1]);
        System.out.println(tc[0].equals(tc[1]));
    }
}

7-4教师类-2

修改教师类，使得由多个Teacher对象所形成的数组可以排序（编号由低到高排序），并在main函数中使用Arrays.sort(Object[] a)方法排序
定义一个类TeacherManagement，包含教师数组，提供方法add(Teacher[])，使其可以添加教师，提供重载方法search，方法可以在一组给定的教师中，根据姓名或年龄返回等于指定姓名或年龄的教师的字符串信息，信息格式为：“no: , name:, age: **, seminary: **”。如果没有满足条件的教师，则返回“no such teacher”。
输入格式:
教师个数
教师信息
待查找教师的姓名
待查找教师的年龄

输出格式:
排序后的信息
按姓名查找的老师信息
按年龄查找的老师信息

输入样例:
在这里给出一组输入。例如：

4
3 Linda 38 SoftwareEngineering
1 Mindy 27 ComputerScience
4 Cindy 28 SoftwareEngineering
2 Melody 27 ComputerScience
Cindy
27

输出样例:
在这里给出相应的输出。例如：

no: 1, name: Mindy, age: 27, seminary: ComputerScience
no: 2, name: Melody, age: 27, seminary: ComputerScience
no: 3, name: Linda, age: 38, seminary: SoftwareEngineering
no: 4, name: Cindy, age: 28, seminary: SoftwareEngineering
search by name:
no: 4, name: Cindy, age: 28, seminary: SoftwareEngineering
search by age:
no: 1, name: Mindy, age: 27, seminary: ComputerScience
no: 2, name: Melody, age: 27, seminary: ComputerScience

没写TeacherManagement类，凑合看

import java.util.*;
class Teacher{
    int no,age;
    String name,seminary;
    public Teacher(int aNo,String aName,int anAge,String aSeminary){
        no=aNo;age=anAge;
        name=aName;seminary=aSeminary;
    }
    public Teacher(){no=0;age=0;name="null";seminary="null";}
    public int getNo(){return no;}
    public int getAge(){return age;}
    public String getName(){return name;}
    public String getSeminary(){return seminary;}
    public void setNo(int aNo){no=aNo;}
    public void setAge(int anAge){age=anAge;}
    public void setName(String aName){name=aName;}
    public void setSeminary(String aSeminary){seminary=aSeminary;}
    public boolean equals(Teacher b){
        if(b.getNo()==no)return true;
        return false;
    }
    public String toString(){
        return "no: "+no+", name: "+name+", age: "+age+", seminary: "+seminary;
    }
    public boolean search(String aName){
        if(name.equals(aName))return true;
        return false;
    }
    public boolean search(int anAge){
        if(age==anAge)return true;
        return false;
    }
}
// class TeacherManagement{
//     Teacher [] tchr;
//     static int cnt=0;
//     public void add(Teacher[] tch){}
//     public String search(String aName){
//     }
//     public String search(int aAge){
//     }
// }
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int n=Integer.parseInt(str);
        Teacher[] tc=new Teacher[n];
        for(int i=0;i<n;i++){
            str=in.nextLine();
            String []strArr=str.split("\\s+");            
            tc[i]=new Teacher(Integer.parseInt(strArr[0]),strArr[1],Integer.parseInt(strArr[2]),strArr[3]);
        }
        Arrays.sort(tc, new Comparator<Teacher>(){
			public int compare(Teacher o1, Teacher o2) {
				return o1.getNo()-o2.getNo();
			}
		});
        for(int i=0;i<n;i++){
            System.out.println(tc[i]);
        }
        str=in.nextLine();
        System.out.println("search by name:");
        int cnt=0;
        for(int i=0;i<n;i++){
            if(tc[i].search(str)){
                System.out.println(tc[i]);
                cnt++;
            }
        }
        if(cnt==0)System.out.println("no such teacher");
        
        str=in.nextLine();
        System.out.println("search by age:");
        cnt=0;
        for(int i=0;i<n;i++){
            if(tc[i].search(Integer.parseInt(str))){
                System.out.println(tc[i]);
                cnt++;
            }
        }
        if(cnt==0)System.out.println("no such teacher");
    }

}

7-5编写一个类Shop（商店）、内部类InnerCoupons（内部购物券）

编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。

在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。

输入格式:
输入一个大于或等于3的整数。

输出格式:
使用了面值为50的购物券进行支付
牛奶还剩XX箱
使用了面值为100的购物券进行支付
牛奶还剩XX箱

输入样例:
在这里给出一组输入。例如：

5

输出样例:
在这里给出相应的输出。例如：

使用了面值为50的购物券进行支付
牛奶还剩4箱
使用了面值为100的购物券进行支付
牛奶还剩2箱

import java.util.*;
class Shop{
    public class InnerCoupons{
        int value;
        public InnerCoupons(int v){value=v;}
        public void buy(){
            System.out.println("使用了面值为"+value+"的购物券进行支付");
            milkCount-=value/50;
            System.out.println("牛奶还剩"+milkCount+"箱");
        }
    }
    int milkCount;
    InnerCoupons coupons50,coupons100;
    public Shop(int a){
        milkCount=a;
        coupons50=new InnerCoupons(50);
        coupons100= new InnerCoupons(100);
        coupons50.buy();
        coupons100.buy();
    }
    public void setMilkCount(int a){milkCount=a;}
    public int getMilkCount(){return milkCount;}
}
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int n=Integer.parseInt(str);
        Shop myshop=new Shop(n);
    }
}

7-6jmu-Java-04面向对象进阶-01-接口-Comparable

编写实现Comparable接口的PersonSortable类，使其按name以及age排序

1.编写PersonSortable类
属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString函数：返回格式为：name-age
实现Comparable接口：实现先对name升序排序，如果name相同则对age进行升序排序

2.main方法中
首先输入n
输入n行name age，并创建n个对象放入数组
对数组进行排序后输出。
最后一行使用System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));输出PersonSortable所实现的所有接口
输入样例:

5
zhang 15
zhang 12
wang 14
Wang 17
li 17

输出样例:

Wang-17
li-17
wang-14
zhang-12
zhang-15
//这行是标识信息

import java.util.*;
class PersonSortable implements Comparable<PersonSortable>{
    private String name;
    private int age;
    PersonSortable(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String toString(){
        return name+"-"+age;
    }
    public int compareTo(PersonSortable B){
        if(this.name.compareTo(B.name)>0)return 1;
        else if(this.name.compareTo(B.name)<0)return -1;
        else{
            if(this.age>B.age)return 1;
            else return -1;
        }
    }
}
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int n=Integer.parseInt(str);
        PersonSortable []ps=new PersonSortable[n];
        for(int i=0;i<n;i++){
            str=in.nextLine();
            String []s=str.split("\\s+");
            ps[i]=new PersonSortable(s[0],Integer.parseInt(s[1]));
        }
        Arrays.sort(ps);
        for(int i=0;i<n;i++){
            System.out.println(ps[i]);
        }
        System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));
    }
}

7-7jmu-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情况。
提示

排序可使用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.util.*;
import java.text.DecimalFormat;
class 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(){ //返回"name-age-gender"格式的字符串
        return name+"-"+age+"-"+gender;
    }         
    public boolean equals(Object obj){//比较name、age、gender,都相同返回true,否则返回false
        Person tmp=(Person)obj;
        if(name.equals(tmp.name)&&age==tmp.age&&gender==tmp.gender)return true;
        return false;
    }
    public String getName(){return name;}
    public int getAge(){return age;}
}
class Student extends Person{
    private String stuNo,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 String getStuNo(){return stuNo;}
    public String getClazz(){return clazz;}
    public boolean equals(Object obj){//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。
        Student tmp=(Student)obj;
        if(super.equals(tmp)){
            if(stuNo.equals(tmp.stuNo)&&clazz.equals(tmp.clazz))return true;
         }  
        return false;
    }
}
class Company{
    private String name;
    public Company(String name){this.name=name;}
    public String toString(){return name;}         
    public boolean equals(Company obj){//name相同返回true
        if(name.equals(obj.name))return true;
        return false;
    }
}
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(){//返回"Employee:person的toString-company-salary"格式的字符串
        return "Employee:"+super.toString()+"-"+company+"-"+salary;
    }         
    public boolean equals(Object obj){//首先调用父类的equals方法,如果返回true。再比较company与salary。
        Employee tmp=(Employee)obj;
        if(super.equals(tmp)){
            DecimalFormat df=new DecimalFormat("#.#");
            if(company.equals(tmp.company)&&df.format(salary).equals(df.format(tmp.salary)))
                return true;
         }  
        return false;
    }//比较salary属性时，使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数
}
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        String str;
        List<Person> personList=new ArrayList<>();
        List<Person> stuList=new ArrayList<>();
        List<Person> empList=new ArrayList<>();
        int cnt=0;
        while(true){
            str=in.nextLine();
            String []s=str.split("\\s+");
            if(s[0].equals("s")){
                Student obj=new Student(s[1],Integer.parseInt(s[2]),Boolean.parseBoolean(s[3]),s[4],s[5]);
                personList.add(obj);
                cnt++;
            }else if(s[0].equals("e")){
                Company cpny=new Company(s[5]);
                Employee obj=new Employee(s[1],Integer.parseInt(s[2]),Boolean.parseBoolean(s[3]),Double.parseDouble(s[4]),cpny);
                personList.add(obj);
                cnt++;
            }else break;
        }
        personList.sort(new Comparator<Person>() {//使用List接口的方法排序
            public int compare(Person o1, Person o2) {
                if(o1.getName().equals(o2.getName())){
                    if(o1.getAge()>=o2.getAge())return 1;
                    else return -1;
                }
                if(o1.getName().compareTo(o2.getName())>1)return 1;
                return -1;
            }
        });
        for(int i=0;i<cnt;i++){
            System.out.println(personList.get(i));
        }      
        while(true){
            str=in.nextLine();
            if(str.equals("exit")||str.equals("return"))break;
            int stucnt=0,empcnt=0;
            for(int i=0;i<cnt;i++){
                Person t=personList.get(i);
                if(t instanceof Student){
                    int f=0;
                    for(int j=0;j<stucnt;j++){
                        if(t.toString().equals(stuList.get(j).toString())){f=1;break;}
                        if(t.equals(stuList.get(j))){f=1;break;}
                    }
                    if(f==0){
                        stuList.add(t);
                        stucnt++;
                    }
                }else{
                    int f=0;
                    for(int j=0;j<empcnt;j++){
                        if(t.equals(empList.get(j))){f=1;break;}
                    }
                    if(f==0){
                        empList.add(t);
                        empcnt++;
                    }
                }
            }
            System.out.println("stuList");
            for(int i=0;i<stucnt;i++){
                System.out.println(stuList.get(i));
            }
            System.out.println("empList");
            for(int i=0;i<empcnt;i++){
                System.out.println(empList.get(i));
            }
        }
    }
}

7-8定义接口（Biology、Animal）、类（Person）、子类（Pupil）

（1）定义Biology（生物）、Animal（动物）2个接口，其中Biology声明了抽象方法breathe( )，Animal声明了抽象方法eat( )和sleep( )。
（2）定义一个类Person（人）实现上述2个接口，实现了所有的抽象方法，同时自己还有一个方法think( )。breathe()、eat()、sleep()、think()四个方法分别输出：
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考
（3）定义Person类的子类Pupil（小学生），有私有的成员变量school（学校），公有的成员方法setSchool( )、getSchool( )分别用于设置、获取学校信息。
（4）在测试类Main中，用Pupil类创建一个对象zhangsan。尝试从键盘输入学校信息给zhangsan，获取到该信息后输出该学校信息，格式为“我的学校是XXX”；依次调用zhangsan的breathe()、eat()、sleep()、think()方法。

输入格式:
从键盘输入一个学校名称（字符串格式）

输出格式:
第一行输出：我的学校是XXX（XXX为输入的学校名称）
第二行是breathe()方法的输出
第三行是eat()方法的输出
第四行是sleep()方法的输出
第五行是think()方法的输出

输入样例:
在这里给出一组输入。例如：

新余市逸夫小学

输出样例:
在这里给出相应的输出。例如：

我的学校是新余市逸夫小学
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考

import java.util.*;
interface Biology{
    public void breathe();
}
interface Animal{
    public void eat();
    public void sleep();
}
class Person implements Biology,Animal{
    public void breathe(){
        System.out.println("我喜欢呼吸新鲜空气");
    }
    public void eat(){
        System.out.println("我会按时吃饭");
    }
    public void sleep(){
        System.out.println("早睡早起身体好");
    }
    public void think(){
        System.out.println("我喜欢思考");
    }
}
class Pupil extends Person{
    private String school;
    public void setSchool(String sch){school=sch;}
    public String getSchool(){return school;}
}
public class Main{
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();;
        Pupil zhangsan=new Pupil();
        zhangsan.setSchool(str);
        System.out.println("我的学校是"+str);
        zhangsan.breathe();
        zhangsan.eat();
        zhangsan.sleep();
        zhangsan.think();
    }
}

7-9Employee类的层级结构

定义四个类，分别为Employee类、SalariedEmployee类、HourlyEmployee类和CommissionEmployee类。其中Employee类是其他三个类的父类。Employee类包含姓名和身份证号。除此之外，SalariedEmployee类还应包含每月工资；HourlyEmployee类还应包含每小时工资数和工作时间数；CommissionEmployee还应包含提成比例和销售总额。其中HourlyEmployee的工资为：每小时工资数×工作时间数，CommissionEmployee的工资为：提成比例×销售总额。每个类都应有合适的构造方法、数据成员的设置和读取方法。编写一个测试程序，创建这些类的对象，并输出与对象相关的信息。注意子类有时需调用父类的构造方法和被覆盖的方法，成员变量定义为private，对有些方法实现重载。
输入格式:
输入三行。第一行为一个SalariedEmployee对象的姓名，身份证号和每月工资。第二行为一个HourlyEmployee对象的姓名、身份证号、每小时工资数、工作时间。第三行为一个CommissionEmployee对象的姓名、身份证号、提成比例和销售总额。

输出格式:
输出三个对象的工资和对象的其他信息。每一个对象输出两行，第一行为工资，第二行为对象的信息。

输入样例:

Mike 0001 5000
Jack 0002 20 300
Tom 0003 0.2 50000

输出样例:

5000.0
SalariedEmployee[name=Mike,id=0001][monthSalary=5000.0]
6000.0
HourlyEmployee[name=Jack,id=0002][hourSalary=20.0,workhour=300.0]
10000.0
CommissionEmployee[name=Tom,id=0003][commissionRatio=0.2,sale=50000.0]

import java.util.*;
abstract class Employee{
    private String name,id;
    Employee(String a,String b){
        name=a;id=b;
    }
    public String toString(){return "name="+name+",id="+id;}
    public abstract double getSalary();
}
class SalariedEmployee extends Employee{
    private double salary;
    public SalariedEmployee(String a,String b,double c){
        super(a,b);
        salary=c;
    }
    public double getSalary(){return salary;}
        public String toString(){
        return "SalariedEmployee["+super.toString()+"][monthSalary="+salary+"]";
    }
}
class HourlyEmployee extends Employee{
    private double salary,hour;
    public HourlyEmployee(String a,String b,double c,double d){
        super(a,b);
        salary=c;
        hour=d;
    }
    public double getSalary(){return salary*hour;}
    public String toString(){
        return "HourlyEmployee["+super.toString()+"][hourSalary="+salary+",workhour="+hour+"]";
    }
}
class CommissionEmployee extends Employee{
    private double rate,sellVolume;
    public CommissionEmployee(String a,String b,double c,double d){
        super(a,b);
        rate=c;
        sellVolume=d;
    }
    public double getSalary(){return rate*sellVolume;}
    public String toString(){
        return "CommissionEmployee["+super.toString()+"][commissionRatio="+rate+",sale="+sellVolume+"]";
    }
}
public class Main{
    public static void main(String [] args){
       Scanner in=new Scanner(System.in);
       Employee [] e=new Employee[3];
       e[0]=new SalariedEmployee(in.next(),in.next(),in.nextDouble());
       e[1]=new HourlyEmployee(in.next(),in.next(),in.nextDouble(),in.nextDouble());
       e[2]=new CommissionEmployee(in.next(),in.next(),in.nextDouble(),in.nextDouble());
       for(int i=0;i<e.length;i++)
       {    
           System.out.println(e[i].getSalary());
           System.out.println(e[i]);
       }
    }
}