【Java练习题汇总】《第一行代码JAVA》面向对象进阶篇，汇总Java练习题——面向对象：特性详解、关键字this、super、instanceof、final、static、抽象类与接口... ~

柔情只为你懂 2023-10-13 19:03 2阅读 0赞

#### Java练习题 · 面向对象进阶篇 ####

*  1️⃣ 面向对象进阶篇
 *  2️⃣ 答案

## 1️⃣ 面向对象进阶篇 ##

一、填空题

1.  Java 中通过\_\_\_\_\_\_\_关键字实现继承。
2.  一个类只能继承\_\_\_\_\_\_\_个父类，但能实现\_\_\_\_\_\_\_个接口。
3.  \_\_\_\_\_\_\_ 类是所有类的父类，该类中判断两个对象是否相等的方法是\_\_\_\_\_\_\_，取得对象完整信息的方法是\_\_\_\_\_\_\_。
4.  `Integer` 类是对\_\_\_\_\_\_\_基本数据类型的封装。 `Float` 类是对\_\_\_\_\_\_\_基本数据类型的封装。 `Double`类是对\_\_\_\_\_\_\_ 基本数据类型的封装。字符类`Character` 是对\_\_\_\_\_\_\_基本数据类型的封装。
5.  当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时，称子类方法\_\_\_\_\_\_\_父类方 法，子类默认使用\_\_\_\_\_\_\_方法，使用父类的同名方法，必须使用\_\_\_\_\_\_\_关键字说明。
6.  当子类定义的成员变量与父类的成员变量同名时，称子类\_\_\_\_\_\_\_父类的成员变量，子类默认使用\_\_\_\_\_\_\_属性。使用父类的同名成员变量，必须用\_\_\_\_\_\_\_关键字说明。
7.  如果子类定义了构造方法，在创建子类对象时首先默认调用\_\_\_\_\_\_\_，然后调用本类的构造方法。

二、选择题

1.  不能直接使用 `new` 创建对象的类是( )。  
    A. 静态类  
    B. 抽象类  
    C. 最终类  
    D. 公有类
2.  为类定义多个名称相同，但参数的类型或个数不同的方法的做法称为( )。  
    A. 方法重载  
    B. 方法覆写  
    C. 方法继承  
    D. 方法重用
3.  定义接口的关键字是( )。  
    A. extends  
    B. class  
    C. interface  
    D. public
4.  现在有两个类`A`、`B`, 以下描述中表示`B` 继承自`A` 的是 ( )。  
    A. class A extends B  
    B. class B implements A  
    C. class A implements B  
    D. class B extends A
5.  下面关于子类调用父类构造方法的描述正确的是( )。  
    A. 子类定义了自己的构造方法，就不会调用父类的构造方法  
    B. 子类必须通过super 关键字调用父类有参的构造方法  
    C. 如果子类的构造方法没有通过 super 调用父类的构造方法，那么子类会先调用父类中无参构 造方法，再调用子类自己的构造方法  
    D. 创建子类对象时，先调用子类自己的构造方法，让后再调用父类的构造方法
6.  假设类`X` 是类`Y` 的父类，下列声明对象`x` 的语句中不正确的是( )。  
    A. X x = new X();  
    B. X x = new Y();  
    C. Y x = new Y();  
    D. Y x = new X();
7.  编译并运行下面的程序，结果是( )。
    
        public class A {
              
        	public static void main(String args[]){
              
        		B  b = new  B();
        		b.test();
        	}
        	void test(){
              
        		System.out.print("A");
        	}
        }
        
        class B extends A{
              
        	void test(){
              
        		super.test();
        		System.out.println("B");
        	}
        }
    
    A. 产生编译错误，因为类B 覆盖类A 的方法 test()时，降低了其访问控制的级别  
    B. 代码可以编译运行，并输出结果： AB  
    C. 代码可以编译运行，但没有输出  
    D. 代码可以编译运行，并输出结果： A
8.  ( )修饰符所定义的方法必须被子类所覆写。  
    A. final  
    B. abstract  
    C. static  
    D. interface
9.  ( )修饰符所定义的方法不能被子类所覆写。  
    A. final  
    B. abstract  
    C. static  
    D. interface
