JAVA入门速成(二)-判断

发布于 2023-05-01 695 次阅读

设类B是类C的父类，语句B x1=new C( );

正确
向上转型是可以的，它是将一个子类对象赋值给一个父类类型的变量。这样做是合理的，因为子类对象具有父类对象所有的属性和方法，因此可以用父类类型的变量来引用子类对象，但是只能使用父类的属性和方法。例如，如果有一个Dog类和一个Animal类，Dog是Animal的子类，那么可以将一个Dog对象赋值给一个Animal类型的变量，即进行向上转型。

设类B是类C的父类，语句Ｃ x1=new Ｂ( );

错误
将父类转换成子类是不合理的，因为父类对象不具备子类独有的属性和方法，因此不能用子类类型的变量来引用父类对象，也无法使用子类独有的属性和方法。如果强制进行这种转换，可能会导致程序出错

Java中的包是专门用来存放类的，通常功能相近的类存放在相同的包中。

正确
在Java中，包是一种将相关类组织在一起的机制。通过使用包，开发人员可以更好地组织和管理代码，避免类名冲突，并且可以在代码中更清晰地表达类之间的关系。

Java中的String类型是一种基本数据类型。

错误
虽然Java中的基本数据类型包括int、double、boolean等，但是String类型不是其中之一。String类型是一种引用数据类型，也就是说，它的值是一个对象，而不是简单的数值。在Java中，String类型用于表示一串字符序列，通常用于存储文本信息。

在Java中，含有抽象方法的类一定是抽象类。

正确
在Java中，如果一个类含有一个或多个抽象方法，那么这个类必须被声明为抽象类。抽象类不能被实例化，只能被用作其他类的父类，而这些子类必须实现抽象类中的所有抽象方法。如果一个类继承自一个抽象类，但没有实现抽象类中的所有抽象方法，那么这个类也必须声明为抽象类。

private修饰的成员变量不能被子类继承，因此在子类中也不为该类型变量分配空间。

错误
私有（private）修饰的成员变量不能被子类继承，但是该成员变量仍然会被继承并分配空间。在子类中，可以通过调用父类的方法或者间接地调用父类的构造函数来访问该私有成员变量。

String对象和StringBuffer对象都是字符串类型，创建后的对象都可以在原地进行修改。

错误
在Java中，String对象是不可变的，一旦创建了一个String对象，它的值就不能被修改。例如，下面的代码创建了一个String对象并将其赋值给s1，然后使用s1调用toUpperCase()方法将其转换为大写形式，但是s1本身并没有被修改，而是返回了一个新的String对象：
```
arduinoCopy codeString s1 = "hello";
String s2 = s1.toUpperCase(); // s2 的值为 "HELLO"
System.out.println(s1); // 输出 "hello"
```

相比之下，StringBuffer对象是可变的。可以在原地对其进行修改，例如追加、插入、删除等操作。下面是一个简单的示例：

goCopy codeStringBuffer sb = new StringBuffer("hello");
sb.append(" world"); // 在字符串末尾追加 " world"
System.out.println(sb); // 输出 "hello world"

因此，String对象和StringBuffer对象有本质的区别，不能将它们混淆。

在JAVA的集合框架中，Map接口是自Collection接口继承而来。

错误
在Java的集合框架中，Map接口不是自Collection接口继承而来。Collection接口继承了Iterable接口，而Map接口则没有继承任何接口。Map接口与Collection接口有很大的区别，Collection接口用于表示一组对象，而Map接口则用于表示键值对的映射。

在FileInputStream类的对象中，利用read(byte[] bytes)和read(byte[] bytes,int off,int len)方法读取一次数据后，bytes数组中的所有数据都是本次读取的数据。

错误
read(byte[] bytes)方法从文件中读取数据，将其存储在bytes数组中，并返回读取的字节数。
read(byte[] bytes, int off, int len)方法将最多len个字节的数据读入bytes数组中，从数组的off位置开始存储读取的数据，并返回实际读取的字节数。
在FileInputStream类的对象中，利用read(byte[] bytes)和read(byte[] bytes, int off, int len)方法读取一次数据后，bytes数组中只有读取的数据被填充到数组中，其他位置的值不会被修改。

多线程是指将CPU资源按时间片分配到多个任务上，看似并行工作，实质上在同一时刻只有一个线程在工作；在一段时间之内，是多个线程在同时工作。

正确

在Java中，输出格式字符串时，也可以利用printf方法进行格式控制。

正确

利于Scanner类的对象进行输入字符串时，使用next()或者nextLine()方法都能取得字符串，二者没有什么差别。

错误
next()和nextLine()方法有一定的差别。
next()方法返回输入的下一个字符串（不包含空格），如果输入的字符串中包含空格，则只返回第一个空格前的部分。而nextLine()方法则是读取输入中的一行，包括换行符，返回该行的字符串。

因此，如果需要获取整行输入，则应该使用nextLine()方法。如果只需要获取下一个字符串，且该字符串不包含空格，则可以使用next()方法。

我们编写出程序之后，在必要的时候，可以通过DEBUG模式来调试程序，单步执行程序，观察变量的值的变化，从而尽快发现程序的逻辑错误。

正确

不含公共类的JAVA源文件名称可以随便命名，不受任何限制。

正确
Java源文件的命名必须与其内部定义的类名称相同，且大小写必须一致。如果一个Java源文件中只有一个类，并且这个类是公共类，那么这个源文件的文件名必须与公共类的名称相同。如果一个Java源文件中包含多个类，那么只能有一个类是公共类，这个公共类的名称必须与文件名相同。==其他情况的类的名称可以随意取。==

在Windows操作系统和Linux操作系统运行的JAVA虚拟机没有什么差别。（）

错误
虽然Java虚拟机在不同操作系统上的工作原理是相同的，但是由于操作系统的不同，Java虚拟机在不同操作系统上的实现也会有所差异，比如文件路径的表示方式、进程管理方式等。因此，在不同操作系统上运行的Java虚拟机也会有所差别。

运行类路径下的HelloWorld.class文件，使用的命令是：java HelloWorld.class 。

错误
运行类路径下的HelloWorld.class文件，应该使用命令：java HelloWorld。不需要加上“.class”后缀。

使用集成开发工具Eclipse来开发程序，可以省去源程序的编译步骤，直接运行程序。

