【韩顺平零基础学java】第8章课后题
第一题
package HomeWork;
public class HomeWork01 {
//初始化一个数组\
public static void main(String[] args) {
Person[] person = new Person[3];
person[0] = new Person("mary",30, "PHP工程师");
person[1] = new Person("tom",50, "大数据工程师");
person[2] = new Person("smith",10, "JavaEE工程师");
// for (int i =0;i< person.length;i++){
// System.out.println(person[i]);
// }
Person temp = null;
//使用冒泡排序
for(int i = 0;i< person.length-1;i++){
for(int j =0;j< person.length-1-i;j++){
if(person[j].getName().length()>person[j+1].getName().length()){
temp = person[j];
person[j] = person[j+1];
person[j+1] = temp;
}
}
}
for(int i = 0;i< person.length;i++){
System.out.println(person[i]);
}
}
}
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 + '\'' +
'}';
}
}
第二题
第三题
- homework03.java
package HomeWork.HomeWork03;
public class HomeWork03 {
public static void main(String[] args) {
Professor professor[] = new Professor[3];
Professor professor1 = new Professor("tom", 30, "教授", 300000, 1.3);
Professor professor2 = new Professor("jerry", 23, "副教授", 200000, 1.2);
Professor professor3 = new Professor("spike", 28, "讲师", 100000, 1.1);
professor1.introduce();
professor2.introduce();
professor3.introduce();
}
}
- teacher.java
package HomeWork.HomeWork03;
public class Teacher{
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;
}
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;
}
public void introduce(){
System.out.println("name =" + getName()+"age = "+getAge() + "post="+getPost()+"salary = "+getSalary()+"grade="+getGrade());
}
}
- Professor
package HomeWork;
public class Professor extends Teacher{
public Professor(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
@Override
public void introduce() {
System.out.println("这是教授的信息");
super.introduce();
}
}
- Lecture
package HomeWork;
public class Lecturer extends Teacher{
public Lecturer(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
@Override
public void introduce() {
System.out.println("这是讲师的信息");
super.introduce();
}
}
- associate.java
package HomeWork.HomeWork03;
public class associate extends Teacher{
public associate(String name, int age, String post, double salary, double grade) {
super(name, age, post, salary, grade);
}
@Override
public void introduce() {
System.out.println("这是副教授的信息");
super.introduce();
}
}
第四题
- HomeWork04
public class Homework04 {
public static void main(String[] args) {
Manager manage = new Manager("刘备", 100, 20, 1.2);
//设置奖金
manage.setBonus(3000);
//打印经理的工资情况
manage.printSal();
Worker worker = new Worker("关羽",50, 10, 1.0);
worker.printSal();
}
}
- Employee
package com.hspedu.homework;
import java.sql.SQLOutput;
public class Employee {
//属性
//员工属性：姓名，单日工资，工作天数
private String name;
private double daySal;
private int workDays;
//分析出还有一个属性等级
private double grade;
//方法[构造器，getter 和 setter]
//打印工资方法
//方法 void printSal() {}
public void printSal() {
System.out.println(name + " 工资=" + daySal * workDays * grade);
}
public Employee(String name, double daySal, int workDays, double grade) {
this.name = name;
this.daySal = daySal;
this.workDays = workDays;
this.grade = grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getDaySal() {
return daySal;
}
public void setDaySal(double daySal) {
this.daySal = daySal;
}
public int getWorkDays() {
return workDays;
}
public void setWorkDays(int workDays) {
this.workDays = workDays;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}
}
- Manager
package com.hspedu.homework;
public class Manager extends Employee {
//特有属性
private double bonus;
//创建Manager对象时，奖金是多少并不是确定的，因为老师在构造器中，不给bonus
//,可以通过setBonus
public Manager(String name, double daySal, int workDays, double grade) {
super(name, daySal, workDays, grade);
}
//方法:重写父类的 printSal
@Override
public void printSal() {
//因为经理的工资计算方式和Employee不一样，所以我们重写
System.out.println("经理 " + getName() + " 工资是="
+ (bonus + getDaySal() * getWorkDays() * getGrade()));
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
- Worker
package com.hspedu.homework;
public class Worker extends Employee{
//分析普通员工没有特有的属性
public Worker(String name, double daySal, int workDays, double grade) {
super(name, daySal, workDays, grade);
}
//重写printSal
//因为普通员工和Employee输出工资情况一下，所以直接调用父类的printSal()
@Override
public void printSal() {
System.out.print("普通员工 ");//自己的输出信息
super.printSal();//调用父类的方法，复用代码
}
}
第五题
- HomeWork05
package com.hspedu.homework.homework5;
public class Homework05 {
public static void main(String[] args) {
Worker jack = new Worker("jack", 10000);
jack.setSalMonth(15);//灵活额修改带薪月份
jack.printSal();
Peasant smith = new Peasant("smith", 20000);
smith.printSal();
//老师测试
Teacher teacher = new Teacher("顺平", 2000);
//老师有课时费
teacher.setClassDays(360);
teacher.setClassSal(1000);
teacher.printSal();
//科学家
Scientist scientist = new Scientist("钟南山", 20000);
scientist.setBonus(2000000);
scientist.printSal();
}
}
- Employee
package com.hspedu.homework.homework5;
public class Employee { //父类
//属性
//分析有一个带薪的月份 13 , 15, 12
private String name;
private double sal;
private int salMonth = 12;
//方法
//打印全年工资
public void printSal() {
System.out.println(name + " 年工资是: " + (sal * salMonth));
}
public Employee(String name, double sal) {
this.name = name;
this.sal = sal;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public int getSalMonth() {
return salMonth;
}
public void setSalMonth(int salMonth) {
this.salMonth = salMonth;
}
}
- Peasant
package com.hspedu.homework.homework5;
public class Peasant extends Employee {//子类
//属性
//农民,服务生只有基本工资 sal
//方法
public Peasant(String name, double sal) {
super(name, sal);
}
//年工资
@Override
public void printSal() {
System.out.print("农民 ");
super.printSal();
}
}
- Worker
package com.hspedu.homework.homework5;
public class Worker extends Employee{ //子类
//属性
//工人,农民,服务生只有基本工资 sal
public Worker(String name, double sal) {
super(name, sal);
}
//方法
@Override
public void printSal() {
System.out.print("工人 ");
super.printSal();//使用父类的printSal()
}
}
- Teacher
package com.hspedu.homework.homework5;
public class Teacher extends Employee{//子类
//特有属性
private int classDays; //一年上课次数
private double classSal; //课时费
public Teacher(String name, double sal) {
super(name, sal);
}
//方法-重写printSal
@Override
public void printSal() { //老师不能使用super.printSal()
System.out.print("老师 ");
System.out.println(getName() + " 年工资是: "
+ (getSal() * getSalMonth() + classDays * classSal ));
}
public int getClassDays() {
return classDays;
}
public void setClassDays(int classDays) {
this.classDays = classDays;
}
public double getClassSal() {
return classSal;
}
public void setClassSal(double classSal) {
this.classSal = classSal;
}
}
- Scientist
package com.hspedu.homework.homework5;
public class Scientist extends Employee{ //子类
//特有属性
//年终奖 bonus
private double bonus;
//方法
public Scientist(String name, double sal) {
super(name, sal);
}
//重写年工资打印
@Override
public void printSal() {
System.out.print("科学家 ");
System.out.println(getName() + " 年工资是: " + (getSal() * getSalMonth() + bonus));
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
第六题
第一个super可以访问父类的 super.name 和 super.g1（），因为super是子类向父类访问时使用的。int的访问修饰符为private，在子类里是不能访问的。
第一个this可以访问到子类里的this.id,this.score,this.f1()方法，因为这些变量在子类里是公开的。而this.name和this.g1()也可以访问到，是因为this是先从本类里面查找的，如果本类没有，也可以调用父类的，所以可以访问到 。同样，因为int的访问修饰符为private,无法访问到。
第二个super要先从Father里开始寻找。所以可以访问到super.id, super.f1(),Father找完了会向上继续找Grand，则可以访问到里面的super.name 、super.g1()。同样的，age和sorce也是因为私有属性所以无法访问。
第二个this会先从son里面开始查找，查找到子类的this.name、this.g1()、this.show()，然后会继续向上查找，查找到father里的this.id和this.f1()。但是Grand里的name和g1()不会被访问到，因为son里已经有同名的了。（同名的内容只能被访问一次）
第七题
··
package com.hspedu.homework;
public class Homework07 {
public static void main(String[] args) {
}
}
class Test{ //父类
String name = "Rose";
Test(){
System.out.println("Test");//(1)
}
Test(String name){//name john
this.name = name;//这里把父类的 name 修改 john
}
}
class Demo extends Test{//子类
String name="Jack";
Demo() {
super();
System.out.println("Demo");//(2)
}
Demo(String s){
super(s);
}
public void test(){
System.out.println(super.name);//(3) Rose (5) john
System.out.println(this.name);//(4) Jack (6) Jack
}
public static void main(String[] args) {
//老韩分析
//1. new Demo()
new Demo().test(); //匿名对象
new Demo("john").test();//匿名
}
}
匿名对象指的就是没有名字的对象,在语法上，只创建对象，但不用变量来接收,匿名对象本质上仍然是一个对象，所以它具备对象的所有功能
1.首先创建了一个无参的Demo()对象,然后调用子类里的无参Demo()方法。在该方法中第一句的super()会回归到父类里的无参Test（）方法，输出里面的内容：Test
2.然后继续回到子类的Demo()方法中，输出里面的内容：Demo
3，此时对象创建完毕，然后使用里面的Test()方法。super.name是输出父类的name属性，素以会输出Rose。
4.然后输出this.name，是子类的name属性，输出jack。
5.然后使用Demo()的带参构造器。调用里面的super(s)，则又回到了父类。然后把传进来的john赋值给了name.（属性没有动态绑定机制）。
6.继续使用test()方法。此时的super.name()是刚刚被修改过的，所以会输出john.
7.然后使用子类的this.name(),此时会使用子类的name属性，输出的是jack.
第八题
- BankAccount
package com.hspedu.homework;
public class BankAccount {//父类
private double balance ;//余额
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
//存款
public void deposit(double amount) {
balance += amount;
}
//取款
public void withdraw(double amount) {
balance -= amount;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
- CheckingAccount
package com.hspedu.homework;
/*
在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费
*/
public class CheckingAccount extends BankAccount{//新的账号
//属性
public CheckingAccount(double initialBalance) {
super(initialBalance);
}
@Override
public void deposit(double amount) {//存款
super.deposit(amount - 1);//巧妙的使用了父类的 deposit
//1 块钱转入银行的账号
}
@Override
public void withdraw(double amount) {//取款
super.withdraw(amount + 1);
//1 块钱转入银行的账号
}
}
- SavingAccount
package com.hspedu.homework;
/*
扩展前一个练习的BankAccount类，
新类SavingsAccount每个月都有利息产生(earnMonthlyInterest方法被调用)，
并且有每月三次免手续费的存款或取款。在earnMonthlyInterest方法中重置交易计数
*/
public class SavingsAccount extends BankAccount {
//老韩分析
//新增加属性
private int count = 3;
private double rate = 0.01;//利率
public void earnMonthlyInterest() {//每个月初，我们统计上个月的利息，同时将count=3
count = 3;//
super.deposit(getBalance() * rate);
}
@Override
public void deposit(double amount) {
//判断是否还可以免手续费
if(count > 0) {
super.deposit(amount);
} else {
super.deposit(amount - 1);//1 块转入银行
}
count--;//减去一次
}
@Override
public void withdraw(double amount) {//取款
//判断是否还可以免手续费
if(count > 0) {
super.withdraw(amount);
} else {
super.withdraw(amount + 1);//1 块转入银行
}
count--;
}
public SavingsAccount(double initialBalance) {
super(initialBalance);
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
}
第九题
- HomeWork09
package com.hspedu.homework;
public class Homework09 {
public static void main(String[] args) {
new LabeledPoint("Black",1929,230.07);
}
}
- LabelPoint
package HomeWork.Homework07;
public class LabelPoint extends Point{
//属性
private String label;
public LabelPoint(String label, double x, double y) {
super(x, y);
this.label = label;
}
//方法
}
- Point
package com.hspedu.homework;
public class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
}
第十题
- HomeWork10
package com.hspedu.homework;
public class Homework10 {
public static void main(String[] args) {
//测试
Doctor doctor1 = new Doctor("jack", 20, "牙科医生", '男', 20000);
Doctor doctor2 = new Doctor("jack", 21, "牙科医生", '男', 20000);
System.out.println(doctor1.equals(doctor2));//T
}
}
- Doctor
package com.hspedu.homework;
public class Doctor {
//属性
//{name, age, job, gender, sal}
private String name;
private int age;
private String job;
private char gender;
private double sal;
//5个参数的构造器
public Doctor(String name, int age, String job, char gender, double sal) {
this.name = name;
this.age = age;
this.job = job;
this.gender = gender;
this.sal = sal;
}
//方法
//相应的getter()和setter()方法
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;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
//重写父类(Object)的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同
public boolean equals(Object obj) {
//判断两个比较对象是否相同
if (this == obj) {
return true;
}
//判断obj 是否是 Doctor类型或其子类
//过关斩将 校验方式
if (!(obj instanceof Doctor)) { //不是的话
return false;
}
//向下转型, 因为obj的运行类型是Doctor或者其子类型
Doctor doctor = (Doctor)obj;
return this.name.equals(doctor.name) && this.age == doctor.age &&
this.gender == doctor.gender && this.job.equals(doctor.job) && this.sal == doctor.sal;
}
}
第十一题
编译看左边，运行看右边
1.向上转型时，运行类型为父类Person,所以可以访问到父类里的p.run() p.eat()方法。但是运行时还是子类，子类里也有run()方法，输出的是子类的run方法里的student run。子类里没有eat方法，所以会输出父类的run方法
2.向下转型时，编译类型为子类Student,所以会访问到子类里的run()、study（）方法。因为p本身就是父类的引用方法，所以也可以访问到父类的eat（）方法。运行类型是student，所以会输出student run、student study、子类没有eat方法，使用父类的eat方法，输出person eat
第十二题
第十三题
- HomeWork13
package com.hspedu.homework.homework13;
public class Homework13 {
public static void main(String[] args) {
//测试老师
Teacher teacher = new Teacher("张飞", '男', 30, 5);
teacher.printInfo();
System.out.println("-----------------------------------");
//测试
Student student = new Student("小明", '男', 15, "00023102");
student.printInfo();//封装
//定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序
Person[] persons = new Person[4];
persons[0] = new Student("jack", '男', 10, "0001");
persons[1] = new Student("mary", '女', 20, "0002");
persons[2] = new Teacher("smith", '男', 36, 5);
persons[3] = new Teacher("scott", '男', 26, 1);
//创建对象
Homework13 homework13 = new Homework13();
homework13.bubbleSort(persons);
//输出排序后的数组
System.out.println("---排序后的数组-----");
for(int i = 0; i < persons.length; i++) {
System.out.println(persons[i]);
}
//遍历数组，调用test方法
System.out.println("=======================");
for (int i = 0; i < persons.length; i++) {//遍历多态数组
homework13.test(persons[i]);
}
}
//定义方法，形参为Person类型，功能：调用学生的study或教师的teach方法
//分析这里会使用到向下转型和类型判断
public void test(Person p) {
if(p instanceof Student) {//p 的运行类型如果是Student
((Student) p).study();
} else if(p instanceof Teacher) {
((Teacher) p).teach();
} else {
System.out.println("do nothing...");
}
}
//方法,完成年龄从高到底排序
public void bubbleSort(Person[] persons) {
Person temp = null;
for (int i = 0; i < persons.length - 1; i++) {
for (int j = 0; j < persons.length - 1 - i; j++) {
//判断条件, 注意这里的条件可以根据需要，变化
if(persons[j].getAge() < persons[j+1].getAge()) {
temp = persons[j];
persons[j] = persons[j + 1];
persons[j + 1] = temp;
}
}
}
}
}
- Person.java
package com.hspedu.homework.homework13;
/*
抽取一个父类Person类，将共同属性和方法放到Person类
*/
public class Person {//父类
private String name;
private char gender;
private int age;
//方法
public Person(String name, char gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//编写一个play 方法, 把共有的输出内容写到父类
public String play() {
return name + "爱玩";
}
//返回一个基本信息
/*
姓名：张飞
年龄：30
性别：男
*/
public String basicInfo() {
return "姓名: " + name + "\n年龄: " + age + "\n性别: " + gender;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", gender=" + gender +
", age=" + age +
'}';
}
}
- Student.java
package com.hspedu.homework.homework13;
/*
Student类有名称（name），性别(sex),年龄（age），学号（stu_id），
做合理封装，通过构造器在创建对象时将4个属性赋值。
学生需要有学习的方法（study），在方法里写生“我承诺，我会好好学习。”
*/
public class Student extends Person{ //
//属性
private String stu_id;
//方法
public Student(String name, char gender, int age, String stu_id) {
super(name, gender, age);
this.stu_id = stu_id;
}
public String getStu_id() {
return stu_id;
}
public void setStu_id(String stu_id) {
this.stu_id = stu_id;
}
//我承诺，我会好好学习
public void study() {
System.out.println(getName() + "承诺，我会好好学习 老韩讲的 java");
}
/**
* 学生爱玩足球
* @return
*/
@Override
public String play() {
return super.play() + "足球";
}
//编写一个输出信息的方法，这样体现封装
public void printInfo() {
System.out.println("学生的信息:");
System.out.println(super.basicInfo());
System.out.println("学号: " + stu_id);
study();//组合， 变化万千
System.out.println(play());
}
@Override
public String toString() {
return "Student{" +
"stu_id='" + stu_id + '\'' +
'}' + super.toString();
}
}
- Teacher.java
package com.hspedu.homework.homework13;
/*
写一个Teacher类，Teacher类有名称（name），性别（sex），年龄（age），工龄（work_age),
做合理封装，通过构造器在创建对象时将4个属性赋值
*/
public class Teacher extends Person {
//属性
private int work_age;
//方法
public Teacher(String name, char gender, int age, int work_age) {
super(name, gender, age);
this.work_age = work_age;
}
public int getWork_age() {
return work_age;
}
public void setWork_age(int work_age) {
this.work_age = work_age;
}
//教师需要有教学的方法（teach），在方法里写上“我承诺，我会认真教学。
public void teach() {
System.out.println(getName() + "承诺，我会认真教学 java...");
}
/**
* 老师爱玩象棋
*/
@Override
public String play() {
return super.play() + "象棋";
}
//输出信息方法
public void printInfo() {
System.out.println("老师的信息：");
System.out.println(super.basicInfo());
System.out.println("工龄: " + work_age);
teach();
System.out.println(play());
}
@Override
public String toString() {
return "Teacher{" +
"work_age=" + work_age +
'}' + super.toString();
}
}
第十四题
首先，新创建了一个无参的C类型对象，该对象指向本类中的有参构造器，然后使用super方法，调用父类（B类）里的有参构造器。但是因为这个地方隐含了一个super（）方法，所以会继续向上调用A类的无参构造器，输出“我是A类”后，执行print方法，输出“hahah我是B类的有参构造”，然后回到C类的有参构造，输出“”“我是C类的有参构造”，这个时候执行完了this.hello()方法，此时输出“我是C类的无参构造”。
第十五题
第十六题