10. 下面的程序编译运行的结果是( )。
    
        public class A implements B{
              
        	public static void main(String args[]){
              
        		int  m,n;
        		A a = new A();
        		m = a.K;
        		n = B.K;
        		System.out.println(m+","+n);
        	}
        }
        
        interface B{
              
        	int K=5;
        }
    
    A.5,5  
    B.0,5  
    C. 0,0  
    D. 编译程序产生编译结果
11. 下面关于接口的说法中不正确的是( )。  
    A. 接口所有的方法都是抽象的  
    B. 接口所有的方法一定都是 public类型  
    C. 用于定义接口的关键字是 implements  
    D. 接口是Java 中的特殊类，包含全局常量和抽象方法
12. 下面关于Java 的说法不正确的是( )。  
    A. abstract和 final 能同时修饰一个类  
    B. 抽象类不光可以做父类，也可以做子类  
    C. 抽象方法不一定声明在抽象类中，也可以在接口中  
    D. 声明为 final的方法不能在子类中覆写

三、判断题

1.  `final`声明的类可以有子类。 ( )
2.  一个类继承了抽象类，则抽象类中的抽象方法需要在其子类中覆写。 ( )
3.  `final`类型的变量是常量，其内容不可改变。 ( )
4.  一个类不能既是子类又是父类。 ( )
5.  子类只能继承父类的成员，但不能修改父类成员。 ( )
6.  Java 语言只支持单继承，不支持多继承。 ( )
7.  子类可以继承父类的所有成员。 ( )
8.  一个接口可以继承一个抽象类。 ( )
9.  一个接口可以同时继承多个接口。 ( )
10. 在程序中 `this`和 `super`调用构造方法时可以同时出现。 ( )

四、 简答题

1.  简述 this与 super 关键字的区别。
2.  简述方法的重载与覆写的区别。
3.  在已有类的基础上派生新的类有什么好处?
4.  如何区分子类和父类?子类可以继承父类的哪些内容?
5.  什么是多态?实现都态的方法有哪些?
6.  接口有哪些特征?如何定义和实现接口?
7.  接口和抽象类有哪些区别?
8.  简述基本数据类型的自动装箱及自动拆箱操作。

五、编程题

1.  定义一个 `ClassName` 接口，接口中只有一个抽象方法 `getClassName()`。 设计一个类 `Company`, 该类实现接口 `ClassName` 中的方法 `getClassName()`,功能是获取该类的类名称。编写应用程序使用 `Company` 类。
2.  建立一个人类(`Person`) 和学生类 (`Student`) 功能要求：  
    A. `Person` 中包含4个保护型的数据成员 `name`、`address`、`sex`、`age` 分别为字符串、字符串、字符及整型。表示：姓名、地址、性别和年龄。 一个四参构造方法， 一个无参构造方法，及一个输出方法用于显示四种属性。  
    B. `Student` 继承 `Person`, 并增加输出成员 `math`、`english` 存放数学和英语成绩。 一个六参构造方法， 一个两参构造方法， 一个无参构造方法，重写输出方法用于显示全部六种属性。
3.  定义员工类，具有姓名、年龄、性别属性，并具有构造方法，显示数据方法。定义管理层类， 继承员工类，并有自己的属性：职务、年薪。定义职员类，继承员工类，并有自己的属性：所属部门、月薪。
4.  定义类 `Shape` 表示一般二维图形。 `Shape` 具有抽象方法 `area` 和 `perimeter`,分别计算形状的面积和周长。试定义一些二维形状类(如矩形、三角形、圆形等)，这些类均为`Shape` 类的子类。

## 2️⃣ 答案 ##

一、填空题

1.  `extends`
2.  一个，多个
3.  `Object` ， `equals()`， `toString()`
4.  整数，浮点数，双精度浮点数，字符
5.  重写（override），子类，`super`
6.  重写（override），子类，`super`
7.  父类的无参构造方法

二、选择题

1.  B
2.  A
3.  C
4.  D
5.  B
6.  D
7.  B
8.  B
9.  A
10. A
11. C
12. A

三、判断题

1.  ( ❌ )
2.  ( ✔️ )
3.  ( ✔️ )
4.  ( ❌ )
5.  ( ✔️ )
6.  ( ✔️ )
7.  ( ✔️ )
8.  ( ❌ )
9.  ( ✔️ )
10. ( ❌ )

四、 简答题