错误

编译当前路径下的HelloWorld.java文件，使用的命令是：javac HelloWorld.java 。

正确

Java源程序中的字母大小写敏感，而在源文件命名时字母大小写不敏感。

错误
在源文件命名时，字母的大小写是敏感的，因为在不同的操作系统中，文件名的大小写规则可能不同，因此应该遵循Java的命名规范来命名文件，例如类名和文件名应该完全一致，而且要使用驼峰命名法。

不含公共类的JAVA源文件名称可以随便命名，不受任何限制。

正确
和14.一样

运行类路径下的HelloWorld.class文件，使用的命令是：java HelloWorld.class 。

错误

Java语言和C语言一样，是面向过程的语言。

错误
c面向过程,Java面向对象

1991年JDK1.0版本发布。

错误

James Gosling是Java语言的创始人之一。

正确

Java虚拟机可以将类文件（.class）在不同的操作系统上运行，从而实现跨平台特性。

正确
Java虚拟机是为了实现Java程序的跨平台性而设计的，它可以将编写好的Java代码编译为字节码（.class文件），然后在不同的操作系统上运行。因为不同操作系统的硬件和软件环境不同，所以JVM充当了中间层，通过解释和执行字节码实现了Java程序的跨平台特性。

Java源程序中的字母大小写敏感，源文件名字母大小写不敏感。

错误

一个Java源文件的名称可以随便取，不受任何限制。

错误
Java源文件的命名必须与公共类的类名相同，且必须以".java"作为文件扩展名。否则编译器将无法正确识别源文件中定义的类。

java.lang包的Character类的isJavaIdentifierStart()方法的功能是用来判断某个字符串是否为合法Java标识符。

错误

java.lang包的Character类的isJavaIdentifierStart方法的功能是用来判断某个字符是否为合法Java标识符首字符。

正确
Java中的Character类的isJavaIdentifierStart()方法用于判断给定的字符是否可以作为Java标识符的开始部分。Java标识符是用于表示变量、类、方法等名称的字符串，它由字母、数字、下划线（_）和美元符号（$）组成，但必须以字母、下划线或美元符号开头。isJavaIdentifierStart()方法返回一个布尔值，表示给定的字符是否可以作为Java标识符的开始部分。

java.util.Arrays类提供了诸多对数组进行操作的方法。使用其toString()方法可以对一维数组和二维数组展示其元素数值，equals()方法对一维数组和二维数组的两个数组比较其元素内容数值是否对应相等。

错误
使用Arrays类的toString()方法可以对一维数组和二维数组展示其元素数值，但是该方法对于二维数组只能展示第一维数组的地址信息，不能展示其内部的元素。Arrays类的equals()方法可以比较一维数组的内容是否相等，但对于二维数组的比较需要自行实现。

两个数组对象利用“\==”运算符比较若相等，则两数组的各个元素值一定对应相等；反过来说，两个数组的元素值都对应相等，则两个数组一定相等（==）。

错误
两个类满足==则地址一致,两个类指向同一个地址则元素一定相等,元素都相等不一定指向同一个地址
如果需要比较两个数组是否包含相同的元素值，需要使用Arrays.equals()方法。

和C语言相似，Java中的局部变量在声明后不赋初值，可以打印其变量的值。

错误
对于局部变量而言，其赋值和取值访问顺序是确定的。这样设计是一种约束，尽最大程度减少使用者犯错的可能。假使局部变量可以使用默认值，可能总会无意间忘记赋值，进而导致不可预期的情况出现。

同一作用域内的局部变量可以重复命名。

错误

Java中，某个四则运算表达式中的数值都是int数据类型，则计算之后的数值一定是int类型。

正确
是的，如果一个四则运算表达式中的数值都是int类型，则计算结果一定是int类型。如果要得到其他数据类型的结果，需要进行强制类型转换。例如，double result = (double) 5 / 2; 可以将整数5强制转换为double类型，得到2.5。

Java中，某个四则运算表达式中的数值有一个是double类型，则计算之后的数值一定是double类型。

正确
某个四则运算表达式中的数值有一个是double类型，则计算之后的数值一定是double类型。这是因为在数值计算时，Java会自动将其他数值转换为double类型进行计算。如果希望得到其他数据类型的结果，可以通过强制类型转换实现。

Java基本数据类型都有对应的封装类。封装类能保留其数值，其他方面也没有太大的作用。

错误
封装类除了可以保留对应的基本数据类型的数值，还提供了一些常用的方法，如Integer类的parseInt()方法可以将字符串转换为int类型的数值，Double类的parseDouble()方法可以将字符串转换为double类型的数值等等。此外，封装类还提供了自动装箱和拆箱功能(==选择题会提到==)，可以将基本数据类型和对应的封装类对象互相转换。

在Java中，10/3这个表达式计算的结果是3.333333… 。

错误
10/3这个表达式计算的结果是3，因为两个操作数都是整数类型，所以进行整数除法。如果希望得到浮点数结果，可以将其中一个操作数强制转换为浮点数，例如：10.0/3。

在Java中，&&、||和 &、|都表示逻辑的与、或运算，二者使用起来没有什么差异。

错误
在 Java 中，&& 和 || 表示逻辑的短路与和短路或，而 & 和 | 则表示逻辑的非短路与和非短路或。具体来说，当使用 && 或 || 进行逻辑运算时，如果前面的表达式已经能够决定整个表达式的结果，那么后面的表达式将不再计算；而当使用 &或 | 进行逻辑运算时，无论前面的表达式是否已经决定了整个表达式的结果，后面的表达式都会继续计算。因此，使用 && 和 || 通常比使用 & 和 | 更高效和安全。

Java中break语句可用于循环结构或者switch-case结构，作用是终止当前循环或者分支语句。

正确

Java中continue语句的作用是结束本次循环，开始下一次循环。

正确

Java中的switch-case分支结构的特点是等值判断。它能用if分支结构进行改写。

正确

Java中的switch-case分支结构中，一旦控制表达式的计算结果与某个case值匹配成功，就执行完该case对应的语句块，即结束switch-case语句。

错误
和c一样

Java中的while循环和do-while循环结构的区别是后者至少执行一次循环，而前者可能一次也不执行。

正确

continue; 语句只用于循环语句中，它的作用是跳出循环。

