1、编写一个 Java 程序 , 程序中有一个父类 Telephone,Telephone 类中包含有电话品牌、电话号码、通话时间、费率等属性 , 以及计算话费和显示信息等方法。另外 , 程序中还有另一个类叫作 Mobilephone, 它是 Telephone 的子类 , 除了具有 Telephone 类的属性外 , 它还有自己的属性如网络类型、被叫时间 , 同时它有自己的计算话费和显示信息的方法。 最后程序中应包含一个主类来使用上述两个类并显示它们的信息。
实验步骤 :
(1) 仔细阅读程序清单 1-5, 完成代码1~代码5.
程序清单 1-5 Inheritance.java
class Telephone {
String brand, number;
double dialledTime;
double rate;
Telephone(String b, String n) {
brand = b;
number = n;
}
String getBrand( ) { return brand; }
String getNumber( ) { return number; }
代码1 //返回费率值
double getDialledTime( ) { return dialledTime; }
void setBrand(String b) {
brand = b;
}
void setNumber(String n) {
代码2 // 设置电话号码
}
void setRate(double r) {
rate = r;
}
void setDialledTime(double d) {
dialledTime = d;
}
double callCost( ) {
return dialledTime * rate;
}
void display( ) {
System.out.println("电话品牌: "+ brand +" 电话号码: "+ number);
System.out.println("通话时间: "+ dialledTime +" 费率: "+ rate);
System.out.println("话费: "+ callCost( ));
}
}
class Mobilephone extends Telephone {
String network;
double receivedTime;
Mobilephone(String b, String num, String net) {
super(b, num);
network = net;
}
String getNetwork( ) { return network; }
double getReceivedTime( ) { return receivedTime; }
void setNetwork(String n) {
network = n;
}
void setReceivedTime(double d) {
代码3 //设置被叫时间
}
double callCost( ) {
return (dialledTime + 0.5*receivedTime) * rate;
}
void display( ) {
System.out.println("电话品牌: "+ brand +" 电话号码: "+ number
+" 网络: "+ network);
System.out.println("主叫时间: "+ dialledTime +" 被叫时间: " +
receivedTime +" 费率: "+ rate);
System.out.println("话费: "+ callCost( ));
}
}
public class Inheritance {
public static void main(String[] args) {
Telephone tel;
Mobilephone mobile;
tel = new Telephone("TCL", "8309600");
mobile = new Mobilephone("Nokia", "13007091010","CDMA");
tel.setRate(0.2);
tel.setDialledTime(150);
mobile.setRate(0.4);
代码4 //设置主叫时间为80
mobile.setReceivedTime(120);
tel.display( );
System.out.println( );
代码5 //显示移动电话的信息
}
}
(2)编译运行程序, 观察程序运行结果。
思考
(1) 在 Mobilephone 类的 display() 方法中有如下语句 :
System.out.println(" 话费 :"+callcost());
试问这里调用的是子类自己的 callcost() 还是其父类的 callcost(); 如果想要在此处调用
父类的 callcost() 应如何处理。
(2) 子类 Mobilephone 的构造函数中有语句 super(b,num): 请指出该语句的作用。 然后请将该语句删除掉 , 编译运行程序 , 看看是否会出现编译错误 , 并分析原因。
事实上 , 如果在子类的构造函数中不显式地使用 super 来调用父类的构造函数的话 ,那么
系统将自动调用父类的无参或默认的构造函数。因此为了纠正这个错误 , 可试着在Telephone 类中加入一个无参的构造函数。
(3) 要调用父类的构造函数可以用 super 关键字 , 而要调用本类自己的构造函数可以用
this 关键字 , 请试着在 Telephone 类中加入一个构造函数如下 :
Telephone (String b ,String n,double r){
this(b,n);
rate =r;
}
然后在主程序中用这个构造函数来创建一个 Telephone 对象 , 看看它能否起作用。
class Telephone
{
String brand,number;//供应商，号码
double dialledTime;//通话时间
double rate;//每单位时间费用
Telephone(String b,String n)
{
brand = b;
number = n;
}
Telephone (String b ,String n,double r)
{
this(b,n);
rate =r;
}
String getBrand()
{
return brand;
}
String getNumber()
{
return number;
}
//代码1:返回费率值
double getRate()
{
return rate;
}
double getDialledTime()
{
return dialledTime;
}
void setBrand(String b)
{
brand = b;
}
void setNumber(String n)
{
//代码2：设置电话号码
number = n;
}
void setRate(double r)
{
rate = r;
}
void setDialledTime(double d)
{
dialledTime = d;
}
double callCost()
{
return dialledTime*rate;
}
void display()
{
System.out.println("电话品牌："+brand+"电话号码："+number);
System.out.println("通话时间:"+dialledTime+"费率："+rate);
System.out.println("话费："+callCost());
}
}
class Mobilephone extends Telephone
{
String network;//网络类型
double receivedTime;//被叫类型
Mobilephone(String b,String num,String net)
{
super(b,num);
network = net;
}
String getNetwork()
{
return network;
}
double getReceivedTime()
{
return receivedTime;
}
void setNetwork(String net)
{
network = net;
}
void setReceivedTime(double r)
{
//代码3:设置被叫时间
receivedTime = r;
}
double callCost()
{
return (dialledTime+0.5*receivedTime)*rate;
}
void display()
{
System.out.println("电话品牌: "+ brand +" 电话号码: "+ number +" 网络: "+ network);
System.out.println("主叫时间: "+ dialledTime +" 被叫时间: " + receivedTime +" 费率: "+ rate);
System.out.println("话费: "+ callCost());
}
}
public class Inheritance
{
public static void main(String[] args)
{
Telephone tel;
Mobilephone mobile;
tel = new Telephone("TCL","9309600");
mobile = new Mobilephone("Nokia","13007091010","CDMA");
tel.setRate(0.2);
tel.setDialledTime(150);
mobile.setRate(0.4);
//代码4 设置主叫时间为80
mobile.setDialledTime(80);
mobile.setReceivedTime(120);
tel.display();
System.out.println();
//代码5 显示移动电话的信息
mobile.display();
System.out.println();
Telephone newTel = new Telephone("TCL","9309601",0.2);
newTel.setDialledTime(150);
newTel.display();
}
}
2、请设计 3 个类 , 分别是学生类 Student, 本科生类 Undergaduate, 研究生类 Postgraduate,其中 Student 类是一个抽象类 , 它包含一些基本的学生信息如姓名、所学课程、课程成绩等 , 而Undergraduate 类和 Postgraduate 都是 Student 类的子类 , 它们之间的主要差别是计算课程成绩等级的方法有所不同 , 研究生的标准要比本科生的标准高一些 , 如表 1-2 所示。
表 1-2 课程成绩等级
| 本科生标准 |
研究生标准 |
||
| 80--100 |
优秀 |
90--100 |
优秀 |
| 70--80 |
良好 |
80--90 |
良好 |
| 60--70 |
一般 |
70--80 |
一般 |
| 50--60 |
及格 |
60--70 |
及格 |
| 50 以下 |
不及格 |
60 以下 |
不及格 |
假设某班级里既有本科生也有研究生 , 请编写程序统计出全班学生的成绩等级并显示出来。此题关键是设计一个学生数组 , 既能存放本科生对象 , 又能存放研究生对象。
实验步骤 :
仔细阅读程序清单,完成代码1~~代码5。
程序清单Polymorphism.java
abstract class Student {
final static int CourseNo = 3;
String name;
String type;
int[] courses;
String courseGrade;
public Student(String name) {
this.name = name;
courses = new int[CourseNo];
代码1 //初始化courseGrade为空串
}
public abstract void calculateGrade();
public String getName( ) {
return name;
}
public String getType( ) {
代码2 //返回学生类型
}
public String getCourseGrade( ) {
return courseGrade;
}
public int getCourseScore(int courseNumber) {
return courses[courseNumber];
}
public void setName(String name) {
this.name = name;
}
public void setType(String type) {
this.type = type;
}
public void setCourseScore(int courseNumber, int courseScore) {
代码3 //按课程索引号设置课程成绩
}
}
class Undergraduate extends Student {
public Undergraduate(String name ) {
super(name);
type = "本科生";
}
public void calculateGrade() {
int total = 0;
double average = 0;
for (int i = 0; i < CourseNo; i++) {
代码4 // 累加各门课程成绩
};
average = total / CourseNo;
if (average>=80&&average<100) courseGrade = "优秀";
else if (average>=70&&average<80) courseGrade = "良好";
else if (average>=60&&average<70) courseGrade = "一般";
else if (average>=50&&average<60) courseGrade = "及格";
else courseGrade = "不及格";
}
}
class Postgraduate extends Student {
public Postgraduate(String name) {
super(name);
type = "研究生";
}
public void calculateGrade() {
int total = 0;
double average = 0;
for (int i = 0; i < CourseNo; i++) {
total += courses[i];
};
average = total / CourseNo;
if (average>=90&&average<100) courseGrade = "优秀";
else if (average>=80&&average<90) courseGrade = "良好";
else if (average>=70&&average<80) courseGrade = "一般";
else if (average>=60&&average<70) courseGrade = "及格";
else courseGrade = "不及格";
}
}
public class Polymorphism {
public static void main(String[] args) {
Student[] students = new Student[5];
students[0] = new Undergraduate("陈建平");
students[1] = new Undergraduate("鲁向东");
students[2] = new Postgraduate("匡晓华");
students[3] = new Undergraduate("周丽娜");
代码5 // 创建姓名为梁欣欣的Postgraduate对象students[4]
for (int i=0; i<5 ;i++) {
students[i].setCourseScore(0,87);
students[i].setCourseScore(1,90);
students[i].setCourseScore(2,78);
}
for (int i=0; i<5 ;i++) {
students[i].calculateGrade();
}
System.out.println("姓名" + " 类型" +" 成绩");
System.out.println("-----------------------");
for (int i=0; i<5 ;i++) {
System.out.println(students[i].getName( )+" "+
students[i].getType( )+" "+
students[i].getCourseGrade( ));
}
}
}
思考
(l) 在 Polymorphism 类中有一个循环语句用来计算每个学生的成绩等级
for(int i=0;i<5;i 十 +){
student[i].calculateGrade();
}
请问这里的 calculateGrade() 方法是按照研究生的标准还是按照本科生的标准来计算的。
(2) 现在请在程序 Polymorphism 类的 main() 方法中添加如下的语句
Student st=new Student (" 李明 ");
此时编译是否会报错 , 如有错误 , 请解释原因。
(3) 在程序中要判断 student[i] 中存放的究竟是 Undergraduate 对象还是 Postgraduate对象 , 只需要调用 student[i].getType() 方法即可 , 然而 Java 提供了一个 instanceof 运算也可以完成这一任务 , 它能判断出一个对象所属的类 , 请将以下代码添加到程序中进行测试。
for (int i=0;i<5;i++){
If(students[i] instanceof Undergraduate)
system-out-printlII(students[i].getName()+" 是本科生 ");
else
System-out-println(students[i]-getName()+" 是研究生 ");
(4)现在请模仿本程序 , 新增一个高中生类 , 它计算成绩等级的标准采用如下方法 , 然后
在主程序中测试并使用它。
80~100 好
60~80 中
60 以下 差
abstract class Student
{
final static int CourseNo = 3;
String name;
String type;
int [] courses;
String courseGrade;
public Student(String name)
{
this.name = name;
courses = new int[CourseNo];
//代码1：初始化courseGrade为空串
courseGrade="";
}
public abstract void calculateGrade();
public String getName()
{
return name;
}
public String getType()
{
//代码2 返回学生类型
return type;
}
public String getCourseGrade()
{
return courseGrade;
}
public int getCourseScore(int courseNumber)
{
return courses[courseNumber];
}
public void setName(String name)
{
this.name = name;
}
public void setType(String type)
{
this.type = type;
}
public void setCourseScore(int courseNumber,int courseScore)
{
//代码3 按课程索引号设置课程成绩
courses[courseNumber]=courseScore;
}
}
class Undergraduate extends Student
{
public Undergraduate(String name)
{
super(name);
type = "本科生";
}
public void calculateGrade()
{
int total = 0;
double average = 0;
for(int i=0;i<CourseNo;i++)
{
total += courses[i];
}
average = total/CourseNo;
if (average>=80&&average<100) courseGrade = "优秀";
else if (average>=70&&average<80) courseGrade = "良好";
else if (average>=60&&average<70) courseGrade = "一般";
else if (average>=50&&average<60) courseGrade = "及格";
else courseGrade = "不及格";
}
}
class Postgraduate extends Student
{
public Postgraduate(String name)
{
super(name);
type = "研究生" ;
}
public void calculateGrade()
{
int total = 0;
double average = 0;
for (int i=0;i<CourseNo;i++)
{
total += courses[i];
}
average = total/CourseNo;
if (average>=90&&average<100) courseGrade = "优秀";
else if (average>=80&&average<90) courseGrade = "良好";
else if (average>=70&&average<80) courseGrade = "一般";
else if (average>=60&&average<70) courseGrade = "及格";
else courseGrade = "不及格";
}
}
class SeniorStudent extends Student
{
SeniorStudent(String name)
{
super(name);
type="高中生";
}
public void calculateGrade()
{
int total = 0;
double average = 0;
for (int i=0;i<CourseNo;i++)
{
total += courses[i];
}
average = total/CourseNo;
if (average>=80&&average<100) courseGrade = "好";
else if (average>=60&&average<80) courseGrade = "中";
else courseGrade = "差";
}
}
public class Polymorphism
{
public static void main(String[] args)
{
Student[] students = new Student[5];
Student[] _students = new Student[2];
students[0] = new Undergraduate("陈建平");
students[1] = new Undergraduate("鲁向东");
students[2] = new Postgraduate("匡晓华");
students[3] = new Undergraduate("周丽娜");
// 代码5 创建姓名为梁欣欣的Postgraduate对象students[4]
students[4] = new Postgraduate("梁欣欣");
_students[0] = new SeniorStudent("王功胜");
_students[1] = new SeniorStudent("瓦妮达");
for (int i=0;i<5;i++)
{
students[i].setCourseScore(0,87);
students[i].setCourseScore(1,90);
students[i].setCourseScore(2,78);
}
for(int i=0;i<2;i++)
{
_students[i].setCourseScore(0,87);
_students[i].setCourseScore(1,30);
_students[i].setCourseScore(2,78);
}
for (int i=0;i<5;i++)
{
students[i].calculateGrade();
}
for (int i=0;i<2;i++)
{
_students[i].calculateGrade();
}
System.out.println("姓名" + " 类型" +" 成绩");
System.out.println("-----------------------");
for (int i=0; i<5 ;i++)
{
System.out.println(students[i].getName( )+" "+students[i].getType( )+" "+students[i].getCourseGrade( ));
}
for (int i=0;i<2; i++)
{
System.out.println(_students[i].getName( )+" "+_students[i].getType( )+" "+_students[i].getCourseGrade( ));
}
//Student st = new Student("李明");
System.out.println();
for(int i=0;i<5;i++)
{
if(students[i] instanceof Undergraduate )
{
System.out.println(students[i].getName()+"是本科生");
}
else
{
System.out.println(students[i].getName()+"是研究生");
}
}
}
}
3、分别编写四个类Point，Point2D，Point3D，Test来表示一维、二维和三维的点及测试类，使之满足下列要求：
(1) Point类的成员变量和成员方法如下所示：
成员变量 int x；
成员方法 ①构造函数Point（int x），实现对成员变量x的初始化
② void offset(int a)实现对一维点x坐标的平移
③ double distance（Point p）计算当前点到一维点p的距离
(2) Point2D类是Point类的直接子类，其成员变量和成员方法如下所示：
成员变量 int x，y；(分别为二维空间的X,Y方向坐标)，x可从父类继承。
成员方法 ①构造函数Point2D（int x, int y），实现对成员变量x，y的初始化，可先调用父类的构造函数super（x），实现对x坐标的初始化。
② void offset(int a, int b)实现对二维点坐标的平移，可先调用父类的offset函数实现对x坐标的平移。
③ double distance（Point p）覆盖父类的距离函数，计算当前点到二维点p的距离
(3) Point3D类是Point2D类的直接子类，其成员变量和成员方法如下所示：
成员变量 int x，y，z；(分别为三维空间的X,Y,Z方向坐标)，x，y可从父类继承。
成员方法 ①构造函数Point3D（int x, int y,int z），实现对成员变量x，y，z的初始化，可先调用父类的构造函数super（x,y），实现对x ，y坐标的初始化。
② void offset(int a, int b,int c)实现对三维点坐标的平移，可先调用父类的offset函数实现对x，y坐标的平移。
③ double distance（Point p）覆盖父类的距离函数，计算当前点到三维点p的距离
(4)在测试类Test的主函数main()中实例化两个Point2D的对象p2d1，p2d2，打印出它们之间的距离，再实例化两个Point3D的对象p3d1，p3d2，打印出他们之间的距离。
import static java.lang.Math.abs;
import static java.lang.Math.sqrt;
import java.util.Scanner;
class Point
{
int x;
Point(int x)
{
this.x=x;
}
void offset(int a)
{
x+=a;
}
double distance(Point p)
{
return abs(p.x-x);
}
public String toString() //便于输出
{
return "("+x+")";
}
}
class Point2D extends Point
{
int y;
Point2D(int x,int y)
{
super(x);
this.y=y;
}
void offset(int a,int b)
{
super.offset(a);
y+=b;
}
double distance(Point2D p)
{
return sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
}
public String toString() //便于输出
{
return "("+x+","+y+")";
}
}
class Point3D extends Point2D
{
int z;
Point3D(int x,int y,int z)
{
super(x,y);
this.z = z;
}
void offset(int a,int b,int c)
{
super.offset(a,b);
z+=c;
}
double distance(Point3D p)
{
return sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y)+(z-p.z)*(z-p.z));
}
public String toString() //便于输出
{
return "("+x+","+y+","+z+")";
}
}
public class Test{
public static void main(String[] args)
{
Point2D p2d1 = new Point2D(0,0);
Point2D p2d2 = new Point2D(3,4);
System.out.println(p2d1.toString()+"和"+p2d2.toString()+"之间的距离为："+p2d1.distance(p2d2));
System.out.println("移动之后：");
p2d1.offset(3,3);
p2d2.offset(2,1);
System.out.println(p2d1.toString()+"和"+p2d2.toString()+"之间的距离为："+p2d1.distance(p2d2));
Point3D p3d1 = new Point3D(0,0,0);
Point3D p3d2 = new Point3D(0,3,4);
System.out.println(p3d1.toString()+"和"+p3d2.toString()+"之间的距离为："+p3d1.distance(p3d2));
System.out.println("移动之后：");
p3d1.offset(1,2,3);
p3d2.offset(3,2,1);
System.out.println(p3d1.toString()+"和"+p3d2.toString()+"之间的距离为："+p3d1.distance(p3d2));
System.out.println();
System.out.println("等待输入：<0>退出，<1>输入两个2D点计算距离,<2>输入两个3D点计算距离");
Scanner scanner = new Scanner(System.in);
int input = scanner.nextInt();
switch(input)
{
case 0: break;
case 1:
int[] data1 = new int[4];
System.out.println("请输入4个整数，表示两个2D点的坐标，中间用空格间隔：");
for (int i=0;i<4;i++)
{
data1[i]=scanner.nextInt();
}
Point2D p1 = new Point2D(data1[0],data1[1]);
Point2D p2 = new Point2D(data1[2],data1[3]);
System.out.println(p1.toString()+"和"+p2.toString()+"之间的距离为："+p1.distance(p2));
break;
case 2:
int[] data2 = new int[6];
System.out.println("请输入6个整数，表示两个3D点的坐标，中间用空格间隔：");
for(int i=0;i<6;i++)
{
data2[i]=scanner.nextInt();
}
Point3D p3 = new Point3D(data2[0],data2[1],data2[2]);
Point3D p4 = new Point3D(data2[3],data2[4],data2[5]);
System.out.println(p3.toString()+"和"+p4.toString()+"之间的距离为："+p3.distance(p4));
break;
}
}
}4、设计一个人员类（Person），以及从Person类派生出助教类（Assistant）、讲师类（Instructor）、副教授类（AssistantProfesson）和教授类（Professor）。四种类型教师的工资收入计算公式如下：
工资收入＝基本工资＋授课时数×每课时报酬
其中，助教基本工资为800元，每课时报酬25元，讲师基本工资为1000元，每课时报酬35元，副教授基本工资为1200元，每课时报酬40元，教授基本工资为1400元，每课时报酬50元。
将人员类定义为抽象类，具体定义如下：
abstract class Person {
String name;
double salary; //工资收入
int hour; //课时
abstract double countSalary(int hour);//计算工资收入
abstract public String toString();//返回员工的姓名、职称、收入字符串
abstract public boolean equals(Person p);//与另一员工比较职称及工资收入是否一样
}
请为四种类型教师自行设计合理的类，但必须继承自Person类，另编写一个测试类测试你所编写的类，要求输入两个员工的姓名，职称和授课时数后分别显示他们的姓名、职称、收入，并比较两人职称及工资收入是否一样。
import java.util.Scanner;
abstract class Person
{
String name;
double salary;
int hour;
abstract double countSalary(int hour);
abstract public String toString();
abstract public boolean equals(Person p);
}
class Assistant extends Person
{
Assistant(String name,int hour)
{
this.name = name;
this.hour = hour;
salary = 800;
}
double countSalary(int hour)
{
return salary+hour*25;
}
public String toString()
{
return "姓名："+name+"\t职称:助教"+"\t收入："+countSalary(hour);
}
public boolean equals(Person p)
{
if((p instanceof Assistant) && (countSalary(hour)==p.countSalary(p.hour)))
{
return true;
}
else
{
return false;
}
}
}
class Instructor extends Person
{
Instructor(String name,int hour)
{
this.name = name;
this.hour = hour;
salary = 1000;
}
double countSalary(int hour)
{
return salary+hour*35;
}
public String toString()
{
return "姓名："+name+"\t职称：讲师"+"\t收入："+countSalary(hour);
}
public boolean equals(Person p)
{
if((p instanceof Instructor)&&(countSalary(hour)==p.countSalary(p.hour)))
{
return true;
}
else
{
return false;
}
}
}
class AssistantProfesson extends Person
{
AssistantProfesson(String name,int hour)
{
this.name = name;
this.hour = hour;
salary = 1200;
}
double countSalary(int hour)
{
return salary+hour*40;
}
public String toString()
{
return "姓名："+name+"\t职称：副教授"+"\t收入："+countSalary(hour);
}
public boolean equals(Person p)
{
if((p instanceof AssistantProfesson)&&(countSalary(hour)==p.countSalary(p.hour)))
{
return true;
}
else
{
return false;
}
}
}
class Professor extends Person
{
Professor(String name,int hour)
{
this.name = name;
this.hour = hour;
salary = 1400;
}
double countSalary(int hour)
{
return salary+hour*50;
}
public String toString()
{
return "姓名："+name+"\t职称：教授"+"\t收入："+countSalary(hour);
}
public boolean equals(Person p)
{
if((p instanceof Professor)&&(countSalary(hour)==p.countSalary(p.hour)))
{
return true;
}
else
{
return false;
}
}
}
public class MainClass
{
public static void main(String[] args)
{
System.out.println("请输入两个人信息（每一次输入需要换行）：");
String name1,name2;
int hour1,hour2;
String job1,job2;//职称
Scanner scanner = new Scanner(System.in);
name1 = scanner.next();
job1 = scanner.next();
//读取一个int类型数值
while (true) {
try {
hour1 = scanner.nextInt();
break;
} catch (Exception e) {
scanner = new Scanner(System.in);
}
}
//System.out.println(name1+job1+hour1);
name2 = scanner.next();
job2 = scanner.next();
while (true) {
try {
hour2 = scanner.nextInt();
break;
} catch (Exception e) {
scanner = new Scanner(System.in);
}
}
//System.out.println(name2+job2+hour2);
Person person1,person2;
if(job1.equals("助教"))
{
person1 = new Assistant(name1,hour1);
}
else if(job1.equals("讲师"))
{
person1 = new Instructor(name1,hour1);
}
else if(job1.equals("副教授"))
{
person1 = new AssistantProfesson(name1,hour1);
}
else
{
person1 = new Professor(name1,hour1);
}
if(job2.equals("助教"))
{
person2 = new Assistant(name2,hour2);
}
else if(job2.equals("讲师"))
{
person2 = new Instructor(name2,hour2);
}
else if(job2.equals("副教授"))
{
person2 = new AssistantProfesson(name2,hour2);
}
else {
person2 = new Professor(name2, hour2);
}
System.out.println();
System.out.println(person1.toString());
System.out.println(person2.toString());
boolean same = person1.equals(person2);
if(same==true)
{
System.out.println("两个人职称和工资收入相同");
}
else
{
System.out.println("两个人职称和工资收入不同");
}
}
}