【Java练习题汇总】《第一行代码JAVA》入门介绍篇&程序基本概念篇，汇总Java练习题——基础语法：变量、数据类型、运算符、控制流... ~

小鱼儿 2023-10-13 13:24 22阅读 0赞

#### Java练习题 · 入门介绍篇&程序基本概念篇 ####

*  1️⃣ 入门介绍篇习题
 *  2️⃣ 程序基本概念篇习题
 *  3️⃣ 答案part1
 *  4️⃣ 答案part2

## 1️⃣ 入门介绍篇习题 ##

一、填空题

1.  Java 源程序文件的后缀是\_\_\_\_\_\_\_, Java 字节码文件的后缀名称是\_\_\_\_\_\_\_。
2.  Java 程序实现可移值性，依靠的是\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
3.  Java 语言的3个分支是：\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_。
4.  Java 程序由\_\_\_\_\_\_\_组成，如果Java 使用\_\_\_\_\_\_\_声明类，则文件名称必须与类名称一致。
5.  Java 执行是从\_\_\_\_\_\_\_方法开始执行的，此方法的完整定义是\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
6.  从命名标准上来讲， Java 类名的每个单词的首字母通常要求\_\_\_\_\_\_\_。
7.  当使用java 命令解释一个程序时， 一定需要\_\_\_\_\_\_\_环境属性来定位类资源路径。

二、 选择题

1.  ( ) 属于解释Java 程序所使用到的命令。  
    A. java.exe  
    B. javac.exe  
    C. keytool.exe  
    D. cmd.exe
2.  ( ) 环境变量是Java 解释时所需要的。  
    A. path  
    B. classpath  
    C. JAVA HOME  
    D. TEMP
3.  ( ) 开发方向不属于Java 定义的。  
    A. Java SE  
    B. Java EE  
    C. Java CE  
    D. Java ME

三、 判断题

1.  Java 语言属于编译型的开发语言。 ( )
2.  Java Application 程序不是由 main() 方法开始执行的。 ( )

四 、简答题

1.  简述 Java 实现可移植性的基本原理。
2.  简述 Java 语言的3个程序分支。
3.  简述 Java 中 path 及 classpath 的作用。
4.  简述 Java 语言的主要特点。
5.  详细阐述 Java 中使用 public class 或 class 声明一个类的区别及注意事项。

五、 编程题

1.  在屏幕上输出：“我喜欢学习 Java” 的信息。
2.  在屏幕上打印出以下的图形：  
    \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
    \*\*\*\*\*\*\*\*\* Java 程序设计 \*\*\*\*\*\*\*\*\*  
    \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

## 2️⃣ 程序基本概念篇习题 ##

一 、填空题

1.  Java 中的标识符组成原则是\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
2.  \_\_\_\_\_\_\_关键字是在JDK 1.4 时加入的，\_\_\_\_\_\_\_关键字是在JDK 1.5时加入的。
3.  列举出已经知道的5个关键字：\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
4.  Java 注释分为\_\_\_\_\_\_\_、\_\_\_\_\_\_\_和 \_\_\_\_\_\_\_ 3 种 。
5.  Java 中使用\_\_\_\_\_\_\_关键字，可以定义一个整型数据。
6.  在一个 Java 源文件中定义了3个类和15个方法，编译该Java 源文件时会产生\_\_\_\_\_\_\_个字节码文件，其扩展名是\_\_\_\_\_\_\_。
7.  布尔型数据类型的关键字是\_\_\_\_\_\_\_, 有\_\_\_\_\_\_\_和\_\_\_\_\_\_\_两种取值。
8.  整型数可以采用\_\_\_\_\_\_\_、\_\_\_\_\_\_\_ 、\_\_\_\_\_\_\_和\_\_\_\_\_\_\_4种类型表示。
9.  根据占用内存长度的不同，将浮点型分为\_\_\_\_\_\_\_和\_\_\_\_\_\_\_两种。
10. Java 程序结构分为\_\_\_\_\_\_\_、\_\_\_\_\_\_\_ 和 \_\_\_\_\_\_\_3种。
11. 逻辑表达式： true && false && true 的结果是\_\_\_\_\_\_\_。
12. 逻辑表达式： true ll false 的结果是\_\_\_\_\_\_\_。
13. 在方法中可以使用\_\_\_\_\_\_\_语句来结束方法的执行。
14. 方法中的\_\_\_\_\_\_\_关键字用来表示方法不返回任何值。