错误

对于基本数据类型和引用型数据类型来说，运算符“==”在比较两个变量是否相同时，含义没有什么差别。

错误
对于基本数据类型来说，运算符“\==”比较的是它们的值是否相等。而对于引用型数据类型来说，“\==”比较的是它们所引用的对象是否相同，即它们的内存地址是否相同。因此，在比较引用类型时，即使它们的内容相同，但如果它们所引用的对象不是同一个，那么“==”的结果仍然是false。

数组a的下标取值，取值范围为：从0到a.length。

错误
从0到a.length-1

数组作为一个引用型的数据类型。对于数组a来说，a.length是数组a对象的一个属性。

正确
对于Java中的数组来说，length是一个数组对象的属性，用于返回数组的长度，即数组中元素的数量。由于Java中数组的长度是固定的，因此length属性在数组创建之后就已经确定了，不能修改。
a.length是申请的空间大小,a.length()是a存放的元素个数.

Java中，比较两个二维数组对象是否相同，就是比较这两个数组的每一个元素是否相同。

错误
比较两个二维数组对象是否相同，不能简单地比较它们的每一个元素是否相同，因为数组对象本身是引用类型，比较时默认比较的是它们在内存中的地址。如果要比较两个二维数组对象是否相同，可以使用Arrays.deepEquals()方法，该方法可以递归地比较多维数组中的元素是否相等。

Java中二维数组既可以表示m行n列的规则数据，也可以表示多行数据，每一行的列数不相同的不规则数组。

正确
是的，Java中的二维数组既可以表示规则数组，也可以表示不规则数组。规则数组可以看作是一张表格，每个元素都有确定的行号和列号，对应的二维数组的声明方式如下：

javaCopy code
int[][] table = new int[m][n];

不规则数组则可以看作是多个一维数组组成的集合，每个一维数组的长度不一定相同，对应的二维数组的声明方式如下：

javaCopy codeint[][] data = new int[m][];
data[0] = new int[2];
data[1] = new int[3];
...

其中，data[0]表示第一行的数据，有两个元素，data[1]表示第二行的数据，有三个元素。

Java中的类是一种数据类型，可以用来声明该类类型的变量。

正确
上面的C x1就是将C作为声明变量使用
Java中的类是一种数据类型，可以用来声明该类类型的变量。类可以看做是一种自定义数据类型，可以包含数据和方法。通过创建类的对象，可以访问类中的数据和方法。类可以被继承和扩展，也可以实现接口以达到多态的效果。在Java中，所有的数据类型都可以看做是一种类。

世界万物皆对象，从具有共同特征的对象中抽取出来静态属性和动态行为的共同特征，用类来进行描述。因此，对象是具体的，类是抽象的。

正确

在方法中使用不定长度参数时，声明的不定长参数必须在参数的最后一个。

正确
当在方法中使用不定长度参数时，声明的不定长参数必须放在参数列表的最后一个位置。这是因为在方法调用时，不定长度参数会将所有的参数都收集到一个数组中，如果将不定长参数放在其他参数之前，则无法确定从哪里开始构建数组。因此，Java要求不定长参数必须放在参数列表的最后一个位置

在如下代码中，两个变量str和i都是基本数据类型的变量。

String str="sdutcs”; 
int i =100;

错误

局部变量可以与成员变量重名。

正确
Java中局部变量可以与成员变量重名，但是在同一个作用域内，局部变量会优先使用。如果需要在同一作用域内访问成员变量，可以使用this关键字来指定。例如：

javaCopy codepublic class MyClass {
    private int value;

    public void setValue(int value) {
        this.value = value; // 使用 this 指定成员变量
    }

    public void printValue() {
        int value = 10; // 与成员变量同名的局部变量
        System.out.println(value); // 输出局部变量的值，为 10
        System.out.println(this.value); // 输出成员变量的值，为 0（默认值）
    }
}

55.类变量属于类和所有的对象所共享。利用类来引用类变量，对类变量的值做了改变，再利用对象来引用类变量，它们的值是相等的。

正确
==类变量也叫静态变量/静态方法==，而不是对象，因此所有的对象都可以共享同一个类变量。如果使用类来引用类变量并对其进行修改，所有的对象都将反映出这一修改。同样，如果使用一个对象来引用类变量并对其进行修改，所有的对象都将反映出这一修改。这是因为它们都引用同一个类变量的实例。

实例变量是属于对象的。一个类的多个对象对实例变量可以设置不同的值。

正确
和类变量对应,属于对象.每个对象都有自己独立的实例变量，可以设置不同的值。在创建一个类的多个对象时，每个对象都会有一份实例变量的拷贝，它们的值可以相互独立地进行修改和访问。与类变量不同，实例变量的值是与对象的状态相关联的

Java中的每个类都至少有一个构造方法，一个类如果没有显式地定义构造方法，系统会自动为这个类创建一个默认的无参的构造方法。

正确

有如下类的定义：

public class Rectangle {   
 public Rectangle(int l) {  //构造方法1
  if (l > 0) {
   w = l;
   h = l;
  }
 }
 public Rectangle(int w1, int h1) {  //构造方法2
  if (w1 > 0 && h1 > 0) {
   w = w1;
   h = h1;
  }
 }
}

下面使用Rectangle类创建一个对象，是否正确？

Rectangle rect=new Rectangle();

错误
如果定义了带参数的构造方法,系统不会默认分配不带参数的构造方法

枚举类型定义了具有删除功能的方法。

错误
Java中的枚举类型是一种特殊的数据类型，它用来定义一组固定的常量。枚举类型的实例是不可变的，不能被删除。因此，枚举类型中并没有定义删除功能的方法。

-5%3的运算结果是2。

错误
结果为-2

在JDK1.8及以后的版本中，使用如下语句是否正确？

String str="*******";
  switch(str)
  {
     case "abc":
       //...
        break;
     case "def":
       //.....
       break;
   }

正确
但是这里没有匹配到case的值,所以switch里面的代码不会被执行

定义一个类时，无论有没有显示地给出构造方法的定义，系统都会提供一个默认的、无参的构造方法。

错误

构造方法返回值类型可以用void进行声明。

错误
构造方法没有返回值类型，因此不能用void或其他类型进行声明。构造方法的主要作用是初始化对象的实例变量或执行其他必要的操作，其名称必须与类名相同。