1.  答：this 关键字用于引用当前对象，可以解决成员变量与局部变量同名的问题，也可用于调用当前类的构造方法。super 关键字用于访问父类的成员变量和方法，也可用于调用父类的构造方法。区别在于：
    
     *  `this` 关键字是对当前对象的引用，指代当前类的对象，用于访问当前类的实例变量、实例方法或者调用当前类的构造方法。
     *  `super` 关键字是对父类的引用，用于访问父类的实例变量、实例方法或者调用父类的构造方法。
2.  答：方法重载（Overload）指在同一个类中定义多个同名但参数列表不同的方法，可以通过不同的参数来实现不同的功能。方法覆写（Override）指子类重新定义了父类中具有相同名称和参数列表的方法，以实现自己的特定行为。区别在于：
    
     *  重载是在同一个类中定义多个方法，方法名相同但参数列表不同，返回值可以相同也可以不同。
     *  覆写是子类重写父类的方法，方法名、参数列表和返回值必须相同。
3.  答：派生新的类的好处包括：
    
     *  可以在已有类的基础上进一步扩展功能，满足新的需求。
     *  可以避免重复编写已有类中的代码，提高代码的复用性。
     *  可以实现软件的模块化和层次化设计，方便维护和修改。
4.  答：子类是继承自父类的类。区分子类和父类的方式：
    
     *  子类通过 `extends` 关键字继承父类。
     *  子类可以使用父类的成员变量和方法，包括公共（public）、受保护（protected）和默认（默认修饰符）权限的成员。
     *  子类可以在父类基础上添加新的成员变量和方法。
     *  子类可以覆写父类的方法来实现个性化的功能。
5.  答：多态是指同一种类型的对象，在不同情况下展现出不同的行为。实现多态的方法有：
    
     *  方法覆写（Override）：子类重写父类的方法，通过父类引用调用方法时，执行子类中的方法。
     *  方法重载（Overload）：在同一个类中定义多个同名但参数列表不同的方法，通过参数类型和数量的不同，实现不同的行为。
6.  答：接口的特征包括：
    
     *  接口定义了一组方法的规范，没有方法体，只有方法签名。
     *  接口可以被类实现，一个类可以实现一个或多个接口。
     *  接口是多继承的，在接口中可以定义常量（`public static final`）和抽象方法（`public abstract`）。
     *  接口通过 `interface` 关键字进行定义。
7.  答：接口和抽象类的区别包括：
    
     *  接口定义了一组方法规范，只包含抽象方法和常量，而抽象类除了可以包含抽象方法外，还可以包含具体方法和成员变量。
     *  类可以实现多个接口，但只能继承一个抽象类。
     *  接口中的方法默认是公共的，而抽象类中的方法可以有不同的访问权限。
     *  接口中的成员变量默认是常量（`public static final`），而抽象类中的成员变量没有这种限制。
8.  答：基本数据类型的自动装箱（`Autoboxing`）是指将基本数据类型自动转换为对应的包装类对象，而自动拆箱（`Unboxing`）是指将包装类对象自动转换为对应的基本数据类型。例如：
    
     *  自动装箱：`int` 类型的变量可以自动转换为 `Integer` 类型的对象。
     *  自动拆箱：`Integer` 类型的对象可以自动转换为 `int` 类型的变量。
    
    这种自动转换的机制方便了基本数据类型与其包装类之间的相互转换，使得代码更加简洁。

五、编程题

1.  代码如下：
    
        // 定义 ClassName 接口
        interface ClassName {
              
            String getClassName();
        }
        
        // 实现 ClassName 接口的 Company 类
        class Company implements ClassName {
              
            @Override
            public String getClassName() {
              
                return this.getClass().getSimpleName();
            }
        }
        
        // 应用程序示例
        public class Main {
              
            public static void main(String[] args) {
              
                Company company = new Company();
                String className = company.getClassName();
                System.out.println("Class name: " + className);
            }
        }
