💁 个人主页：Nezuko627的博客主页 欢迎来访~~~
❤️ 支持我：👍 点赞 🌷 收藏 🤘关注
🎏 格言：立志做一个有思想的程序员 🌟
📫 作者介绍：本人本科软件工程在读，博客及技术将主要涉及JavaSE、JavaEE、MySQL、SpringBoot、算法等。专栏内容长期更新，如有错误，欢迎评论区或者私信指正！谢谢大家的支持~~~

本篇主要解决内容：

• 提供一些Java练习题，供大家巩固基础知识⭐️
• 本文题目参考bilibili平台韩顺平零基础30天学会Java视频 P343 ~ P358
  

题目列表

• 题目1：Person类
• 题目2：写出四种访问修饰符及各自的权限
• 题目3：编写老师类
• 题目4：继承员工类
• 题目5：可以调用吗？
• 题目6：输出结果是什么？
• 题目7：重写 equals 方法
• 题目8：说出 == 与 equals 的区别
• 题目9：什么是多态？具体体现在哪方面？
• 题目10：Java的动态绑定机制是什么？
• 写在最后

题目1：Person类

⭐️ 题目描述：

定义一个 Person类{name，age，job}，初始化 Person 对象数组，有3个person对象，并按照 age 从大到小排序，使用冒泡排序

🍑 易错点： 注意是根据 age 信息排序，排序交换的是对象，并非只交换 age 这一属性！

🍌 参考代码：