二、 选择题

1.  下面标识符正确的是( )。  
    A. class  
    B. hello world  
    C. 123$temp  
    D. Demo
2.  下 面 ( ) 是Java 中未使用到的关键字。(多选)  
    A. const  
    B. goto  
    C. int  
    D. assert
3.  public static void main 方法的参数描述是( )。  
    A. String args\[\]  
    B. int\[\] args  
    C. Strings args\[\]  
    D. String args
4.  下面说法正确的是( )。  
    A. Java 程序的源文件名称与主类(public class)的名称相同，后缀可以是 .java或 .txt 等  
    B. JDK 的编译命令是 java  
    C. 一个Java 源文件编译后可能产生多个class 文件  
    D. 在命令行编译好的字节码文件，只需在命令行直接键入程序名即可运行该程序
5.  下面说法不正确的是( )。  
    A.Java 语言是面向对象的、解释执行的网络编程语言  
    B.Java 语言具有可移植性，是与平台无关的编程语言  
    C. Java 语言可对内存垃圾自动收集  
    D. Java 语言执行时需要Java 的运行环境
6.  下面 ( ) 不 是Java 的关键字。  
    A. integer  
    B. double  
    C. float  
    D. char
7.  在 Java 中，字节数据类型的关键字和默认值是( )。  
    A. byte和 0  
    B. byte和 1  
    C. boolean和 true  
    D. boolean 和 false
8.  3.15E2表示的数据是( )。  
    A. 3.15 × 2  
    B. 3.15 × 10-²  
    C. 3.15 × 10²  
    D. 0.315 × 10-²
