本篇主要解决内容：
- 提供一些Java练习题，供大家巩固基础知识⭐️
- 本文题目参考bilibili平台韩顺平零基础30天学会Java视频 P343 ~ P358
题目列表
题目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：写出四种访问修饰符及各自的权限
🍎 答案见下表：
| 访问修饰符 | 本类 | 同包 | 子类 | 不同包 |
|---|---|---|---|---|
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | × |
| default | √ | √ | × | × |
| private | √ | × | × | × |
题目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
😎 解析：
- new Demo().test()： 先使用 Demo类的无参构造器创建对象，在无参构造器中，使用了 super() 调用了父类的无参构造器，因此先输出 Test，而后回到 Demo类 的无参构造器，输出 Demo。最后调用 test 方法，分别输出父类的属性和子类的属性，分别为 Rose 与 Jack；
- 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 的区别
| 名称 | 概念 | 数据类型 |
|---|---|---|
| == | 比较运算符 | 用于基本数据类型（判断值是否相等）和引用数据类型（判断两个对象是否相等） |
| equals | Object类的方法 | 只可用在引用数据类型，默认判断两个对象是否相等，但是一般对该方法进行重写，重写后判断对象的属性是否相等 |
题目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;
}
写在最后
🌟以上便是本文的全部内容啦，后续内容将会持续免费更新，如果文章对你有所帮助，麻烦动动小手点个赞 + 关注，非常感谢 ❤️ ❤️ ❤️ !
如果有问题，欢迎私信或者评论区！
共勉：“你间歇性的努力和蒙混过日子，都是对之前努力的清零。”
232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