定义类的方法时，形式参数是基本数据类型，为值传递；形式参数是一个引用数据类型，为地址传递。

正确
java不应该都是值传递吗🤔搞得和c一样了

静态方法中能直接调用非静态方法和非静态成员变量。

错误
静态方法中不能直接调用非静态方法和非静态成员变量，因为非静态方法和非静态成员变量是属于对象的，而静态方法是属于类的，两者没有直接的联系。如果需要在静态方法中使用非静态方法或非静态成员变量，可以先创建对象，然后通过对象来调用相应的方法或变量。

66.非静态的成员变量（实例变量）能被静态方法（类方法）和非静态方法（实例方法）所直接使用。

错误
和上面一样

静态的成员（类变量和类方法）能被静态方法（类方法）和非静态方法（实例方法）所直接调用。

正确
静态的成员（类变量和类方法）能被静态方法（类方法）直接调用，但是不能被非静态方法（实例方法）直接调用，需要通过对象引用来调用。因为静态成员属于类，而非静态方法属于对象。如果在非静态方法中直接调用静态成员，编译器会给出警告，但仍然可以编译通过，因为可以通过类名来访问静态成员。

静态的成员变量（类变量）能被静态方法（类方法）和非静态方法（实例方法）所直接使用。

正确

default package包中的类也能被其他包中的类所引用。

错误
默认包中的类可以被和它在同一默认包下的其他类直接引用，而且默认包中的类也可以被其他包中的类所引用，只要在引用时使用类的全名（包名.类名）即可。但是，建议还是要给类指定一个包名，避免出现同名类的情况。

创建一个类的时候，如果未指定包名，处于无名包（default packge）中。其他包中的类无法引用该类。

正确

在JDK提供的系统类库中，使用java.lang包中的类时，可以直接使用，不必使用import来进行导入。

正确
Java中的java.lang包中的类是默认导入的，因此可以直接使用，无需进行import导入。

private不能修饰构造方法。

错误

在定义一个类的时候，如果类的成员被private所修饰，该成员不能在类的外部被直接访问。

正确

Abstract method cannot be static. 抽象方法不能是静态方法。

正确
抽象方法不能是静态的，因为抽象方法要被子类实现，而静态方法属于一个类，不能同时属于两个类

抽象类能实例化一个对象。如：

abstract class A(){}

可以调用如下语句创建对象a:

A a=new A();

错误
抽象类不能实例化

JAVA抽象类中一定含有抽象方法。

错误
没有抽象方法加一个abstract也是抽象类

含有抽象方法的类一定是抽象类，抽象类中一定含有抽象方法。

错误
和上面一样

任何一种类类型，都可以使用new关键字来创建对象。

错误

用final关键字修饰的成员变量和局部变量是常量，常量的赋值次数只有一次。

正确

使用类的继承，目的是把多种对象间的共同的属性和共同行为抽取到父类中，因此子类对象和父类的关系表示是is-a的关系。

正确

有如下的父类和子类的定义，语法上是否正确（）

class A{
 int a;
 public A(int a)
 {
  this.a=a;
 }
}
public class B extends A{
}

错误
不正确。因为子类B没有显式地调用父类的构造方法，系统会默认调用父类的无参构造方法，但是在A类中并没有无参构造方法，所以会编译报错。因此，需要在子类B的构造方法中显式地调用父类A的有参构造方法来完成父类A中成员变量的初始化，例如：

javaCopy codepublic class B extends A{
    public B(int a){
        super(a); // 显式调用父类的有参构造方法完成父类成员变量的初始化
    }
}

Java中被final关键字修饰的变量，若在声明时指定了初值，不能被重新赋值。

正确
同时final修饰的类不能被继承,final修饰的方法不可以重写但是可以重载

class Father
{
public final void speak()
{
System.out.println("方法被调用了");
}
}
class Child extends Father
{
  public void speak()
  {
  super.speak();
  }
}
class Run
{
public static void main(String []args)
{
Child c =new Child();
c.speak();
}
}

这么写会报错

class Father
{
public final void speak()
{
System.out.println("方法被调用了");
}
public final void speak(String text)
{
System.out.println("方法被调用了"+text);
}
}

改成这样是可以运行的

当成员变量（属性）的访问权限不足时，可以通过增加公开的set方法和get方法对属性进行设置值或获取值来进行访问。

正确

使用上转型对象调用子类重写的成员变量时表现出多态性。

错误

使用上转型对象调用子类重写的方法时表现出多态性。

正确
和84.一样

抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。

错误
抽象方法必须定义在抽象类中,但是抽象类可以有非抽象方法

Java类可以同时有2个直接父类。

错误
继承只能继承一个

一个类如果实现一个接口，那么它就需要实现接口中定义的全部方法，否则该类必须定义成抽象类。

正确
一个类如果实现了一个接口，就需要实现该接口中定义的全部方法，否则该类必须被定义为抽象类。接口中的方法都是抽象方法，没有方法体，需要具体实现的方法全部定义在实现接口的类中。如果实现类没有实现接口中定义的全部方法，那么这个类必须声明为抽象类。

接口和类不同，不具有单继承性，它可以继承多个接口。

正确
接口与类的继承机制有所不同，接口可以继承多个接口，但接口本身是不能继承类的。一个类可以实现多个接口，但只能继承一个直接父类。这是因为Java采用了单一继承的原则，即一个子类只能有一个直接父类

一个类的定义，可以继承一个父类的同时，再实现多个接口。

正确
和89.一样

Throwable 有两个重要的子类：Exception（异常）和 Error（错误）。异常是应用程序中可能的可预测、可恢复问题。大多数异常表示中度到轻度的问题；错误表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。

正确
.Exception（异常）是应用程序中可能的可预测、可恢复问题。一般大多数异常表示中度到轻度的问题。
Error（错误）表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。

程序中异常对象的产生方式有两种形式：1、系统执行过程中，产生异常对象；2、程序用throw关键字人为抛出异常对象。

正确

在Java程序中，异常对象可以有两种产生方式：

1. 系统执行过程中，产生异常对象。这种情况通常是由于程序执行过程中遇到了一些错误或者异常情况，导致程序无法正
常执行，从而产生异常对象。例如，程序试图读取一个不存在的文件，试图除以零等。

