java学习笔记(8) 第8章（下）- 面向对象编程(中级部分) - 练习题

最新推荐文章于 2022-12-15 11:56:13 发布
最新推荐文章于 2022-12-15 11:56:13 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： java 文章标签： intellij-idea java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50736744/article/details/121419155
版权

目录：

题目1

1.定义一个Person类 {name, age, job} ,初始化Person对象数组，有3个person对象，并安照 age从大到小进行排序,提示，使用冒泡排序。Homework01.java

public class Homework01 {
    public static void main(String[] args) {

        //初始化Person 对象数组，有3个person对象
        Person[] persons = new Person[3];
        persons[0] = new Person("mary",30, "PHP工程师");
        persons[1] = new Person("tom",50, "大数据工程师");
        persons[2] = new Person("smith",10, "JavaEE工程师");

        //输出当前对象数组
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);//不重写就是默认对象的.toString() ,后边要重写toString
        }

        //使用冒泡排序
        Person tmp = null;//临时变量，用于交换
        for(int i = 0; i < persons.length -1 ;i++) {//外层循环
            for(int j = 0; j < persons.length -1 - i; j++) {//内层循环
                //并按照 age 从 大到 小进行排序, 如果前面的人的age < 后面人的年龄，就交换
       // 要求按照名字的长度从小到大 if(persons[i].getName().length() > persons[i+1].getName().length())    
                if(persons[j].getAge() > persons[j+1].getAge()) {
                    tmp = persons[j];
                    persons[j] = persons[j+1];
                    persons[j+1]= tmp;
                }
            }
        }

        System.out.println("排序后的效果");
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);//默认对象的.toString()
        }

    }
    /*定义一个Person类 {name, age, job}, 初始化Person 对象数组，有3个person对象，
    并按照 age 从 大到 小进行排序, 提示，使用冒泡排序 */
}
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  //重写toString
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
}

题目2

  1. 写出四种访问修饰符和各自的访问权限

在这里插入图片描述

题目3

  1. 编写老师类 HomeworkO3.java
    (1)要求有属性 “姓名name”，“年龄age”，“职称post”，“基本工资“salary”
    (2)编写业务方法,introduce ()，实现输出一个教师的信息。
    (3)编写教师类的三个子类：教授类(Professor)、副教授类、讲师类。工资级别分别为：教受为1.3、副教授为1.2、讲师类1.1。在三个子类里面都重写父类的introduce()方法。
    (4)定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印。

方法1：把grade等级写在父类Teacher里

主类代码：

public class Homework03 {
    public static void main(String[] args) {
        Professor professor = new Professor("贾宝玉", 30, "高级职称", 30000, 1.3);
        professor.introduce();
    }
}
/*
(1) 要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”
(2) 编写业务方法， introduce（），实现输出一个教师的信息。
 */
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: " + name + " age: " + age
                + " post: " + post + " salary:" + salary + " grade:" + grade);
    }
}

子类Professor代码：

//子类
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();
    }
}

方法2：把grade等级写在每一个子类里

主类代码：

public class Homework03 {
    public static void main(String[] args) {
        Teacher professor = new Professor("java", 223, "教授", 2300,"s");
        System.out.println(professor.introduce());
    }
}

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) {
        this.name = name;
        this.age = age;
        this.post = post;
        this.salary = salary;
       // this.grade =grade;
    }

    public String introduce(){
        return "教师信息为："+ "姓名"+name+"年龄"+age+"职称"+post+"薪水"+salary;
    }
//    public void introduce() {
//        System.out.println("name: " + name + " age: " + age
//                + " post: " + post + " salary:" + salary + " 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;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", post='" + post + '\'' +
                ", salary=" + salary +
                '}';
    }
}

子类Professor代码：

public class Professor extends  Teacher{
  
    private String grade;

    public Professor(String name, int age, String post, double salary, String grade) {
        super(name, age, post, salary);
        this.grade = grade;
    }

    @Override
    public String introduce() {
        System.out.println("教授信息为");
        return super.introduce()+"级别为"+grade;
    }

    public String getGrade() {
        return grade;
    }
    public void setGrade(String grade) {
        this.grade = grade;
    }
    @Override
    public String toString() {
        return "Professor{" +
                "grade='" + grade + '\'' +
                '}';
    }
}