public class test01 {    public static void main(String[] args) { Person[] people = new Person[3]; // 信息录入 people[0] = new Person("黄小黄", 25, "程序员"); people[1] = new Person("马小淼", 20, "网络安全工程师"); people[2] = new Person("相小欣", 22, "视频剪辑师"); // 排序 按照年龄 冒泡排序 for (int i = 0; i < people.length - 1; i++) {     for (int j = 0; j < people.length - i - 1; j++) {  if(people[j].getAge() < people[j+1].getAge()){      Person temp = people[i];      people[i] = people[i+1];      people[i+1] = temp;  }     } } // 打印信息 for (int i = 0; i < people.length; i++) {     System.out.println(people[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 int getAge() { return age;    }    public String getJob() { return job;    }    public void setName(String name) { this.name = name;    }    public void setAge(int age) { this.age = age;    }    public void setJob(String job) { this.job = job;    }    // 重写toString便于查看结果    @Override    public String toString() { return "Person{" +  "name='" + name + '\'' +  ", age=" + age +  ", job='" + job + '\'' +  '}';    }}

🍎 实现结果：

题目2：写出四种访问修饰符及各自的权限

🍎 答案见下表：

题目3：编写老师类

⭐️ 题目描述：

编写老师类，要求如下：
（1）要求有属性“姓名 name”，“年龄 age”，“职称 post”，“基本工资 salary”；
（2）编写业务方法，introduce（），实现输出一个教师的信息；
（3）编写教师类的子类：教授类（Professor），工资级别为：教授1.3 ，在子类中重写父类的introduce（）方法；
（4）定义初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印。

🍑 分析题目，发现子类都含有工资级别这一属性，因此我们可以将这一属性写到父类中。
🍌 参考代码：

• Teacher类：

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 int getAge() { return age;    }    public String getPost() { return post;    }    public double getSalary() { return salary;    }    public double getGrade() { return grade;    }    public void setName(String name) { this.name = name;    }    public void setAge(int age) { this.age = age;    }    public void setPost(String post) { this.post = post;    }    public void setSalary(double salary) { this.salary = salary;    }    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类：

class Professor extends Teacher{    public Professor(String name, int age, String post, double salary, double grade) { super(name, age, post, salary, grade);    }    // 重写 introduce    public void introduce(){ System.out.println("我是教授类的重写方法"); super.introduce();    }}

• 测试类

public class test03 {    public static void main(String[] args) { Professor professor = new Professor("李强", 45, "教授", 15000, 1.3); professor.introduce();    }}

🍎 实现结果：

题目4：继承员工类

⭐️ 题目描述：

父类：员工类
子类：部门经理类
（1）部门经理工资 = 1000 ＋ 单日工资 * 天数 * 等级（1.2）；
（2）员工工资 = 单日工资 * 天数 * 等级（1.0）；
（3）员工属性：姓名、单日工资、工作天数；
（4）员工方法：打印工资；
（5）部门经理是员工子类，需要重写打印工资的方法；
（6）定义并初始化普通员工对象，调用打印工资方法输入工资，定义并初始化部门经理对象，调用打印工资方法输入工资。

🍑 易错点： 对比普通员工与经理，经理类应该多出一个奖金属性。并且由于奖金不是确定的，我们考虑不使用构造器，并非在创建经理对象时直接确定奖金，而是根据实际情况决定奖金数，使用set方法。

🍌 参考代码：

• Empolyee类：

class Employee{    // 属性：姓名，单日工资，工作天数，工资等级    private String name;    private double daySal;    private int workDays;    private double grade; // 打印工资    public void printSal(){ System.out.println(name + " 工资 = " + daySal*workDays*grade); } // 构造器 get set    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 double getDaySal() { return daySal;    }    public int getWorkDays() { return workDays;    }    public double getGrade() { return grade;    }    public void setName(String name) { this.name = name;    }    public void setDaySal(double daySal) { this.daySal = daySal;    }    public void setWorkDays(int workDays) { this.workDays = workDays;    }    public void setGrade(double grade) { this.grade = grade;    }}

• Manager类：

class Manager extends Employee{    // 特有属性    private double bonus;  // 奖金 // 重写 printSal    public void printSal(){ System.out.println("经理 " + getName() + " 工资 = " + (getDaySal()*getWorkDays()*getGrade()+bonus));    }    public Manager(String name, double daySal, int workDays, double grade) { super(name, daySal, workDays, grade);    }    public void setBonus(double bonus) { this.bonus = bonus;    }    public double getBonus() { return bonus;    }}

• 测试类：

public class test04 {    public static void main(String[] args) { // 经理 顺便练习一下向下转型，你也可以直接使用 Manager 编译类型 Employee employee = new Manager("漩涡鸣人", 100, 22, 1.2); if(employee instanceof Manager){     Manager manager = (Manager) employee;     manager.setBonus(1000); } employee.printSal(); // 员工 Employee employee1 = new Employee("宇智波佐助", 80, 25, 1.0); employee1.printSal();    }}

🍎 实现结果：

题目5：可以调用吗？

⭐️ 题目描述：

假定 Grand、Father 和 Son 在同一包下，问：父类和子类中通过 this 和 super 都可以调用哪些属性和方法？

🍑 题目代码（问题见注释）：

class Grand{// 超类String name = "AA";private int age = 100;public void g1(){}}class Father extends Grand{String id = "001";private double score;public void f1(){// super 可以访问哪些成员？// this 可以访问哪些成员？}}class Son extends Father{String name = "BB";public void g1(){}private void show(){// super 可以访问哪些成员？// this 可以访问哪些成员？}}

🍎 参考答案：

答： 在 Father 类的 f1 方法中，super 可以访问 name 和 g1 两个成员； this 可以访问 id 、 score 、 f1 、name 、g1 五个成员。
在 Son 类的 show 方法中，super 可以访问 id 、 f1 、 name 、 g1四个成员；this 可以访问 name 、g1、show、id 、 f1 五个成员。
归根到底，我们需要明确：super 是从父类开始找，然后找父类的父类; 而 this 是从当前类开始找，然后找父类。其中，我们需要注意访问修饰符的限制，当一个成员被 private 修饰后，其他类不能直接访问该属性！

题目6：输出结果是什么？

⭐️ 题目描述：

阅读下列代码，写出程序的输出结果。

🍑 题目代码：

class Test{// 父类    String name = "Rose";    Test(){ System.out.println("Test");    }    Test(String name){ this.name = name;    }}class Demo extends Test{//子类    String name = "Jack";    Demo(){ super(); System.out.println("Demo");    }    Demo(String s){ super(s);    }    public void test(){ System.out.println(super.name); System.out.println(this.name);    }    public static void main(String[] args) { new Demo().test(); new Demo("john").test();    }}

🍎 参考答案：

Test
Demo
Rose
Jack
john
Jack

😎 解析：

1. new Demo().test()： 先使用 Demo类的无参构造器创建对象，在无参构造器中，使用了 super() 调用了父类的无参构造器，因此先输出 Test，而后回到 Demo类 的无参构造器，输出 Demo。最后调用 test 方法，分别输出父类的属性和子类的属性，分别为 Rose 与 Jack；
2. new Demo(“john”).test()： 先使用 Demo类的有参构造器创建对象，在有参构造器中，使用了 super(s) 调用了父类的有参构造器。由于属性不具备动态绑定机制，所以父类的属性 name 被设置为了 john，而子类的属性 name 保持默认值 Jack 不变。在调用 test 方法时，输出依次为 john、Jack。

题目7：重写 equals 方法

⭐️ 题目描述：

编写Doctor类{name，age，job，gender，sal}，含有相应的get与set方法以及含有5个参数的构造器。请你重写 equals 方法，在测试类中创建两个对象，要求属性值均相同，请你判断两个对象是否相等。

🍌 考察： 本题考察点为 equals 方法的作用：（1）比较是否为同一对象； （2）比较属性值是否相同。
如果忘记了 equals，那就没有什么是一个传送门解决不了的！
❤️ 传送 ing ~~ 【JavaSE】面试高频考点，确定不来看看？深入源码解读 == 和 equals 的区别

🍑 参考代码：

• Doctor类：

class Doctor{    private String name;  // 姓名    private int age;  // 年龄    private String job;  // 工作    private String gender;  // 性别    private double sal;  // 工资    // 重写 equals    public boolean equals(Object obj){ // 先判断是否为同一对象 if(this == obj){     return true; } // 判断 obj 是否为 Doctor 或者其派生类 if(obj instanceof Doctor){     Doctor doctor = (Doctor) obj;  // 向下转型     // 属性判断     return this.name.equals(doctor.name) && this.age == doctor.age      && this.job.equals(doctor.job) && this.gender.equals(doctor.gender)      && this.sal == doctor.sal; } // 不是就为 false return false;    }    public Doctor(String name, int age, String job, String gender, double sal) { this.name = name; this.age = age; this.job = job; this.gender = gender; this.sal = sal;    }    public String getName() { return name;    }    public int getAge() { return age;    }    public String getJob() { return job;    }    public String getGender() { return gender;    }    public double getSal() { return sal;    }    public void setName(String name) { this.name = name;    }    public void setAge(int age) { this.age = age;    }    public void setJob(String job) { this.job = job;    }    public void setGender(String gender) { this.gender = gender;    }    public void setSal(double sal) { this.sal = sal;    }}

• 测试类：

public class test07 {    public static void main(String[] args) { Doctor d1 = new Doctor("乔巴", 5, "船医", "不详", 50); Doctor d2 = new Doctor("乔巴", 5, "船医", "不详", 50); System.out.println(d1 == d2);  // false System.out.println(d1.equals(d2));  // true    }}

🍎 实现结果：

false
true

题目8：说出 == 与 equals 的区别

题目9：什么是多态？具体体现在哪方面？

🍎 答：多态： 方法或者对象具有多种形态，是面向对象（OOP）的第三大特征，是建立在封装和继承基础之上的。
具体体现：
1.方法的多态： 方法的重载与方法的重写体现多态；前者主要是同一对象调用同名的不同方法，后者主要是不同对象调用同名的不同方法；
2.对象的多态： （1）对象的编译类型和对象的运行类型可以不一致，但编译类型在定义时就确定了，不能变化；（2）对象的运行类型是可以变化的，可以通过 getClass()来查看运行类型。

题目10：Java的动态绑定机制是什么？

🍎 答： 1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定。 当其查找到对象的运行类型时，会在该类型中查找是否具有该方法，如果有则直接调用，如果没有则逐层向上，如果直到 Object（顶级父类）都没有，则编译器会报错。2.当调用对象的属性时，没有动态绑定机制。 遵守，哪里声明，哪里使用的原则，即由编译类型决定。如下代码块，输出结果为 10，因为编译类型是 A，所以查找的是 A中的属性。

public class test {    public static void main(String[] args) { A b = new B(); System.out.println(b.a);  // 10    }}class A{    int a = 10;}class B extends A{    int a = 20;}

写在最后

🌟以上便是本文的全部内容啦，后续内容将会持续免费更新，如果文章对你有所帮助，麻烦动动小手点个赞 + 关注，非常感谢 ❤️ ❤️ ❤️ !

如果有问题，欢迎私信或者评论区！
共勉：“你间歇性的努力和蒙混过日子，都是对之前努力的清零。”