2. 程序用throw关键字人为抛出异常对象。这种情况通常是程序员在编写代码时手动抛出异常，以便程序能够捕获并处理
异常。例如，在一个方法中，当输入参数不符合预期时，可以手动抛出一个IllegalArgumentException异常对象。

若异常发生时，它没有捕获，后续的程序不受任何影响，依然能正常执行。

错误
如果异常没有被捕获，它会一直向上抛出，直到有地方处理或者程序崩溃退出。如果没有被处理，后续的代码就不会被执行。

一个异常处理中 finally语句块可以不出现，也可以出现一次。

正确
一个异常处理中，finally语句块可以不出现，但如果出现，则只能出现一次。finally语句块中的代码无论是否发生异常，都会被执行。通常在finally语句块中进行资源的释放，比如关闭文件或者网络连接等。

Java语言中的所有异常类都是java.lang.Throwable的子类。

正确
Java语言中的所有异常类都是java.lang.Throwable的子类。其中，Exception和Error是Throwable的两个重要的直接子类。Exception又分为可检查异常和运行时异常，可检查异常需要在代码中显式地进行处理，而运行时异常则可以不处理。

非运行时异常（受检异常或编译异常），指的是RuntimeException以外的异常，如：IOException、SQLException等以及用户自定义的Exception异常，类型上属于Exception类及其子类。从语法上是必须进行处理的异常，需要使用try-catch（try-catch-finally）结构进行处理或者利用throws向上层抛出。如果不处理，程序就不能编译通过。

正确
受检异常（checked exception）指的是在方法中可能会抛出的异常，在方法声明中需要使用throws关键字声明，或者使用try-catch结构进行捕获和处理。这种异常包括IOException、SQLException等，以及用户自定义的Exception类及其子类。
相对应的，非受检异常（unchecked exception）指的是运行时异常（runtime exception），如NullPointerException、ArrayIndexOutOfBoundsException等，以及Error类及其子类。这种异常不需要在方法声明中使用throws关键字声明，也不强制要求在方法中使用try-catch结构进行捕获和处理。

String类提供了丰富的方法，其中包含许多与正则表达式相关的方法。如：split、replaceFirst、replaceAll、matches等等，可用于对与正则表达式相匹配的字符串进行分割、替换、判断是否匹配操作。

正确
split(String regex): 使用给定的正则表达式分隔字符串。
replaceFirst(String regex, String replacement): 使用给定的正则表达式替换字符串的第一个匹配项。
replaceAll(String regex, String replacement): 使用给定的正则表达式替换字符串的所有匹配项。
matches(String regex): 判断该字符串是否与给定的正则表达式匹配。

String对象和StringBuffer对象都是字符串类型，创建后的对象都可以原地修改。

错误
和7.一样

字符串缓冲区类允许在当前对象上进行追加、增加、删除、修改字符的操作。而字符串对象不具备这一特点，只要改变就生成一个新的对象。

正确
和7.一样

System类中的currentTimeMills()方法，返回一个long类型的、当前时刻距离标准时间GMT之间的毫秒值。

正确
System.currentTimeMillis()获得的是自1970-1-01 00:00:00.000 到当前时刻的时间距离,类型为long,以毫秒为单位

由Date到String的转换需要用到SimpleDateFormat类对象的format方法。

正确
SimpleDateFormat类提供了format()方法，可以将Date对象转换为指定格式的字符串。使用该方法需要先创建一个SimpleDateFormat对象，并指定相应的日期格式。然后将需要转换的Date对象作为参数传入format()方法中即可。

由String到Date的转换需要用到SimpleDateFormat类对象的parse方法。

正确
从String到Date的转换需要用到SimpleDateFormat类对象的parse方法，该方法将一个字符串解析为一个日期对象。这个方法会抛出ParseException异常，因此在使用该方法时应该进行异常处理。例如：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String dateString = "2023-05-01";
try {
    Date date = sdf.parse(dateString);
    // 进一步处理日期对象
} catch (ParseException e) {
    e.printStackTrace();
}

java.math.BigInteger类可以表示比long类型更大的整数，还提供了诸多方法，用于对两个大整数对象的加、减、乘、除、取余、求幂、求最大公约数等等数学运算。

正确
BigInteger类是Java中专门用于处理大整数运算的类。它可以表示比long类型更大的整数，甚至比double类型的范围还大。它提供了许多方法，可以用于对两个大整数对象进行加、减、乘、除、取余、求幂、求最大公约数等数学运算操作

java.lang.Math类是一个最终类。其中包含许多用来进行科学计算的类方法和常量，它们都是Math类的静态成员。

正确
java.lang.Math类是一个最终类，其中包含许多用来进行科学计算的类方法和常量，它们都是Math类的静态成员。Math类中的方法可以用于求平方根、三角函数、指数函数、对数函数、幂函数、取整等等数学运算。这些方法通常比自己手写实现更加精确、高效，并且可以直接使用，无需重新实现。由于Math类是一个最终类，因此不能被其他类继承，也不能创建Math类的实例。

对于泛型类或泛型接口，在编译过程中检查泛型类型的合法性，在对象进入和离开方法的边界处添加类型检查和类型转换的机制，并且泛型信息会保持到运行时阶段。

错误
泛型信息在编译时会进行类型擦除，也就是说，编译器会将泛型类型转换成原始类型，这样在运行时，程序无法访问泛型的类型参数信息。因此，泛型在运行时是不会保留泛型类型信息的。所以，虽然在编译时会进行类型检查，但在运行时是无法对泛型类型进行类型检查的。因此，对于泛型类或泛型接口，在运行时是无法保持泛型信息的。

在Collection集合中元素类型必须是相同的。

错误
List接口中的get方法返回的是泛型类型E，因此它可以返回集合中的任何一个元素，而这些元素的类型可以不同。

在java.util.List接口的实现类java.util.ArrayList所表示的集合中，元素是有序的并且可以重复。该数据结构底层由数组来实现，能够精确地控制每个元素的插入位置，或者删除某个位置的元素，对元素的随机访问速度特别快。