2.  代码如下：
    
        // Person class
        public class Person {
              
            protected String name;
            protected String address;
            protected char gender;
            protected int age;
        
            // Four-argument constructor
            public Person(String name, String address, char gender, int age) {
              
                this.name = name;
                this.address = address;
                this.gender = gender;
                this.age = age;
            }
        
            // Default constructor
            public Person() {
              
            }
        
            // Method to display attributes
            public void displayAttributes() {
              
                System.out.println("Name: " + name);
                System.out.println("Address: " + address);
                System.out.println("Gender: " + gender);
                System.out.println("Age: " + age);
            }
        }
        
        // Student class inheriting from Person
        public class Student extends Person {
              
            private double math;
            private double english;
        
            // Six-argument constructor
            public Student(String name, String address, char gender, int age, double math, double english) {
              
                super(name, address, gender, age);
                this.math = math;
                this.english = english;
            }
        
            // Two-argument constructor
            public Student(double math, double english) {
              
                this.math = math;
                this.english = english;
            }
        
            // Default constructor
            public Student() {
              
            }
        
            // Overriding method to display all six attributes
            @Override
            public void displayAttributes() {
              
                super.displayAttributes();
                System.out.println("Math Score: " + math);
                System.out.println("English Score: " + english);
            }
        }
3.  代码如下：
    
        // Employee class
        public class Employee {
              
            protected String name;
            protected int age;
            protected char gender;
        
            // Constructor
            public Employee(String name, int age, char gender) {
              
                this.name = name;
                this.age = age;
                this.gender = gender;
            }
        
            // Method to display data
            public void displayData() {
              
                System.out.println("Name: " + name);
                System.out.println("Age: " + age);
                System.out.println("Gender: " + gender);
            }
        }
        
        // Management class inheriting from Employee
        public class Management extends Employee {
              
            private String position;
            private double annualSalary;
        
            // Constructor
            public Management(String name, int age, char gender, String position, double annualSalary) {
              
                super(name, age, gender);
                this.position = position;
                this.annualSalary = annualSalary;
            }
        
            // Method to display data
            public void displayData() {
              
                super.displayData();
                System.out.println("Position: " + position);
                System.out.println("Annual Salary: " + annualSalary);
            }
        }
        
        // Staff class inheriting from Employee
        public class Staff extends Employee {
              
            private String department;
            private double monthlySalary;
        
            // Constructor
            public Staff(String name, int age, char gender, String department, double monthlySalary) {
              
                super(name, age, gender);
                this.department = department;
                this.monthlySalary = monthlySalary;
            }
        
            // Method to display data
            public void displayData() {
              
                super.displayData();
                System.out.println("Department: " + department);
                System.out.println("Monthly Salary: " + monthlySalary);
            }
        }
4.  代码如下：
    
        // Shape class
        public abstract class Shape {
              
            public abstract double area();
            public abstract double perimeter();
        }
        
        // Rectangle class inheriting from Shape
        public class Rectangle extends Shape {
              
            private double width;
            private double height;
        
            public Rectangle(double width, double height) {
              
                this.width = width;
                this.height = height;
            }
            
            @Override
            public double area() {
              
                return width * height;
            }
        
            @Override
            public double perimeter() {
              
                return 2 * (width + height);
            }
        }
        
        // Triangle class inheriting from Shape
        public class Triangle extends Shape {
              
            private double side1;
            private double side2;
            private double side3;
        
            public Triangle(double side1, double side2, double side3) {
              
                this.side1 = side1;
                this.side2 = side2;
                this.side3 = side3;
            }
            
            @Override
            public double area() {
              
                double s = (side1 + side2 + side3) / 2; // semi-perimeter
                return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
            }
        
            @Override
            public double perimeter() {
              
                return side1 + side2 + side3;
            }
        }
        
        // Circle class inheriting from Shape
        public class Circle extends Shape {
              
            private double radius;
        
            public Circle(double radius) {
              
                this.radius = radius;
            }
            
            @Override
            public double area() {
              
                return Math.PI * radius * radius;
            }
        
            @Override
            public double perimeter() {
              
                return 2 * Math.PI * radius;
            }
        }

--------------------

[ ![fb1675ea0fe24c47b2b32baf16af9fbe.gif][] ][_fb1675ea0fe24c47b2b32baf16af9fbe.gif_]

[fb1675ea0fe24c47b2b32baf16af9fbe.gif]: https://img-blog.csdnimg.cn/fb1675ea0fe24c47b2b32baf16af9fbe.gif
[_fb1675ea0fe24c47b2b32baf16af9fbe.gif_]: https://lst66.blog.csdn.net/?type=blog