9.  程序 `System.out.println("1+1="+1+1);` 的输出结果是( ） 。  
    A. 1  
    B. 1+1=2  
    C. 1+1=11  
    D. 2
10. 程序 `System.out.println(10/3);` 的输出结果是( )。  
    A. 1  
    B. 3  
    C. 3.3  
    D. 3.33333
11. 执行下面的语句后， a、b、c 的值分别是( )。
    
        int a=2;
        int b= (a++)*3;
        int c= (++a)*3;
    
    A. 2 、6 、6  
    B. 4 、9 、9  
    C. 4 、6 、12  
    D. 3 、9 、9
12. 以下 ( ) 能正确表示Java 语言中的一个整型常量。  
    A. 35.d  
    B. -20  
    C. 1,234  
    D. “123”
13. 下面的数据类型( ) 是float型 。  
    A. 33.8  
    B. 129  
    C. 89L  
    D. 8.6F
14. 下列关于自动类型转换的说法中，正确的一个是( )。  
    A. int 类型数据可以自动转换为 char 类型数据  
    B. char 类型数据可以被自动转换为int类型数据  
    C. boolean 类型数据不可以做自动类型转换，但是可以做强制转换  
    D. long类型数据可以被自动转换为 short类型数据
15. 一个方法在定义过程中又调用自身，这种方法称为( )。  
    A. 构造方法  
    B. 递归方法  
    C. 成员方法  
    D. 抽象方法

三、 判断题

1.  变量的内容可以修改，常量的内容不可修改。 ( )
2.  goto是 Java 中未使用到的关键字。 ( )
3.  enum关键字是在JDK1.4 版本中增加的。 ( )
4.  使用 public class定义的类，文件名称可以与类名称不一致。 ( )
5.  主方法编写： public void main(String arg)。 ( )
6.  字符$不能作Java 标识符的第一个字符。 ( )
7.  System.out.println() 输出后是不加换行的，而System.out.print() 输出后是加换行的。 ( )
8.  使用 break 语句可以跳出一次循环。 ( )
9.  byte 的取值范围是0～255。 ( )
10. int 和 double 进行加法操作， int会自动转换为double 类型。 ( )
11. 使用“&”操作时，如果第一个条件是false,则后续的条件都不再判断。 ( )
12. 使用“&&”操作时，如果第一个条件是false,则后续的条件都不再判断。 ( )
13. 使用“ | ”操作时，如果第一个条件是true, 则后续的条件都不再判断。 ( )
14. 使用“ || ”操作时，如果第一个条件是true, 则后续的条件都不再判断。 ( )
15. 定义多个同名方法时，可以依靠返回值区别同名方法。 ( )

四、 简答题

1.  请解释常量与变量的区别。
2.  解释方法重载的概念，并举例说明。

五、 编程题

1.  打印出100～1000范围内的所有“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个“水仙花数"，因为153 = l³+5³+3’。
2.  通过代码完成两个整数内容的交换。
3.  判断某数能否被 3,5,7 同时整除。
4.  编写程序，分别利用 while循环、 do…while 循环和 for 循环求出100～200的累加和。

## 3️⃣ 答案part1 ##

一、填空题

1.  `.java`, `.class`
2.  `Java虚拟机（JVM）`
3.  `Java SE（Java Standard Edition，标准版 Java）`、`Java EE（Java Enterprise Edition，企业版 Java）`，`Java ME（Java Micro Edition，微型版 Java）`
4.  类与对象，`public Class`
5.  `main`，`public static void main(String[] args)`
6.  大写
7.  `CLASSPATH`

二、 选择题

1.  A
2.  A
3.  C

三、 判断题

1.  ( √ )
2.  ( × )

四 、简答题

1.  答：Java实现可移植性的基本原理是通过Java虚拟机（JVM）的存在。以下是简要的说明：  
    （1）JVM：Java程序在计算机上运行时，并不直接运行在物理硬件上，而是在一个虚拟机中运行，即JVM。JVM是Java平台的核心组件，负责解释和执行Java字节码。  
    （2）字节码：Java源代码被编译成一种称为字节码的中间形式。字节码是一种与特定硬件无关的二进制格式，可以在任何支持Java的平台上运行。这意味着同一个字节码文件可以在不同的操作系统、处理器架构和设备上运行。  
    （3）解释执行：JVM通过解释器将字节码逐条翻译成机器码执行。由于JVM负责具体的执行过程，因此Java程序对底层硬件的具体细节是抽象的，从而达到了可移植性的目标。不同操作系统和硬件架构只需要提供相应的JVM实现，而不需要修改Java程序本身。  
    （4）API（应用程序编程接口）：Java提供了丰富的标准类库和API，其中封装了对底层操作系统、网络、图形界面等的访问。使用这些标准库和API，开发者可以编写与特定平台无关的代码，从而实现跨平台的应用程序。
    
    综上所述，Java实现可移植性的基本原理是通过使用JVM作为中间层，将Java程序编译成与特定硬件无关的字节码，并由JVM解释执行。这种方式使得Java程序可以跨不同操作系统和硬件平台运行，提供了高度的可移植性。
2.  答：Java 语言的3个分支是：  
    （1）`Java SE（Java Standard Edition）`：标准版的 Java，用于开发桌面应用程序和一些通用的 Java 应用。  
    （2）`Java EE（Java Enterprise Edition）`：企业版的 Java，用于开发大型、分布式的企业级应用。它提供了很多扩展的功能和 API，包括数据库连接、消息传递、安全性管理等。  
    （3）`Java ME（Java Micro Edition）`：微型版的 Java，主要用于嵌入式设备和移动设备上的应用程序开发。它针对资源有限的设备进行了优化，并提供了一套特殊的 API 和库来支持这些设备的功能。
3.  答：在Java中，`path`和 `classpath` 是两个关键的系统变量，用于指定系统或JVM在运行时查找可执行文件和类文件的位置。  
    （1）`Path` 是一个操作系统级的环境变量，在不同的操作系统上可能有不同的设置方式。它定义了操作系统查找可执行文件的路径。在Java中，`Path`变量可以指定查找可执行文件（如JDK安装路径 `bin`目录下的可执行文件）的路径。当在命令行中运行Java应用程序时，操作系统会根据`Path`变量来搜索可执行文件的路径，从而能够直接使用命令行运行Java工具（如 `javac`和 `java`）。  
    （2）`Classpath` 是一个Java虚拟机（JVM）的系统属性，用于指定JVM在运行时查找类文件的路径。`Classpath`决定了JVM在加载Java类时的搜索路径。当需要加载类文件时，JVM将使用`classpath`变量指定的路径进行搜索，以找到所需的类文件。
    
    根据运行时需要，合理设置`Path`和 `classpath` 变量可以确保Java应用程序能够找到所需的可执行文件和类文件，从而顺利进行编译和执行。
4.  答：Java语言有以下主要特点：  
    （1）简洁性：Java的语法设计相对简单，易于学习和使用。它摒弃了一些复杂的特性，如指针和多继承，使得代码更易于理解、调试和维护。  
    （2）面向对象：Java是面向对象的编程语言，支持封装、继承和多态等面向对象的概念。通过类和对象的机制，可以更好地组织和管理代码，并提高代码的可重用性和灵活性。  
    （3）平台无关性：一次编写，到处运行是Java的重要优势。Java应用程序编译成与平台无关的字节码，然后在任何支持Java虚拟机（JVM）的平台上运行。这使得Java具有很高的可移植性，可以在不同的操作系统和硬件架构上运行。  
    （4）安全性：Java在设计时注重安全性。它提供了安全性管理机制，包括访问控制、异常处理和内存管理等，以减少潜在的安全漏洞。此外，Java的执行环境中有一个安全沙箱，限制了代码对系统资源的直接访问，防止恶意攻击。  
    （5）多线程支持：Java提供了内置的多线程支持，使得开发人员可以方便地编写并发程序。通过多线程，可以实现同时执行多个任务，提高程序的效率和响应性。  
    （6）高性能：尽管Java是解释执行的语言，但通过`Just-In-Time（JIT）`编译技术，它能够在运行时将热点代码编译成本地机器码，提供接近于原生代码的性能。此外，Java还优化了内存管理和垃圾回收，减少了手动内存管理的负担。
5.  答：在Java中，使用`public class`或`class`来声明一个类有以下区别：  
    （1）可见性：使用`public class`声明的类是公共类，可以被其他类访问到。这意味着其他包内的类和不同包中的类都可以使用这个类。而使用`class`声明的类则具有默认可见性，只能被同一包内的其他类访问。  
    （2）文件命名：在Java中，如果文件名与公共类的名称匹配，那么文件必须以.java扩展名保存。这意味着当使用`public class`声明一个公共类时，文件名必须与公共类的名称完全一致。但是，使用`class`声明的类没有这个限制，文件名可以与类的名称不同。

五、 编程题

1.  代码如下：

public class OutputExample {
        
        public static void main(String[] args) {
        
            System.out.println("我喜欢学习 Java");
        }
    }

1.  代码如下：

public class PrintExample {
        
        public static void main(String[] args) {
        
            // 第一行
            for (int i = 0; i < 36; i++) {
        
                System.out.print("*");
            }
            
            // 第二行
            System.out.println();
            System.out.println("********* Java 程序设计 *********");
            
            // 第三行
            for (int i = 0; i < 36; i++) {
        
                System.out.print("*");
            }
        }
    }

## 4️⃣ 答案part2 ##

一 、填空题

1.  可以包含字母、数字、下划线和美元符号，不能以数字开头，区分大小写，并且不能使用保留关键字。
2.  `assert`，`enum`
3.  `public`、`class`、`static`、`void`、`if`（其他的关键字也行）
4.  单行注释、多行注释、文档注释
5.  `int`
6.  3，`.class`
7.  `boolean`，`true`（真）和`false`（假）
8.  `byte`（字节）、`short`（短整型）、 `int`（整型）、 `long`（长整型）
9.  `float`（单精度浮点型）、`double`（双精度浮点型）
10. 顺序结构、分支结构（选择结构）、循环结构
11. `false`
12. `true`
13. `return`
14. `void`

二、 选择题

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

三、 判断题

1.  ( √ )
2.  ( √ )
3.  ( × )
4.  ( × )
5.  ( × )
6.  ( × )
7.  ( × )
8.  ( √ )
9.  ( √ )
10. ( √ )
11. ( × )
12. ( √ )
13. ( × )
14. ( √ )
15. ( × )

四、 简答题

1.  答：常量和变量在编程中具有不同的特性和用途：  
    （1）常量是指在程序执行过程中其值保持不变的数据。常量的值在定义后不能被修改。例如，数学中的π (pi) 或者一个固定的字符串常量。  
    （2）变量是指在程序执行过程中其值可以被修改的存储空间。变量用于存储和表示可以在程序运行过程中发生变化的数据。变量需要声明类型，并且可以在声明后赋予新的值。
2.  答：方法重载是指在同一个类中，可以有多个具有相同名称但参数列表不同的方法。这些方法可以具有不同的参数类型、不同的参数数量或者不同的参数顺序。方法重载允许使用相同的方法名来表示具有类似功能但参数不同的行为，从而提高代码的可读性和灵活性。
    
    通过方法重载，我们可以根据不同的参数来选择合适的方法进行调用，使代码更加灵活和可扩展。它与方法的返回类型无关，所以方法重载不仅仅是因为返回类型不同而实现的。
    
    下面是一个简单的方法重载的示例：
    
        public class Calculator {
              
            public int add(int a, int b) {
              
                return a + b;
            }
        
            public float add(float a, float b) {
              
                return a + b;
            }
        
            public int add(int a, int b, int c) {
              
                return a + b + c;
            }
        }
    
    在上述示例中，Calculator 类定义了三个名为 add 的方法，它们都来完成两个或三个数相加的功能。这三个方法具有相同的方法名 “add”，但是参数列表不同：第一个方法接收两个 int 类型的参数，第二个方法接收两个 float 类型的参数，第三个方法接收三个 int 类型的参数。这样，根据参数的不同，我们可以调用适合的方法来执行相应的加法操作。

五、 编程题

1.  代码如下：
    
        public class NarcissisticNumbers {
              
            public static void main(String[] args) {
              
                for (int i = 100; i <= 1000; i++) {
              
                    if (isNarcissisticNumber(i)) {
              
                        System.out.println(i);
                    }
                }
            }
        
            // 判断一个数是否为水仙花数
            public static boolean isNarcissisticNumber(int number) {
              
                int sum = 0;
                int temp = number;
                while (temp != 0) {
              
                    int digit = temp % 10;
                    sum += Math.pow(digit, 3);
                    temp /= 10;
                }
                return sum == number;
            }
        }
2.  代码如下：
    
        public class SwapVariables {
              
            public static void main(String[] args) {
              
                int a = 5;
                int b = 10;
        
                System.out.println("交换前：");
                System.out.println("a = " + a);
                System.out.println("b = " + b);
        
                int temp = a;
                a = b;
                b = temp;
        
                System.out.println("交换后：");
                System.out.println("a = " + a);
                System.out.println("b = " + b);
            }
        }
3.  代码如下：
    
        public class DivisibilityCheck {
              
            public static void main(String[] args) {
              
                int number = 105; // 要判断的数字
        
                if (number % 3 == 0 && number % 5 == 0 && number % 7 == 0) {
              
                    System.out.println(number + " 可以同时被3、5和7整除");
                } else {
              
                    System.out.println(number + " 不能同时被3、5和7整除");
                }
            }
        }
4.  代码如下：  
    （1）使用`while`循环：
    
        public class SumWhileLoop {
              
            public static void main(String[] args) {
              
                int num = 100;
                int sum = 0;
        
                while (num <= 200) {
              
                    sum += num;
                    num++;
                }
        
                System.out.println("累加和为: " + sum);
            }
        }
    
    （2）使用`do...while`循环：
    
        public class SumDoWhileLoop {
              
            public static void main(String[] args) {
              
                int num = 100;
                int sum = 0;
        
                do {
              
                    sum += num;
                    num++;
                } while (num <= 200);
        
                System.out.println("累加和为: " + sum);
            }
        }
    
    （3）使用`for`循环：
    
        public class SumForLoop {
              
            public static void main(String[] args) {
              
                int sum = 0;
        
                for (int num = 100; num <= 200; num++) {
              
                    sum += num;
                }
        
                System.out.println("累加和为: " + sum);
            }
        }
    
    这三段代码分别使用`while`循环、`do...while`循环和`for`循环在100到200之间进行累加求和。它们的输出结果都将打印出累加和。

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

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

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