【Java练习题汇总】《第一行代码JAVA》面向对象基础篇，汇总Java练习题——面向对象：特性、类与对象、数组、String、内部类... ~

曾经终败给现在 2023-10-13 17:01 10阅读 0赞

#### Java练习题 · 面向对象基础篇 ####

*  1️⃣ 面向对象基础篇
 *  2️⃣ 答案

## 1️⃣ 面向对象基础篇 ##

一、填空题

1.  面向对象的三大特征：\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_。
2.  类由\_\_\_\_\_\_\_和\_\_\_\_\_\_\_组成。
3.  运算符\_\_\_\_\_\_\_的作用是根据对象的类型分配内存空间。当对象拥有内存空间时，会自动调用类中的\_\_\_\_\_\_\_为对象\_\_\_\_\_\_\_。
4.  使用\_\_\_\_\_\_\_修饰的类成员称为私有成员。私有成员只能在\_\_\_\_\_\_\_中使用。
5.  构造方法的名称与\_\_\_\_\_\_\_相同。
6.  \_\_\_\_\_\_\_关键字可以让类中的属性和方法对外部不可见。
7.  `this` 关键字可以调用本类中的\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_，调用\_\_\_\_\_\_\_时必须放在\_\_\_\_\_\_\_的首行。
8.  在 Java 中数组排序的方法是\_\_\_\_\_\_\_\_\_\_\_\_\_\_。

二、 选择题

1.  如果希望方法直接通过类名称访问，在定义时要使用的修饰符是( )。  
    A. static  
    B. final  
    C. abstract  
    D. this
2.  如果类中没有定义构造方法，系统会提供 一 个默认的构造方法。默认构造方法的特点是 ( )。  
    A. 无参数有操作  
    B. 有参数无操作  
    C. 既无参数也无任何操作  
    D. 有参数有操作
3.  有一个类 `Demo`, 对与其构造方法的正确声明是( )。  
    A. void Demo(int x)\{… \}  
    B. Demo(int x)\{… \}  
    C. Demo Demo(int x)\{… \}  
    D. int Demo()\{\}
4.  以下关于面向对象概念的描述中，不正确的一项是( )。  
    A. 在现实生活中，对象是指客观世界的实体  
    B. 程序中的对象就是现实生活中的对象  
    C. 在程序中，对象是通过一种抽象的数据类型来描述的，这种抽象数据类型称为类 (class)  
    D. 在程序中，对象是一组变量和相关方法的集合
5.  ( )不属于面向对象程序设计的基本要素。  
    A. 类  
    B. 对象  
    C. 方法  
    D. 安全