正确
Java中的ArrayList实现了List接口，是基于数组的动态集合，能够存储任何类型的对象。它可以动态地增加或缩小容量，实现了可变大小的数组。ArrayList中的元素是有序的，并且可以重复。此外，它还提供了随机访问元素的能力，可以快速地根据索引获取元素，因为底层数据结构就是数组。所以，ArrayList通常被用于需要经常读取数据而不需要频繁地插入或删除元素的场合。

Set集合是有序的，不可以包含重复的对象。

错误
Set集合是无序的，而且元素是不可重复的。Set集合是基于哈希表的实现，所以元素的顺序是无序的，而且每个元素在集合中只会存在一次。

List集合是有序的，可以包含重复的对象。

正确
List集合是一个有序的集合，可以根据元素的索引位置获取元素，也允许元素重复。这意味着，在List集合中，可以通过添加多个相同的元素来实现重复。常见的List集合实现类有ArrayList和LinkedList。

集合Set是通过键-值对的方式来存储对象的。

错误
这个说法不正确。Set集合是一种不允许重复元素的集合，它并不是通过键-值对的方式来存储对象，而是直接存储对象本身。键-值对是用来存储映射关系的数据结构，如Map集合。

在java.util.Set接口的实现类java.util.HashSet所表示的集合中，元素是无序的并且不允许重复，因此不能利用索引位置访问元素。

正确
在java.util.HashSet所表示的集合中，元素是无序的并且不允许重复，但是它是通过哈希表来实现的，可以快速地进行查找、插入、删除操作。因此，虽然不能利用索引位置访问元素，但是可以通过迭代器来遍历集合中的元素。

由于编码方式不同，表达同样的信息产生的数据量大小不同。

正确
ASCII编码只能表示128个字符，每个字符用7位二进制数表示，因此对于包含大量ASCII字符的数据来说，使用ASCII编码能够有效地减小数据量。而UTF-8编码使用变长编码方式，对于ASCII字符只需1个字节表示，对于中文等非ASCII字符需要2个或3个字节表示，因此对于包含大量中文字符的数据来说，使用UTF-8编码相对于其他编码方式能够减小数据量。

如果一个File表示的目录对象下有文件或者子目录，调用delete()方法也可以将它们删除。

错误
如果一个File表示的目录对象下有文件或者子目录，调用delete()方法将只能删除该目录对象，而无法删除目录中的文件或子目录。如果想要删除整个目录，需要借助其他的方法实现，比如递归删除目录中的所有文件和子目录，或者使用第三方的库来操作。

通过File类可对文件属性进行修改。

正确
可以通过File类对文件属性进行修改，例如文件的读写权限、最后修改时间等属性。可以使用File类的setReadable()、setWritable()、setExecutable()等方法来修改文件的读写权限；可以使用setLastModified()方法修改文件的最后修改时间。需要注意的是，这些方法的调用需要有相应的权限才能成功执行。

在FileReader类的对象中，利用read(char[] buf)和read(char[] buf,int off,int len)方法读取数据后，buf数组中全部存放的是本次读取的数据。

错误
read方法返回的是本次读取的字符数，如果返回-1则表示已经读到文件的末尾。

InputStream类中的close()方法是用于关闭流并且释放流所占的系统资源。

正确
InputStream类中的close()方法是用于关闭流并且释放流所占的系统资源。关闭流可以防止资源泄露，也可以保证数据的完整性和可靠性。

BufferedInputStream和BufferedOutputStream不是字节缓冲流。

错误
ufferedInputStream和BufferedOutputStream是Java中的字节缓冲流，它们可以提高读写文件的效率。它们内部都包装了一个输入流或输出流，并提供了缓冲功能，在读写数据时会先将数据缓存在内存中，然后一次性进行读取或写入，从而减少了与磁盘的IO操作，提高了读写效率。

在程序代码中，java.io.IOException异常必须被捕获或抛出，不能置之不理。

正确
java.io.IOException异常是一个检查异常（checked exception），必须在方法签名中声明或者在try-catch块中捕获，否则代码将无法通过编译。==同96.受检异常都是如此==

Java系统的标准输入对象是System.in，标准输出对象有两个，分别是标准输出System.out和标准错误输出System.err。

正确
在Java中，标准输入对象是System.in，可以通过它来读取控制台输入的数据。而标准输出对象有两个，分别是System.out和System.err。通常情况下，使用System.out进行标准输出，而System.err则用于输出错误信息。

Serializable接口是个空接口，它只是一个表示对象可以串行化的特殊标记。

正确
它定义了一个用于串行化的协议，即类实现Serializable接口后，可以将对象转化为一组字节，以便在网络上传输或者存储到磁盘中。Serializable接口中并没有任何方法需要实现，因此被认为是一个标记接口。

对象串行化（序列化）机制是指将程序中对象的状态转化为一个字节流，存储在文件中。

正确
对象串行化机制是指将一个Java对象转换为字节序列，以便在网络上传输或在文件中存储。在Java中，需要实现java.io.Serializable接口才能将一个对象串行化。一旦对象被串行化，它就可以通过网络或存储在文件中进行传输或保存，然后在另一个Java程序中被反串行化（反序列化）为原始对象。这种机制为Java程序的分布式计算和对象持久化提供了支持。

对象序列化是指将一个Java对象转换成一个I/O流中的字节序列的过程。

正确
对象序列化指的就是将一个Java对象转换成字节序列，以便可以将其存储在磁盘上或者通过网络传输。在Java中，通过实现Serializable接口，可以将对象序列化为字节流，这个过程可以通过ObjectOutputStream实现。反之，将字节流转换为Java对象的过程称为对象反序列化，这个过程可以通过ObjectInputStream实现。

文件缓冲流的作用是提高文件的读/写效率。

正确
文件缓冲流通过在内存中维护一个缓冲区来提高文件的读写效率，避免了每次读写文件时都要直接访问磁盘的开销。当数据被写入缓冲区时，并不会直接写入磁盘，而是等待缓冲区被填满或者调用flush()方法时才将数据写入磁盘。同样地，当读取数据时，缓冲流也会将一部分数据先读取到缓冲区中，以减少直接访问磁盘的次数。这样可以显著提高读写速度，特别是对于大文件或者需要频繁读写的文件而言。

通过IP地址可以连接到网络上指定计算机，端口号定位计算机中的某个应用程序，因此通过IP地址和端口号，就可以定位到网络上某主机上的应用程序。

正确
都考的是什么鬼😒