题目4

  1. 通过继承实现员工工资核算打印功能 Homework04.java
    父类:员工类(Employee)
    子类:部门经理类(Manager)、普通员工类(Worker)
    (1)部门经理工资=1000+单日工资* 天数* 等级（1.2)。=>奖金＋基本工资
    (2)普通员工工资=单日工资 * 天数 * 等级(1.0); =>基本工资
    (3)员工属性:姓名，单日工资,工作天数
    (4)员工方法(打印工资)
    (5)普遍员工及部门经理都是员工子类,需要重写打印工资方法。
    (6)定义并初始化普通员工对象，调用打印工资方法输出工资，定义并初始化部门经理对象,调用打印工资方法输出工资

方法1：创建Manager对象时，奖金是多少并不是确定的，因为在构造器中，不给bonus，可以在主类通过setBonus动态设置奖金。（我认为这一步无所谓，用方法二也一样。）

主类和父类代码：

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
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代码：


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代码：

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();//调用父类的方法，复用代码
    }
}

方法2：创建Manager对象时，在构造器中给bonus。

主类和父类代码：

public class Homework04 {
    public static void main(String[] args) {
    
        Manager s = new Manager("大猛子", 100, 20, 1.2, 1000);
        s.printSal();

        Worker worker = new Worker("小猛子", 80, 30, 1.0);
        worker.printSal();
    }
}

class Employee {

    private String name;
    private double daySal;
    private int workDays;
    private double grade;

    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代码

public class Manager extends  Employee{
    private double bonus;
    
    @Override
    public void printSal() {
        //super.printSal();
        System.out.println("经理 "+getName()+" 工资为："+(bonus + getDaySal()*getWorkDays()*getGrade()));
    }

    public Manager(String name, double daySal, int workDays, double grade, double bonus) {
        super(name, daySal, workDays, grade);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}

子类普通员工Worker代码：

public class Worker extends Employee {
    public Worker(String name, double daySal, int workDays, double grade) {
        super(name, daySal, workDays, grade);
    }
    
    @Override
    public void printSal() {
        System.out.print("普通员工 ");
        super.printSal();
    }
}

题目5