6.  下列程序的执行结果是( )。
    
        public class TestDemo {
              
        	public void fun(){
              
        		static int i=0;
        		i++;
        		System.out.println(i);
        	}
        	public static void main(String args[]){
              
        		TestDemo demo = new TestDemo();
        		demo.fun(;
        	}
        }
    
    A. 编译错误  
    B. 0  
    C. 1  
    D. 运行成功，但不输出
7.  顺序执行下列程序语句后，则b 的值是 ( )。
    
        String str = "Hello";
        String b = str.substring(0,2);
    
    A. Hello  
    B. hello  
    C. He  
    D. null

三、 判断题

1.  没有实例化的对象不能使用。 ( )
2.  不可以为类定义多个构造方法。 ( )
3.  使用 `static` 声明的方法可以调用非 `static` 声明的方法。 ( )
4.  非 `static` 声明的方法可以调用 `static`声明的属性或方法。 ( )
5.  String对象可以使用==进行内容的比较。 ( )
6.  垃圾是指无用的内存空间，会被垃圾收集机制回收。 ( )
7.  构造方法可以有返回值类型的声明。 ( )
8.  匿名对象是指使用一次的对象，使用之后将等待被垃圾回收。 ( )
9.  使用`static` 定义的内部类就成为外部类。 ( )
10. 多个实例化对象之间不会互相影响，因为保存在不同的内存区域之中。 ( )

四、 简答题

1.  String 类的操作特点。
2.  简述垃圾对象的产生。
3.  `static`方法如何调用? 非 `static` 方法如何调用?
4.  类与对象的关系是什么? 如何创建及使用对象?
5.  举例说明子类对象的实例化过程。
6.  简述 `this`与 `super` 关键字的区别。

五、 编程题

1.  编写并测试一个代表地址的 `Address` 类，地址信息由：国家，省份，城市，街道，邮编组成， 并可以返回完整的地址信息。
2.  定义并测试一个代表员工的 `Employee` 类。员工属性包括“编号”、"姓名”、“基本薪水”、“薪水增长额”，还包括 “计算增长后的工资总额”的操作方法。
3.  编写程序在将字符串 “`want you to know one thing`”, 统计出字母 “`n`”和 字母 “`o`”的出现次数。
4.  设计一个 `Dog` 类，有名字、颜色、年龄等属性，定义构造方法来初始化类的这些属性，定义方法输出 `Dog` 信息，编写应用程序使用`Dog` 类。
5.  字符串操作。  
    （1）从字符串 “`HELLO Java 技术学习20230713`” 中提取日期信息。  
    （2）将 “`Hello JAVA 高端技术培训学习`”字符串中的 “`Java`”替换为 “`JAVA EE`”。  
    （3）取出 “`Java 技术学习20230713`”中的第八个字符。  
    （4）清除 “`Java 技术学习20230713`”中的所有“`0`”。  
    （5）从任意给定的身份证号码中提取此人的出生日期。
6.  编写一个银行账户类，类的构成包括：  
    （1）数据成员：用户的账户名称、用户的账户余额；  
    （2）方法包括：开户(设置账户名称及余额)，利用构造方法完成；  
    （3）查询余额功能。

## 2️⃣ 答案 ##

一、填空题

1.  封装、继承、多态
2.  属性（成员变量）、方法
3.  `new`、构造方法、初始化
4.  `private`、本类
5.  类名
6.  `private`
7.  属性、方法、构造方法、构造方法、构造方法
8.  `Arrays.sort()`

二、 选择题

1.  A
2.  C
3.  B
4.  B
5.  D
6.  A
7.  C

三、 判断题

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

四、 简答题

1.  答：String类是不可变类，即字符串一旦被创建就不可修改。支持字符串连接操作符（+）来进行字符串拼接。  
    提供了丰富的方法用于字符串的处理，例如截取子串、查找字符等。可以通过 `equals()`方法比较两个字符串是否相等。
2.  答：垃圾对象指的是在程序中没有被任何引用变量所引用的对象。当一个对象不再被引用时，它变得不可达，这时候就有可能成为垃圾对象。垃圾对象的产生通常发生在以下情况下：  
    （1）对象的引用被赋值为null，使得原本引用的对象变得无法访问。  
    （2）对象的引用超出了作用域范围，例如在方法执行完成后，局部变量引用的对象就会成为垃圾对象。  
    （3）在动态数据结构中，当对象不再链表或树中时，就会成为垃圾对象。
3.  答：`static`方法可以直接通过类名来调用，例如`ClassName.staticMethodName()`。  
    非`static`方法需要先实例化对象，然后通过对象名来调用，例如`objectName.nonStaticMethodName()`。
4.  答：类是一个模板或蓝图，用于定义对象的属性和方法。它描述了具有相似特征和行为的一组对象。对象是类的实例化，是类的具体实体，拥有类中定义的属性和方法。  
    创建对象时首先声明对象的引用变量，然后使用`new`关键字和构造方法创建对象，最后将对象的引用赋值给引用变量。  
    使用对象时，通过对象的引用变量访问对象的属性和方法，可以调用对象的方法来执行相应的操作。
5.  答：假设有一个父类`Animal` 和子类 `Dog`，子类继承自父类。子类对象实例化的过程如下：
    
        Animal animal = new Dog();
    
    上述代码通过`new Dog()`创建了一个`Dog`类的对象，并将其赋值给了父类`Animal`类型的引用变量`animal`。这个过程称为向上转型（`Upcasting`）。因为子类是父类的一种类型，所以可以通过父类的引用变量来引用子类的对象。通过这样的实例化方式，可以使用`animal` 引用变量调用`Animal` 类中的方法，以及重写的被子类覆盖的方法。
6.  答：`this` 关键字代表当前对象的引用，可以用于访问当前对象的成员变量和方法。它主要用于区分局部变量和实例变量之间的命名冲突。  
    `super` 关键字代表父类对象的引用，可以用于调用父类的构造方法、成员变量和方法。它主要用于在子类中访问并调用父类的成员。

五、 编程题

1.  代码如下：
    
        // Address类
        class Address {
              
            private String country;
            private String province;
            private String city;
            private String street;
            private String postalCode;
        
            // 构造方法
            public Address(String country, String province, String city, String street, String postalCode) {
              
                this.country = country;
                this.province = province;
                this.city = city;
                this.street = street;
                this.postalCode = postalCode;
            }
        
            // 返回完整的地址信息
            public String getFullAddress() {
              
                return country + "省" + province + "市" + city + "街道" + street + "邮编" + postalCode;
            }
        }
2.  代码如下：
    
        // Employee类
        class Employee {
              
            private int id;
            private String name;
            private double baseSalary;
            private double salaryIncrease;
        
            // 构造方法
            public Employee(int id, String name, double baseSalary, double salaryIncrease) {
              
                this.id = id;
                this.name = name;
                this.baseSalary = baseSalary;
                this.salaryIncrease = salaryIncrease;
            }
        
            // 计算增长后的工资总额
            public double calculateTotalSalary() {
              
                return baseSalary + salaryIncrease;
            }
        }
3.  代码如下：
    
        // 统计字符出现次数的方法
        public class CharacterCount {
              
            public static void main(String[] args) {
              
                String str = "want you to know one thing";
                char target1 = 'n';
                char target2 = 'o';
        
                int count1 = countOccurrences(str, target1);
                int count2 = countOccurrences(str, target2);
        
                System.out.println("字母n出现的次数为：" + count1);
                System.out.println("字母o出现的次数为：" + count2);
            }
        
            public static int countOccurrences(String str, char target) {
              
                int count = 0;
                for (int i = 0; i < str.length(); i++) {
              
                    if (str.charAt(i) == target) {
              
                        count++;
                    }
                }
                return count;
            }
        }
4.  代码如下：
    
        // Dog类
        class Dog {
              
            private String name;
            private String color;
            private int age;
        
            // 构造方法
            public Dog(String name, String color, int age) {
              
                this.name = name;
                this.color = color;
                this.age = age;
            }
        
            // 输出Dog信息
            public void printInfo() {
              
                System.out.println("Name: " + name);
                System.out.println("Color: " + color);
                System.out.println("Age: " + age);
            }
        }
        
        // 在应用程序中使用Dog类
        public class DogApplication {
              
            public static void main(String[] args) {
              
                Dog dog = new Dog("Bobby", "Brown", 3);
                dog.printInfo();
            }
        }
5.  代码如下：
    
        // 字符串操作
        public class StringOperations {
              
            public static void main(String[] args) {
              
                // (1) 提取日期信息
                String str1 = "HELLO Java 技术学习20230713";
                String date = str1.substring(str1.lastIndexOf("学习") + 2);
                System.out.println(date);
        
                // (2) 替换字符串
                String str2 = "Hello JAVA 高端技术培训学习";
                String replacedStr = str2.replace("Java", "JAVA EE");
                System.out.println(replacedStr);
        
                // (3) 取出第八个字符
                String str3 = "Java 技术学习20230713";
                char eighthChar = str3.charAt(7);
                System.out.println(eighthChar);
        
                // (4) 清除所有0
                String str4 = "Java 技术学习20230713";
                String clearedStr = str4.replace("0", "");
                System.out.println(clearedStr);
        
                // (5) 提取出生日期
                String idNumber = "360402199001010001";
                String birthday = idNumber.substring(6, 14);
                System.out.println(birthday);
            }
        }
6.  代码如下：
    
        // 银行账户类
        class BankAccount {
              
            private String accountName;
            private double balance;
        
            // 构造方法。开户
            public BankAccount(String accountName, double balance) {
              
                this.accountName = accountName;
                this.balance = balance;
            }
        
            // 查询余额
            public double checkBalance() {
              
                return balance;
            }
        }

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

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

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