在网络通信中，对数据传输格式、传输速率、传输步骤等作了统一规定，只有通信双方共同遵守这个规定才能完成数据的交互，这种规定称为网络传输协议。

正确
😒

TCP协议的特点是面向连接，即在传输数据前先在服务器端和客户端建立逻辑连接。

正确
😒

使用TCP协议通信时，通信的两端以I/O流的方式进行数据的交互。

正确
通信的两端通过建立连接后，可以通过输入输出流进行数据的交互。客户端通过输出流向服务器端发送数据，服务器端通过输入流接收数据；服务器端通过输出流向客户端发送数据，客户端通过输入流接收数据。这种方式类似于文件的读写操作，但是在网络通信中需要考虑到数据的可靠传输和网络异常处理等问题。

利用TCP协议进行通信，客户端和服务器端建立起连接，形成传输数据的通道之后，进行大数据量的传输，是可靠的传输协议。

正确
😒

在TCP协议通信时，客户端和服务器端建立起连接，通过Socket套接字的getInputStream()返回此套接字的输入流，getOutputStream()返回套接字的输出流。通信的双方通过输入、输出流读写数据。

正确
客户端通过创建Socket对象，指定服务器的IP地址和端口号，调用Socket的connect()方法与服务器建立连接。建立连接成功后，客户端可以通过Socket的getOutputStream()方法获取输出流，向服务器发送数据；也可以通过Socket的getInputStream()方法获取输入流，从服务器接收数据。服务器端则通过ServerSocket对象的accept()方法监听客户端的连接请求，建立连接成功后，也可以通过Socket的getInputStream()方法获取输入流，从客户端接收数据；也可以通过Socket的getOutputStream()方法获取输出流，向客户端发送数据。在传输数据时，TCP协议会保证数据的可靠性和顺序性。

Socket类的方法 shutdownInput和shutdownOutput的作用是关闭相应的输入、输出流，不关闭网络连接。它将输入、输出流移动到末尾，再没有数据可以读写了，将以后发过来的数据忽略掉。

正确
输出流实际上是关闭了客户端与服务器之间的数据传输通道，不再允许进行数据的读写。这个操作将使得Socket对象底层的SocketImpl的输入、输出流都被关闭。在调用了这两个方法之后，客户端和服务器仍然保持着连接，可以继续通信，只不过不能再通过这两个流进行数据的读写。如果需要重新建立输入、输出流，可以调用getInputStream()和getOutputStream()方法。

由于UDP是面向无连接的协议，可以保证数据的完整性，因此在传输重要数据时建议使用UDP协议。

错误
UDP是面向无连接的协议，不保证数据的可靠性和完整性，因为它不提供数据的确认、重传和流量控制机制。所以，在传输重要数据时，建议使用TCP协议，因为TCP协议提供了数据的确认、重传和流量控制机制，可以保证数据的可靠性和完整性。

Thread.sleep ()方法执行后，在指定时间内所有线程都会暂停，进入休眠状态。

错误
Thread.sleep()方法执行后，当前线程会进入阻塞状态，而不是所有线程都会暂停进入休眠状态。调用该方法的线程会暂停执行一段时间，然后恢复执行状态，其他线程不受影响。因此，如果在主线程中调用了Thread.sleep()方法，只会使主线程暂停，而不会影响其他线程的执行。
简单来说,谁调用谁sleep

当调用一个正在进行线程的stop()方法时，该线程便会进入休眠状态。

错误
线程停止而不是休眠

如果线程死亡，它就不能运行。

正确
线程死亡后资源就会被释放

在java程序中，只能使用英文的分号;，否则编译器会报告错误信息。

正确

Java语言在定义类时，可以将class写成Class。

错误
java对大小写敏感

标识符可以为关键字。

错误
Java中的关键字是具有特殊意义的单词，不能用作标识符（例如变量名、方法名等）。如果将关键字用作标识符，编译器会报错。

常量就是程序中常常变化的数据。

错误
常量的定义是指在程序中定义一个固定的数值或字符串，不允许程序对其进行修改，其值在程序运行过程中不能改变。常量的值可以在编译时就确定，也可以在程序运行时动态计算得出。

在为double类型的变量赋值时，后面可以加字母D或d，也可以不添加。

正确
当给double类型的变量赋值时，可以在数值后面加上字母"D"或"d"来表示这是一个double类型的字面量，也可以不添加。例如，下面的语句都可以正确地为double类型的变量赋值：
```
javaCopy codedouble num1 = 3.14;
double num2 = 3.14D;
double num3 = 3.14d;
```
相同的,给数字后面加上f表示float型,如果不加默认是double型

在进行自增（++）和自减（--）运算时，如果运算符++或--放在操作数的前面，则先进行自增或自减运算，再进行其他运算。

正确
和c一样

运算符“&”和“&&”都表示“与”操作。

正确
“&”是逻辑运算符，表示逻辑与操作，无论左右两侧的表达式结果如何，都会进行计算，而且如果左侧表达式结果为false，右侧表达式也会被计算，所以“&”操作符可能会产生多余的计算。
“&&”是条件运算符，表示条件与操作，如果左侧表达式结果为false，则右侧表达式不会被计算，因为已经确定整个表达式的结果为false，从而避免了不必要的计算。因此，“&&”操作符比“&”操作符更加高效。

while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。

正确
和c一样

break语句可以在循环语句或者switch条件语句中使用。

正确
和c一样

在switch语句中，每个case关键字后面必须有break。

错误
和c一样

浮点数常量指的是数学中的小数。

正确
浮点数常量是指数学中的小数，可以表示为有小数点的数字。在Java中，浮点数常量可以使用float和double两种数据类型表示。

在Java中，小数会被默认是double类型的值。

正确

Java允许在一个程序中定义多个同名的方法，但是参数的类型或个数必须不同，这就是方法的重载。

正确
参数的类型或个数必须不同造成了签名不同,签名不同就是重载
重写是签名相同而函数体不同

代码int[][] arr = new int[3][4]可以正确的定义一个二维数组。

正确

数组的最大下标的值比它的长度小1。

正确
下标从0开头的

Java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。

正确

构造方法不可以被继承。

正确
当一个子类继承父类时，它可以使用父类的构造方法，但是它不能继承父类的构造方法。子类可以定义自己的构造方法，但是如果没有定义构造方法，系统会自动创建一个默认的构造方法。