  1. 设计父类一员工类。子类:工人类(Worker),农民类(Peasant),教师类(Teacher),科学家类(Scientist).服务生类(Waiter)。
    (1)其中工人,农民,服务生只有基本工资sal
    (2)教师除基本工资外还有课酬(元/天) classDay, classSal
    (3)科学家除基本工资外,还有年终奖bonus
    (4)编写一个测试类,将各种类型的员工的全年工资打印出来
    HomeworkO5.java 放在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代码：
注意：这里年薪有的发12个月，有的13个15个，变化设置成属性，然后不加入构造器，而是用get和set在主类设置。

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

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 代码：

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代码：
注意：这里 classDays 和 classSal没有放入构造器，也是在主类用set方法设置。

public class Teacher extends Employee{//子类
    //特有属性
    private int //课时费

    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代码：
注意：这里 bonus 没有放入构造器，也是在主类用set方法设置。

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;
    }
}

题目6

在这里插入图片描述
1、super访问父类。(不仅局限于父类，还可以往上一类)

2、this先从本类访问(本类所有的成员都可以访问)，本类没有再去父类或者 超类，但是，this在本类访问了name，就不能再访问超类的name了。假如this在父类中访问了一个成员，就不能再去超类访问了。。

题目7

在这里插入图片描述

题目8

在这里插入图片描述

主类代码：

public class Homework08 {
    public static void main(String[] args) {
    
          // 第1小问测试checkingAccount
//        CheckingAccount checkingAccount = new CheckingAccount(1000);
//        checkingAccount.deposit(10);// 1010 - 1 = 1009
//        checkingAccount.withdraw(9);//1009 - 9 = 1000 -1= 999
//        System.out.println(checkingAccount.getBalance());

        //测试SavingsAccount
        SavingsAccount savingsAccount = new SavingsAccount(1000);
        savingsAccount.deposit(100);
        savingsAccount.deposit(100);
        savingsAccount.deposit(100);
        System.out.println(savingsAccount.getBalance());//1300  三次免息
        savingsAccount.deposit(100);
        System.out.println(savingsAccount.getBalance());//1400-1=1399

        //月初，定时器自动调用一下 earnMonthlyInterest
        savingsAccount.earnMonthlyInterest();//统计利息
        System.out.println(savingsAccount.getBalance());//1399 + 13.99 =1412.99
        savingsAccount.withdraw(100);//免手续
        System.out.println(savingsAccount.getBalance());//1412.99 -100 =1312.99
        savingsAccount.withdraw(100);//免手续
        savingsAccount.withdraw(100);//免手续
        System.out.println(savingsAccount.getBalance());//1412.99 -200 =1112.99
        savingsAccount.deposit(100);//扣手续费
        System.out.println(savingsAccount.getBalance());//1112.99 + 100 = 1212.99 - 1 = 1211.99

    }
}

子类checkingAccount代码：

/*
在上面类的基础上扩展 新类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);//比如说取10元，加上手续费就是要取11元
        //1 块钱转入银行的账号
    }
}

子类SavingsAccount代码：

/*
扩展前一个练习的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;
    }
}

题目9

  1. 设计一个Point类，其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint，其构造器接受一个标签值和x,y坐标,比如:new LabeledPoint("Black”,1929,230.07),写出对应的构造器即可。HomeworkO9.java

    此题的用意在于：已知需求，反写构造器

public class Homework09 {
    public static void main(String[] args) {
        new LabeledPoint("Black",1929,230.07);
    }
}

class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

class LabeledPoint extends Point {
    //特有属性
    private String label;
    
    public LabeledPoint(String label, double x, double y) {
        super(x, y);
        this.label = label;
    }
    //方法
}

题目10

  1. 编写Doctor类{name, age, job, gender, sal}
    相应的getter()和setter()方法，5个参数的构造器，重写父类(Object)的equals(方法:public boolean equals(Object obi)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同。 Homework10.java

提示：此题可以参考学习笔记第八章（中）的 8.12.2 如何重写equals 方法

public class Homework10 {
    public static void main(String[] args) {
        //测试
        Doctor doctor1 = new Doctor("jack", 20, "牙科医生", '男', 20000);
        Doctor doctor2 = new Doctor("jack", 20, "牙科医生", '男', 20000);

        System.out.println(doctor1.equals(doctor2));//T  equals重写了，是判断属性是否相同。
    }
}

 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;

    }
}

题目11

考察向上转型，向下转型。
可以参考文章文章https://blog.csdn.net/m0_50736744/article/details/121377193中的 8.11.5 多态注意事项和细节讨论-向上转型 和 向下转向 部分。

在这里插入图片描述
小总结：其实访问方法时，可以理解成 访问方法看运行类型(右边)-指输出结果。
可以参考文章https://blog.csdn.net/m0_50736744/article/details/121377193中的8.11.6 课堂练习的2

题目12

在这里插入图片描述

题目13

在这里插入图片描述
注意：本题7、8小问好好领会。（7、8小问需要重写toString方法）

主类代码：7,8小问放在了主类

public class Homework13 {
    public static void main(String[] args) {

        //测试老师
        Teacher teacher = new Teacher("张飞", '男', 30, 5);

        teacher.printInfo();

        //测试
        Student student = new Student("小明", '男', 15, "00023102");
        System.out.println("-----------------------------------");
        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类：

/*抽取一个父类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类：

/*学生需要有学习的方法（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类：

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();
    }
}

题目14

注意：千万别忘了B类中隐藏的那个Super
在这里插入图片描述
答案：我是A类，hahah我是B类的有参构造，我是c类的有参参构造，我是c类的无参构造

题目15

  1. 什么是多态 , 多态具体体现有哪些? (可举例说明)

答案：

多态:方法或对象具有多种形态，是0OP的第三大特征，是建立在封装和继承基础之上多态具体体现
1.方法多态
(1)重载体现多态(2)重写体现多态
2.对象多态
(1)对象的编译类型和运行类型可以不一致,编译类型在定义时，就确定，不能变化
(2)对象的运行类型是可以变化的,可以通过getClasss ( ) 来查看运行类型
(3)编译类型看定义时=号的左边，运行类型看=号的右边
3.举例说明

public class Homework15 {
    public static void main(String[] args) {
        AAA obj = new BBB();//向上转型
        AAA b1 = obj;
        System.out.println("obj的运行类型=" + obj.getClass());//BBB
        
        obj = new CCC();//向上转型
        System.out.println("obj的运行类型=" + obj.getClass());//CCC
      
        obj = b1;
        System.out.println("obj的运行类型=" + obj.getClass());//BBB
    }
}

class AAA {//超类

}
class BBB extends AAA {//父类

}
class CCC extends BBB {//子类

}

内存分析图顺序：黄–>红–>蓝
在这里插入图片描述
注意：这里obj的运行类型可以改变，但是编译类型不能改变，AAA obj就决定了obj的编译类型是AAA

题目16

  1. java的动态绑定机制是什么? Homework16.java

    答案：
    1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定。
    2.当调用对象的属性时，没有动态绑定机制,哪里声明,那里使用。

码农小C
关注
专栏目录
1.3 面向对象编程中级 两个案例秒懂封装思想 别忘了打开IDE动手敲一下嗷 -跟着韩老师学JavaSE
一碗菜粥的博客
06-15 3365
面向对象编程中级 两个很不错的案例 分享 与大家共勉
1.6 面向对象编程中级 Object类详解 断点调试初始-跟着韩老师学JavaSE
一碗菜粥的博客
07-25 325
面向对象编程中级 完结！介绍了四个Object类中的方法 介绍了断点调试 之后二刷要来看看断点调试的案例 、 整章的案例 来加深印象！
【java期末复习题】第8章 常用实用类
DynamoTUO的博客
06-25 3033
第8章 常用实用类 1．获取字符串长度应该使用下列哪个方法？（ ）。 A、length B、length() C、codePointAt() D、chatAt() 2．当编译和运行下列代码时会发生什么？（ ）。 public class Test { public static void main(String[] args) { System.out.println("" + 2 + 3); System.out.println
Java第八章课后习题
cyj88880的博客
10-16 773
3.String类型特点 1.一旦赋值，便不能更改其指向的字符对象 2.如果更改，则会指向一个新的字符对象 3.不能为null 4.String值比较与引用比较？ stringA.equals(stringB)值比较 stringA==stringB进行引用比较 5.String与StringBuffer的区别,相互转化？ StringBuffer是一个具有对象引用传递特点的字符串对象。 `Str...
【Java语言面向对象】（12）构造方法/构造器
FairyKunKun的博客
02-25 505
introduce() ---introduce是方法名 Dog()----Dog是方法名 Dog dog = new Dog(); 实例化一个Dog对象 -----堆区开辟一开内存空间，内存空间存储dog对象中的相关数据，如：strain、sex、health……,这些事情都是由构造方法或构造器完成。 结论： (1)每个类都有一个默认的无参构造方法，由系统提供。 (2)看不到构造器，构造器是存在的，这样的构造器叫隐式构造器。 (3)若需要看到默认的构造器，则需要显式定义出...
Java面向对象——继承(1)
m0_68828514的博客
11-28 496
本篇文章来给大家讲解java面向对象三大特性中的继承。本次的内容相比上篇的封装内容要多很多，同时难度也有所增加，我会用最通俗，最直观的案例带大家学习。继承这一章节我会分三次进行讲解，初识继承、深入继承特性以及继承JVM内存分布。如果能将继承深入的理解，那么你对OOP设计思想也会得到质的飞跃，同时也为今后的学习打下坚实的基础！接下来带大家初识面向对象的继承。
大数据分析综合实习day05
最新发布
qq_53474111的博客
12-15 125
类：具有相同特征和行为的一类事物的统称，理解成一张图纸，一个抽象的事物。一个类如果继承了另一个类，就拥有了这个类的所有资源，私有除外。属性：name，age，classes，address。结论：先有类，后有对象，对象是根据类创建出来的。子类：DrugDog（缉拿毒贩的警犬）子类：ArmyDog（追击敌人的警犬）对象：是根据类创建出来的具体存在的事物。封装：就是把属性和方法封装到类中的过程。面向对象编程思想的基本单位：类与对象。继承：指的是类与类之间存在的关系。多态：指的是一种事物的多种形态。
Pepcoding-Intermidiate
03-30
【压缩包子文件的文件名称列表】"Pepcoding-Intermidiate-main" 暗示了课程资源可能组织在一个主目录下，包含各种代码文件、笔记、练习题或者项目文件。学员可以通过这个主目录逐步学习和实践课程内容。 在"Java...
【最新版】Java学习路线（含B站口碑推荐视频链接）
Redemption___的博客
08-14 5961
文章目录一、计算机网络二、数据结构与算法三、操作系统四、计算机组成原理五、编译原理六、设计模式七、MySQL八、实操工具九、JAVA并发与JVM十、Redis十一、Linux十二、Java路线学习尚硅谷黑马程序员动力节点狂神说十三、Java基础十四、JavaWeb十五、框架十六、微服务/分布式十七、中间件十八、面试技巧、简历优化
Java学习路线图，全套Java基础视频教程
sebeefe的博客
08-01 1464
扎实的技术基础功+真实项目实战经验，才是好就业的关键。不止于此，黑马程序员帮助已就业学员继续提升！技术的提升永无止步，碎片时间学习进行各种技术强化以上Java学习路线图均有课程+源码+笔记+资料。更多提升课程访问底部，即可获取持续成长技能！...
Person类和它的两个子类Student、Employee
11-04
设计一个名为Person的类和他的两个名为Student和Employee子类。Employee又有两个子类：教员类Faculty和职员类Staff。
设计一个Person类，有Person类派生一个Student类和一个Teacher类
06-18
设计一个Person类，有Person类派生一个Student类和一个Teacher类，Student类包括姓名，编号，和成绩。Teacher类包括姓名，编号，职务和部门。又要用的来下载啊，希望对你有所帮助。
201521123047 《Java程序设计》第4周学习总结
weixin_30294295的博客
03-18 67
1. 本周学习总结 1.1 尝试使用思维导图总结有关继承的知识点。 1.2 使用常规方法总结其他上课内容。 答： - 只能有一个父类，即单继承，子类继承父类的全部成员(属性和方法)，并可能有自己特有的属性和方法。 - 覆盖是指在子类中重新定义父类中的方法。 - 多态性是指相同的形态不同的行为即方法名相同，但是实现的过程不同。 - instanceof 可以判断父类引用所引用的对象实例的...
java常见编程练习hw二(中等难度)
西京刀客
02-05 1212
文章目录1. 进制转换[推荐、简单]思路：java内置 decode方法,将 String 解码为 Integer【不推荐】思路2，自己计算2. 质数因子思路1: 设定i=2，i一直递增，当N除以i余数为0的时候，N设定为N/i3. 合并表记录思路：使用有序的TreeMap4. 提取不重复的整数思路1 创建一个长度为10的数组5. 字符个数统计HashSet6. 字符串排序思路：利用java 的 Arrays.sort 排序数组即可7. 购物单 (TODO 难一点)思路1：给定购物单，逐级增加金额和件数，
5-2 定义并测试一个代表员工的Employee类。
zuoan1134的博客
12-24 1万+
5-2 定义并测试一个代表员工的Employee类。员工属性包括“编号”，“姓名”，“基本薪水”，“薪水增长额”，还包括计算薪水增长额以及计算增长后的工资总额的操作方法。class Employee{ String number; String name; float salary; float time;// increase=time*200; pub
大学期末考java编程题_2016年大学java期末考试试题(5)
weixin_34475062的博客
12-23 1643
A. 界面是否有错误B. 终止性错误C. 输入是否正确接收D. 是否存在冗余代码14. 不同级别的用户对同一对象拥有不同的访问权利或某个客户端不能直接操作到某个对象，但又必须和那个对象有所互动，这种情况最好使用什么设计模式。A. Fa?ade模式B. Proxy模式C. Adapter模式D. Bridge模式15. 下面哪项不是web容器的部署描述符的作用。A. 映射到Servlet/JSP的请...
实现一个名为Person的类和它的两个子类Student和Employee。
热门推荐
superyzh的博客
06-23 2万+
1、实现一个名为Person的类和它的两个子类Student和Employee。Employee有子类Faculty和Staff。Person中的人有姓名、地址和电话号码。  Student中的学生有班级状态（一、二、三、四年级）。将这些状态定义为常量。  Employee中的雇员有办公室、工资。Faculty中的教员有级别。Staff中的职员有职务称号。覆盖每个类中的toString方法，显
写一个员工类Employee，有员工编号，姓名，年龄。 用map存储公司的员工，员工作为key，薪水作为value
健健
06-22 1万+
要求：输出所有员工的薪水 员工离职员工加薪按员工年龄从大到小输出public class Employee implements Comparable&lt;Employee&gt;{ private String no; private String name; private int age; public Employee() { super(); } public ...
JAVA小练习123——定义一个Person数组，将Person数组中的重复对象剔除
Eric_The_Red的博客
06-13 1843
import java.util.Arrays; import java.util.Set; import java.util.List; import java.util.HashSet; class Person { public String name; public int age; public Person(String name, int age) { this.n...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值