1. 练习1 342
定义一个Person类 {name, age, job}, 初始化Person 对象数组，有3个person对象，
并按照 age 从 大到 小进行排序, 提示，使用冒泡排序
代码在com.stulzl.exercise01.包中
Exercise01
package com.stulzl.exercise01;
//定义一个Person类 {name, age, job}, 初始化Person 对象数组，有3个person对象，
//并按照 age 从 大到 小进行排序, 提示，使用冒泡排序 342
public class Exercise01 {
public static void main(String[] args) {
//初始化Person 对象数组，有3个person对象
Person[] person=new Person[3];
person[0]=new Person("jack",10,"javaEE工程师");
person[1]=new Person("tom",50,"大数据工程师");
person[2]=new Person("mary",30,"PHP工程师");
//输出当前数组
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);//默认对象的，toString()
}
//使用冒泡排序
Person tmp = null;//临时变量，用于交换
for (int i = 0; i < person.length-1; i++) {//趟数
for(int j=0;j<person.length-1-i;j++){//交换
//并按照 age 从 大到 小进行排序,如果前面人的age<后面人的age,就交换
//扩展要是按照名字的长度排person[i].getName().length
if(person[i].getAge()< person[i+1].getAge()){
tmp=person[i];
person[i]=person[i+1];
person[i+1]=tmp;
}
}
}
//排序后
System.out.println("====================");
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);//默认对象的，toString()
}
}
}
class Person{
private String name;
private int age;
private String job;
public Person(String name, int age, String job) {
this.name = name;
this.age = age;
this.job = job;
}
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 String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
@Override
public String toString() {//可以输出对象属性值
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", job='" + job + '\'' +
'}';
}
}2. 练习2 343
写出四种访问修饰符和各自的访问权限
3. 练习3 344
编写老师类
(1)要求有属性“姓名name”，“年龄age”,“职称post”,“基本工资salary”
2）编写业务方法， introduce（），实现输出一个教师的信息。
(3) 编写教师类的三个子类：教授类、副教授类、讲师类。工资级别分别为：教授为1.3、副教授为1.2、讲师类1.1。在三个子类里面都重写父类的introduce（)方法。
(4)定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印.
代码在com.stulzl.exercise03.包中
测试Exercise03
package com.stulzl.exercise03;
//编写老师类
//(1)要求有属性“姓名name”，“年龄age”,“职称post”,“基本工资salary”
//(2)编写业务方法，introduce（），实现输出一个教师的信息。
//(3) 编写教师类的三个子类：教授类、副教授类、讲师类。工资级别分别为：
// 教授为1.3、副教授为1.2、讲师类1.1。在三个子类里面都重写父类的introduce()方法。
//(4)定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印.
public class Exercise03 {
public static void main(String[] args) {
Professor teacher1 = new Professor("jack",18,"教授",3000,1.3);
teacher1.introduce();
fProfessor teacher2 = new fProfessor("tom", 20, "副教授", 2500, 1.2);
teacher2.introduce();
Lecturer teacher3 = new Lecturer("king", 25, "讲师", 1500, 1.1);
teacher3.introduce();
}
}父类Teacher
package com.stulzl.exercise03;
public class Teacher {//父类
//属性“姓名name”，“年龄age”,“职称post”,“基本工资salary”
private String name;
private int age;
private String post;
private double salary;
private double grade;//我们还分析出每个人都有工资级别
public Teacher(String name, int age, String post, double salary, double grade) {
this.name = name;
this.age = age;
this.post = post;
this.salary = salary;
this.grade = grade;
}
//(2)编写业务方法，introduce（），实现输出一个教师的信息。
public void introduce(){
System.out.println("姓名="+name+" 年龄="+age+" 职位="+post+
" 薪水="+salary+" 级别="+grade);
}
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 String getPost() {
return post;
}
public void setPost(String post) {
this.post = post;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}
// //如果不理解将grade写在父类中请看这种分开写的方法2
// private String name;
// private int age;
// private String post;
// private double salary;
//
// public Teacher(String name, int age, String post, double salary) {
// this.name = name;
// this.age = age;
// this.post = post;
// this.salary = salary;
// }
//
// public void introduce(){
// System.out.println("姓名="+name+" 年龄="+age+" 职位="+post+
// " 薪水="+salary);
// }
// 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 String getPost() {
// return post;
// }
//
// public void setPost(String post) {
// this.post = post;
// }
//
// public double getSalary() {
// return salary;
// }
//
// public void setSalary(double salary) {
// this.salary = salary;
// }
}子类Professor
package com.stulzl.exercise03;
public class Professor extends Teacher {//子类
public Professor(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
//教授为1.3、副教授为1.2、讲师类1.1,子类里面都重写父类的introduce()方法。
public void introduce(){
System.out.println("这是教授信息");
super.introduce();
}
// //方法2
// private double grade;
//
// public Professor(String name, int age, String post, double salary, double grade) {
// super(name, age, post, salary);
// this.grade = grade;
// }
//
// public double getGrade() {
// return grade;
// }
//
// public void setGrade(double grade) {
// this.grade = grade;
// }
//
// public void introduce(){
// super.introduce();
// System.out.println(" 级别="+grade);
// }
}子类fProfessor
package com.stulzl.exercise03;
public class fProfessor extends Teacher {
public fProfessor(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
//教授为1.3、副教授为1.2、讲师类1.1,子类里面都重写父类的introduce()方法。
public void introduce(){
System.out.println("这是副教授信息");
super.introduce();
}
// //方法2
// private double grade;
//
// public fProfessor(String name, int age, String post, double salary, double grade) {
// super(name, age, post, salary);
// this.grade = grade;
// }
//
// public double getGrade() {
// return grade;
// }
//
// public void setGrade(double grade) {
// this.grade = grade;
// }
// public void introduce(){
// super.introduce();
// System.out.println(" 级别="+grade);
// }
}子类Lecturer
package com.stulzl.exercise03;
public class Lecturer extends Teacher {//子类
public Lecturer(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
//教授为1.3、副教授为1.2、讲师类1.1,子类里面都重写父类的introduce()方法。
public void introduce(){
System.out.println("这是讲师信息");
super.introduce();
}
// //方法2
// private double grade;
//
// public Lecturer(String name, int age, String post, double salary, double grade) {
// super(name, age, post, salary);
// this.grade = grade;
// }
//
// public double getGrade() {
// return grade;
// }
//
// public void setGrade(double grade) {
// this.grade = grade;
// }
// public void introduce(){
// super.introduce();
// System.out.println(" 级别="+grade);
// }
}4. 练习4 345
4.通过继承实现员工工资核算打印功能
父类：员工类
子类：部门经理类、普通员工类
(1）部门经理工资=1000+单日工资*天数*等级（1.2）
(2）普通员工工资=单日工资*天数*等级（1.0）
(3) 员工属性：姓名，单日工资，工作天数
(4) 员工共方法（打印工资）
(5) 普遍员工及部门经理都是员工子类，需要重写打印工资方法。
(6)定义并初始化普通员工对象，调用打印工资方法输出工资，定义并初始化部门经理对象，调用打印工资方法输出工资
代码在com.stulzl.exercise04.包中
测试Exercise04
package com.stulzl.exercise04;
//通过继承实现员工工资核算打印功能 345
//父类：员工类
//子类：部门经理类、普通员工类
//(1）部门经理工资=1000+单日工资*天数*等级（1.2）
//(2）普通员工工资=单日工资*天数*等级（1.0）
//(3) 员工属性：姓名，单日工资，工作天数
//(4) 员工共方法（打印工资）
//(5) 普遍员工及部门经理都是员工子类，需要重写打印工资方法。
//(6)定义并初始化普通员工对象，调用打印工资方法输出工资，定义并初始化部门经理对象，调用打印工资方法输出工资
public class Exercise04 {
public static void main(String[] args) {
//普通员工
Worker worker = new Worker("jack",100,30,1.0);
worker.print();
//经理
Manager manager = new Manager("king",200,30,1.2,1000);
manager.print();
}
}父类 Employee
package com.stulzl.exercise04;
public class Employee {//父类
//员工属性：姓名，单日工资，工作天数
private String name;
private double salary;
private int days;
//我们分析出每种员工都有等级grade
private double grade;
public Employee(String name, double salary, int days, double grade) {
this.name = name;
this.salary = salary;
this.days = days;
this.grade = grade;
}
//返回信息
public void mess(){
System.out.print("姓名="+name+" 工作天数="+days);
}
//打印工资
public void print(){
System.out.println(" 工资="+salary*days*grade);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public int getDays() {
return days;
}
public void setDays(int days) {
this.days = days;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}
}子类Worker
package com.stulzl.exercise04;
public class Worker extends Employee{//子类
//普通员工没有特有属性，直接生成构造器
public Worker(String name, double salary, int days, double grade) {
super(name, salary, days, grade);
}
//打印员工信息，普通员工工资=单日工资*天数*等级（1.0）
public void print(){
System.out.println("这是普通员工工资信息~");
super.mess();
//普通员工可以直接引用父类print
super.print();
}
}子类Manager
package com.stulzl.exercise04;
public class Manager extends Employee{//子类
//分析得出经理的1000为奖金，特有属性
private double bonus;
public Manager(String name, double salary, int days, double grade, double bonus) {
super(name, salary, days, grade);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
//打印员工信息，部门经理工资=1000+单日工资*天数*等级（1.2）
public void print(){
System.out.println("这是经理工资信息~");
super.mess();
//因为经理工资带奖金我们没办法直接引用父类print
//所以我们重写一个
System.out.println(" 工资="+(bonus+getSalary()*getDays()*getGrade()));
}
}5. 练习5 346
5.设计父类一员工类。子类：工人类,农民类，教师类，科学家类，服务生类。
（1）其中工人，农民，服务生只有基本工资
（2）教师除基本工资外，还有课酬（元/天)
（3)科学家除基本工资外，还有年终奖
(4)编写一个测试类,将各种类型的员工的全年工资打印出来
代码在com.stulzl.exercise05.包中
测试Exercose05
package com.stulzl.exercise05;
//设计父类一员工类。子类：工人类,农民类，教师类，科学家类，服务生类。
//(1)其中工人，农民，服务生只有基本工资
//(2)教师除基本工资外，还有课酬（元/天)
//(3)科学家除基本工资外，还有年终奖
//(4)编写一个测试类,将各种类型的员工的全年工资打印出来
public class Exercise05 {
public static void main(String[] args) {
Worker jack = new Worker("jack", 10000);
//jack.setMonth(10);//灵活修改带薪月份
jack.printSal();
Farmer smith = new Farmer("smith", 20000);
smith.printSal();
Teacher king = new Teacher("king", 2000);
king.setClassDay(360);
king.setCourseCost(1000);
king.printSal();
Scientist scientist = new Scientist("钟南山", 20000);
scientist.setBonus(2000000);
scientist.printSal();
Waiter waiter = new Waiter("july",3000);
waiter.printSal();
}
}父类Employee
package com.stulzl.exercise05;
public class Employee {//父类
//经分析共同属性，员工名称，基本工资,一年有几个月
private String name;
private double salary;
private int month=12;
//因为各公司年薪月份不一样有12薪，13，14等，所以我们不屑带月份的构造器，可以通过setMonth设置月份
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
//返回工资信息
public void printSal(){
System.out.println("姓名="+name+" 工资="+salary*month);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
}子类Teacher
package com.stulzl.exercise05;
public class Teacher extends Employee{//子类
//教师除基本工资外，还有课酬（元/天)
//老师特有属性，课酬CourseCost,classsDay
private double CourseCost;//课酬
private int classDay;//上课天数
//课酬，上课天数可以通过set,get方法得到
public Teacher(String name, double salary) {
super(name, salary);
}
//打印老师工资信息
public void printSal(){
System.out.println("这是老师工资信息");
System.out.println("姓名="+getName()+" 工资="+(getSalary()*getMonth()
+CourseCost*classDay));
}
public double getCourseCost() {
return CourseCost;
}
public void setCourseCost(double courseCost) {
CourseCost = courseCost;
}
public int getClassDay() {
return classDay;
}
public void setClassDay(int classDay) {
this.classDay = classDay;
}
}子类Scientist
package com.stulzl.exercise05;
public class Scientist extends Employee{//子类
//科学家除基本工资外，还有年终奖
//科学家特有属性年终奖bonus
private double bonus;
//年终奖不固定也可以通过set，get得到
public Scientist(String name, double salary) {
super(name, salary);
}
//打印科学家工资信息
public void printSal(){
System.out.println("这是科学家工资信息");
System.out.println("姓名="+getName()+" 工资="+(getSalary()*getMonth()+bonus));
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}子类Worker
package com.stulzl.exercise05;
public class Worker extends Employee{//子类
//工人没有特有属性，直接写构造器
public Worker(String name, double salary) {
super(name, salary);
}
//打印工人工资信息
public void printSal(){
System.out.println("这是工人工资信息");
super.printSal();
}
}子类Farmer
package com.stulzl.exercise05;
public class Farmer extends Employee{//子类
//农民没有特有属性，直接写构造器
public Farmer(String name, double salary) {
super(name, salary);
}
//打印农民工资信息
public void printSal(){
System.out.println("这是农民工资信息");
super.printSal();
}
}子类Waiter
package com.stulzl.exercise05;
public class Waiter extends Employee{
//服务员没有特有属性，直接写构造器
public Waiter(String name, double salary) {
super(name, salary);
}
//打印服务员工资信息
public void printSal(){
System.out.println("这是服务员工资信息");
super.printSal();
}
}6. 练习6 347
6.假定Grand、Father 和 Son 在同一个包，问：在父类和子类中通过this和super都可以调用哪些属性和方法
黄色为答案
特别说明