类中static修饰的变量或方法，可以使用类名或对象的引用变量访问。

正确
static关键字修饰的变量是属于类的,但是被整个类共享,所以也是属于对象的,可以被类new出来的对象调用

在静态方法内可以调用非静态方法。

错误
在静态方法内部不能直接调用非静态方法。因为非静态方法是依赖于对象的，必须先创建对象，然后通过对象调用非静态方法。而静态方法是不依赖于对象的，可以直接通过类名调用。如果在静态方法中要调用非静态方法，需要先创建对象，然后通过对象调用非静态方法。

静态代码块会随着类对象的创建而创建。

错误
静态代码块会在类被加载时执行，而不是在对象被创建时执行。它只会执行一次，并且在整个类生命周期内只会执行一次。静态代码块可以用来初始化静态变量或执行其他静态的初始化操作。静态代码块的语法为：

arduinoCopy codestatic {
    //静态代码块的代码
}

不存在继承关系的情况下，也可以实现重写。

错误
重写是指子类重写父类的方法，因此在继承关系中才有重写的概念。子类可以重写继承自父类的方法，以实现更特定的功能需求，但是重写的方法名、参数列表和返回值类型必须与父类中被重写的方法相同。

Java中被final关键字修饰的变量，不能被重新赋值。

正确

抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。

错误
和68.一样

Java中，子类可以覆盖父类中的任意方法。

错误
final方法覆盖(重写)不了.Java中的子类可以覆盖（或称为重写）父类中的任意非final方法。重写方法的方法名、参数列表和返回类型都必须与父类方法相同。
重写方法的访问修饰符不能比父类方法的访问修饰符更严格，例如，如果父类方法的访问修饰符为protected，则子类方法可以是protected或public，但不能是private。

如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也是抽象类。

正确
没有全部复写,所以还存在了抽象方法,所以也是抽象类

super调用父类构造方法的代码必须位于子类构造方法的第一行。

正确
这是因为在创建子类对象时，首先要执行父类的构造方法，以初始化从父类继承的成员变量。因此，在子类的构造方法中，必须先调用父类的构造方法，然后才能执行子类自己的构造方法。

循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。

正确

break语句只用于循环语句中，它的作用是跳出循环。

错误
switch也可以用

私有属性只能在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法。

正确
私有属性是指只能在其所在类中被直接访问的属性，而无法被类的外部代码访问。但是，我们可以在类中提供一些公有的方法来访问这些私有属性，这些公有方法也被称为getter和setter方法。通过这些方法，类的外部代码就可以访问和修改私有属性了。

子类重写的方法可以拥有比父类方法更加严格的访问权限。

错误
子类重写的方法不能拥有比父类方法更加严格的访问权限，必须和父类方法具有相同的或更宽松的访问权限。这是因为子类对象可以被当做父类对象使用，如果子类重写的方法具有比父类方法更加严格的访问权限，那么当子类对象被当做父类对象使用时，就不能访问子类方法了，这是不合理的。

protected访问权限比默认访问权限严格。

错误
protected访问权限比默认访问权限更加宽松，但比public和private访问权限更加严格。protected访问权限的成员可以被本类、同一包中的类以及子类访问，但是不能被其他包中的类访问。默认访问权限的成员只能被本类和同一包中的类访问，不能被其他包中的类访问。public访问权限的成员可以被任何类访问。private访问权限的成员只能被本类访问，其他类不能访问。
这里的默认应该是指缺省

如将一个int类型的数转为byte类型，不会造成数据精度的丢失。

错误
byte类型只能表示-128~127之间的整数，而int类型可以表示更大范围的整数。

同一个类的不同对象是完全独立的个体，它们分别拥有各自的属性。

正确
同一个类的不同对象是完全独立的个体，它们分别拥有各自的属性。每个对象都有自己独立的内存空间来存储它的属性。因此，对于同一个类的不同对象，它们的属性值可以相互独立地设置和获取，互不影响。

类中定义了一个有参的构造方法，系统还会再提供无参的构造方法。

错误

静态属性不能使用对象名直接访问。

错误
上面提到过,静态属性和静态方法属于类,那么也属于类被实例化后的对象,所以可以通过类名调用,也可以通过对象名来带调用

所谓方法重写，就是在同一个作用域内方法名相同但参数个数或者参数类型不同的方法。

错误
上面提到过,签名相同函数体不同是方法重载,签名不同才是重写,这里函数签名是相同的

目标类型取值范围小于源类型时，需要进行强制类型转换。

正确
同样的,当目标类型取值范围大于源类型时，可以进行隐式类型转换，不需要强制类型转换。

JAVA中常量名所有字母都大写，单词之间用下划线连接。

正确
JAVA中常量名一般采用全大写字母，单词之间用下划线连接的命名方式，这是一种约定俗成的规范。这样做可以提高代码的可读性和可维护性，也方便区分常量和变量。例如：

javaCopy codepublic static final int MAX_COUNT = 100;
public static final String DEFAULT_NAME = "John Doe";

在给变量起名时，computer和Computer是一样的。

错误
java对大小写敏感

this关键字可以用来访问父类的成员变量和成员方法。

错误
super关键字才能访问父类

JAVA中，一个接口允许继承多个接口。

正确
上面提到过,接口具有多继承性,而一个子类只能有一个父类

在Java中，含有抽象方法的类一定是抽象类。

正确
含有抽象方法的类必须被声明为抽象类。因为抽象方法没有实现，需要被子类实现，而一个非抽象类必须实现其所有的抽象方法，否则就必须将该类也声明为抽象类。

Java中continue语句的作用是结束本次迭代，开始下一次迭代。

正确

String是Java中定义的基本数据类型

错误
java只有8种基本类型,String不是Java中定义的基本数据类型，它是Java中的一个类，用于表示字符串。基本数据类型包括boolean、byte、char、short、int、long、float和double。

Java语言不区分大小写

错误

在Java中，变量的数据类型分为两种，即基本数据和引用数据类型。

正确
Java中的变量数据类型分为基本数据类型和引用数据类型。基本数据类型包括boolean、byte、short、int、long、float、double和char，而引用数据类型包括类、接口、数组等。基本数据类型是按值传递的，而引用数据类型是按引用传递的。