Java SE 易错题
一、初始JAVA
1、Java虚拟机就是一个虚拟的用于执行 字节码文件 的计算机。它是Java最核心的技术，是Java跨平台的基础。
2、一个Java源程序是由若干个类组成。如果源文件中有多个类时，则只能有一个类是
Public 类，并且这个类必须与源文件名同名。
3、 |
以下选项中关于Java跨平台原理的说法正确的是（AC ）。（选择二项） |
|
|
|
|
|
A |
Java源程序要先编译成与平台无关的字节码文件(.class)，然后字节码文件再被解释成机器码运行 |
|
B. |
Java的跨平台原理决定了其性能比C/C++高 |
|
C. |
Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的，但它们都提供了相同的接口 |
|
D. |
Java语言具有一次编译，到处运行的特点，可以在所有的平台上运行 |
4、 |
在Java中，源文件Test.java中包含如下代码，则程序编译运行的结果是（ B ）。（选择一项） |
|
|
public class Test { public static void main(String[ ] args) { system.out.println("Hello!"); } } |
|
|
|
|
|
A |
输出：Hello！ |
|
B. |
编译出错，提示“无法解析system” |
|
C. |
运行正常，但没有输出任何内容 |
|
D. |
运行时出现异常 |
System首字母大写
5、Java具有一次编译，到处运行的特点，其含义是Java的源代码可以一次性编译成计算机的机器码，并在不同的平台上运行。（ 错 ） 应该是字节码。
6、Java的字节码文件的扩展名是class，是一种平台独立的非二进制文件。( 错 )-
是一个与平台无关的二进制文件。
二、数据类型和运算符：
1、使用位运算符来实现运算效率最高，所以最有效率的方法算出2乘以8等于多少的语句是 2<<3 。
2、基本数据类型的类型转换中，要将double类型的常量3.14159赋给为整数类型变量n的语句是_____int n=(int)3.14159;________________。
3、 |
下面的赋值语句中错误的是（ A ）。（选择一项） |
|||
|
|
|
||
|
A |
float f = 11.1; |
||
|
B. |
double d = 5.3E12; |
||
|
C. |
double d = 3.14159; |
||
|
D. |
double d = 3.14D; |
||
4、 |
如下写法哪些是不对的（BD ）（选择二项） |
|||
|
|
|
||
|
A |
byte b = 30; |
||
|
B. |
byte c = 500; |
||
|
C. |
long d = 2343223; |
||
|
D. |
float f = 3.14; |
||
5、char类型变量可以存储一个Unicode字符，在内存中占2个字节，该字符可以是一个汉字。（ 对 ）
6、^ 是异或位运算符，运算规则是如果两个操作数相同，结果是0，否则结果是1。( 对 )
7、赋值运算符优先级别低于条件运算符，条件运算符优先级别低于算术运算符。(对 )
8、赋值和条件运算符是运算级别最低的两种运算符，都具有自右向左的结合性。（ 对 ）
9、00101010 & 00010111语句的执行结果为00111111（ 错 ）
三、选择语句+循环语句
1、for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体}，其中在整个循环过程中只执行一次的部分是 表达式1 。
2、 |
以下代码的执行结果是（ B ）。（选择一项） ??? |
|||
|
boolean m = false; if(m = false){ System.out.println("false"); }else{ System.out.println("true"); } |
|||
|
|
|
||
|
A. |
false |
||
|
B. |
true |
||
|
C. |
编译错误 |
||
|
D. |
无结果 |
||
3. |
阅读下列文件定入的Java代码，其执行结果是（ D ）。（选择一项） |
|||
|
public class Test { public static void main(String[] args) { char ch = 'c'; switch (ch) { case 'a': System.out.print("a"); break; case 'b': System.out.print("ab"); case 'c': System.out.print("c"); default: System.out.print("d"); } } } |
|||
|
A |
a |
||
|
B. |
b |
||
|
C. |
c |
||
|
D. |
cd |
||
4. |
以下Java程序编译运行后的输出结果是（ B ）。（选择一项） |
|||
|
public class Test { public static void main(String[] args) { int i = 0, sum = 0; while (i <= 10) { sum += i; i++; if (i % 2 == 0) continue; } System.out.println(sum); } } |
|||
|
A |
0 |
||
|
B. |
55 |
||
|
C. |
50 |
||
|
D. |
36 |
||
5. |
在Java中有如下代码，则编译运行该类的输出结果是（ D ）。（选择一项） |
|||
|
public static void main(String[ ] args) { for(int i=0;i<10;i++){ if (i%2!=0) return; System.out.print(i); } } |
|||
|
|
|
||
|
A |
13578 |
||
|
B. |
02468 |
||
|
C. |
0123456789 |
||
|
D. |
0
|
||
四、多重循环+方法
1. |
分析下面的Java多重循环代码片段，编译运行后的输出结果是（D ）。（选择一项） |
|
|
for (int i = 0; i < 6; i++) { int k = ++i; while (k < 5) { System.out.print(i); break; } } |
|
|
|
|
|
A. |
024 |
|
B. |
02 |
|
C. |
123 |
|
D. |
13 |
2. |
给定如下Java代码，编译运行的结果是（b ）。（选择一项） |
||
|
public class Test { public static void main(String[] args) { int sum=0; for(int i=1;i<10;i++){ do{ i++; if(i%2!=0) sum+=i; }while(i<6); } System.out.println(sum); } } |
||
|
|
|
|
|
A |
8 |
|
|
B. |
15 |
|
|
C. |
24 |
|
|
D. |
什么也不输出 |
|
3. |
在Java的程序类中如下方法定义正确的是（ ad ）。（选择两项） |
||
|
|
|
|
|
A |
public int ufTest(int num){ int sum=num+100; return sum; } |
|
|
B. |
public String ufTest(int num){ int sum=num+100; return sum; } |
|
|
C. |
public void ufTest(int num){ int sum=num+100; return sum; } |
|
|
D. |
public float ufTest(int num){ int sum=num+100; return sum; } |
|
4. |
以下关于方法调用的代码的执行结果是（ b ）。（选择一项） |
||
|
public class Test { public static void main(String args[]) { int i = 99; mb_operate(i); System.out.print(i + 100); } static void mb_operate(int i) { i += 100; } } |
||
|
|
|
|
|
A. |
99 |
|
|
B. |
199 |
|
|
C. |
299 |
|
|
D. |
99100 |
|
五、数组
1、创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是____NULL________。
2、 |
在Java中，以下程序段能正确为数组赋值的是（ AD ）。（选择二项） |
|
|
|
|
|
A |
int a[]={1,2,3,4}; |
|
B. |
int b[4]={1,2,3,4}; |
|
C. |
int c[];c={1,2,3,4}; |
|
D. |
int d[];d=new int[]{1,2,3,4}; |
3、 |
数组元素的索引可以是（D ）。（选择一项） |
||
|
|
|
|
|
A |
整型常量 |
|
|
B. |
整型变量 |
|
|
C. |
整型表达式 |
|
|
D. |
以上都可以 |
|
4、 |
在Java中，以下定义数组的语句正确的是（ Cd ）。（选择二项） |
||
|
|
|
|
|
A |
int t[10]=new int[ ]; |
|
|
B. |
char [ ]a=”hello”; |
|
|
C. |
String [ ] s=new String [10]; |
|
|
D. |
double[ ] d [ ]=new double [4][ ]; |
|
5、 |
以下选项中能够正确创建一个数组的是（ AD ）。（选择二项） |
||
|
|
|
|
|
A. |
float []f[] = new float[6][6]; |
|
|
B. |
float f[][] = new float[][]; |
|
|
C. |
float [6][]f = new float[6][6]; |
|
|
D. |
float [][]f = new float[6][]; |
|
6、 |
下面的数组定义哪些是正确的？（CD ）。（选择二项） |
||
|
|
|
|
|
A |
int a[][] = new int[3,3]; |
|
|
B. |
int a[3][3] = new int[][]; |
|
|
C. |
int a[][] = new int[3][3]; |
|
|
D. |
int []a[] = new int[3][3]; |
|
7、数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（ 对 ）
六、类和对象
1、执行Person p = new Person();语句后，将在___堆内存________中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
2、 package 关键字作为Java源文件的第一条非注释性语句，指明该源文件定义的类所有的包。
3、
分析如下Java程序的代码所示，则编译运行后的输出结果是（C ）。（选择一项） |
|
public class Test { int count=9; public void count1(){ count=10; System.out.println("count1="+count); } public void count2(){ System.out.println("count2="+count); } public static void main(String[ ] args) { Test t=new Test(); t.count1(); t.count2(); } } |
|
|
|
A |
count1=9; count2=9; |
B. |
count1=10; count2=9; |
C. |
count1=10; count2=10; |
D. |
count1=9; count2=10; |
在成员方法里修改成员变量的值后，值就变了。
4、 |
下列选项中关于Java中类方法的说法错误的是（ AC ）。（选择二项） |
|
|
|
|
|
A |
在类方法中可用this来调用本类的类方法 |
|
B. |
在类方法中调用本类的类方法时可直接调用 |
|
C. |
在类方法中只能调用本类中的类方法 |
|
D. |
在类方法中调用实例方法需要先创建对象 |
|
|
|
5、如果没有为类中的某些成员赋初始值，Java会为类成员赋予固定的初始值，如数值变量的值为0，布尔变量的值为true，未初始化的引用为null。（ 错 ）
布尔变量的值为false.
6、Java中所有的变量，不管是成员变量还是局部变量，在使用前都必须进行初始化。（ 错 ）
成员变量会自动初始化。
7、在Java中对象可以赋值，只要使用赋值运算符即可，相当于生成了一个各属性与赋值对象相同的新对象。（ 错 ）
对象储存的是地址。引用类型只有一份真实数据。所有还是同一个对象。
8、构造方法用于创建对象，一般不允许有任何返回值，因此需要在构造方法返回类型处标注为void。（ 错 ）
构造方法没有返回值类型
9、画出如下程序的内存结构：
class Engine { int speed; int weight; }
class Car { static int tyreNum = 4; Engine engine; String color; // char sequence :字符序列 void changeColor(String c) { color = c; } void showColor() { System.out.println("我的颜色是：" + color); } }
//测试类和对象 public class TestObject { public static void main(String[] args) { Car c1 = new Car(); c1.changeColor("红色"); c1.showColor(); System.out.println(Car.tyreNum); System.out.println(c1.tyreNum);
Car c2 = new Car(); Engine e = new Engine(); e.speed = 1000; e.weight = 10; c2.engine = e; c2.color = "黑色";
c2.tyreNum = 10; System.out.println(c1.tyreNum); } } |
七、封装作业：
1. |
使用权限修饰符（ C ）修饰的类的成员变量和成员方法，可以被当前包中所有类访问，也可以被它的子类（同一个包以及不同包中的子类）访问。（选择一项） |
|
|
|
|
|
A |
public |
|
B. |
protected |
|
C. |
默认 |
|
D. |
private |
2. |
给出如下代码，如何使成员变量m被方法fun()直接访问（ C ）。（选择一项） |
|
|
class Test { private int m; public static void fun() { } } |
|
|
|
|
|
A |
将private int m 改为protected int m |
|
B. |
将private int m 改为public int m |
|
C. |
将private int m 改为static int m |
|
D. |
将private int m 改为int m 解析：此题考点-----成员变量如何在静态方法内访问 静态方法----优先在方法区开辟空间，非静态成员变量在本类对象创建时才会 在堆内存中开辟空间，一个是先开辟另一个是后开辟，所以不能直接访问。 静态方法内访问成员变量两种方式： 其一：成员变量前加static ,其二：创建对象进行调用。
|
八、继承作业
1、 |
以下关于this和super关键字的说法错误的是（ BD ）。（选择二项） |
|
|
|
|
|
A. |
this关键字指向当前对象自身，super关键字指向当前对象的直接父类 |
|
B. |
在main方法中可以存在this或super关键字，但不能同时存在。 |
|
C. |
this和super关键字都可以访问成员属性，成员方法和构造方法 |
|
D. |
在一个类的构造方法中可以同时使用this和super来调用其他构造方法 解析：此题考点----this super关键字 选项A：this代表本类对象的一个引用，super代表本类直接父类的一个引用 选项B：静态方法、静态代码块等，不允许使用this super关键字。 因为：静态方法等优先开辟空间，在使用this时，对象可能还没有 创建，所以JVM不允许在静态方法、静态代码块中使用他们。 选项C：this super代表的是一个引用，可以调用类的属性和方法。 选出D：类的构造方法，首行要么是使用this，要么使用super，只能是二选一 |
2、 |
以下Java程序编译运行后的输出结果是（ A ）。（选择一项） |
|||
|
class HelloA { public HelloA( ) { System.out.println("HelloA"); } { System.out.println("I'm A class"); } static { System.out.println("static A");// ① } } public class HelloB extends HelloA { public HelloB( ) { System.out.println("HelloB"); } { System.out.println("I'm B class"); } static { System.out.println("static B");// ① } public static void main(String[] args) { new HelloB( ); } } |
|||
|
|
|
||
|
A |
static A static B I'm A class HelloA I'm B class HelloB |
C. |
static A I'm A class HelloA static B I'm B class HelloB |
|
B. |
static A static B I'm A class I'm B class HelloA HelloB |
D |
static A static B HelloA HelloB I'm A class I'm B class
|
解析：此题考点-----构造方法、普通代码块、静态代码块
构造方法---使用new关键字进行调用。
---执行子类的构造方法时，JVM先执行一次父类的构造方法。
普通代码块-----从属于对象，只有创建对象时才会开辟空间执行代码。
静态代码块-----优先创建对象时，在方法区内开辟空间。
三者的优先级顺序：
静态代码块 > 普通代码块 > 构造方法
综上所述，得出结论： A
3、 |
下列选项中关于Java中super关键字的说法正确的是（ AD ）。（选择二项） |
|
|
|
|
|
A |
super关键字是在子类对象内部指代其父类对象的引用 |
|
B. |
super关键字不仅可以指代子类的直接父类，还可以指代父类的父类 |
|
C. |
子类通过super关键字只能调用父类的方法，而不能调用父类的属性 |
|
D. |
子类通过super关键字可以调用父类的构造方法 解析：此题考点-----super关键字 选项A： super作为子类直接父类对象的一个引用存在，正确； 选项B：super只能引用子类的直接父类对象，不能一次引用父类的父类。 选项C：为了区分父类和子类重复的属性或方法时，可以使用super进行分区 选项D：允许使用super调用父类的构造方法，则必须是在首行进行调用。 |
4、对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（ × ）
解析： 构造方法，子类只能调用，不能继承。
5、父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ × ）
解析：父类私有的方法，子类不能继承，同时也不能重写。
方法的重写，是建立在继承的基础之上，既然不能继承就无谈重写。
但是私有方法，允许在本类中进行重载，对权限修饰符没有限制。
6、构造方法中，第一句话总是super。（ × ）
解析：不一定是使用super，也可以使用this关键字调用本类其他对象。
7、Object类有一个public方法是toString( )，一个对象通过调用该方法可以获得该对象的字符串表示。（ √ ）
解析：此题考点------Object类的toString方法
此方法目的： 让子类进行重写，重写之后就不会再输出对象在内存当中的
地制值，而是对象所包含的具体内容。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
九、多态作业
1. |
编译运行如下Java代码，输出结果是（ D ）。（选择一项） |
|
|
class Base { public void method(){ System.out.print ("Base method"); } } class Child extends Base{ public void methodB(){ System.out.print ("Child methodB"); } } class Sample { public static void main(String[] args) { Base base= new Child(); base.methodB(); } } |
|
|
|
|
|
A |
Base method |
|
B. |
Child methodB |
|
C. |
Base method Child methodB |
|
D. |
编译错误 解析：此题考点-----对象的多态和父类对象能否调用子类方法。 子类： 在父类中只要不是使用private修饰，子类都可以继承，子类 都可以调用。 父类： 父类对象只能调用自身的方法，子类的方法和属性无权调用； 如果父类的某个方法，被子类重写，那么父类对象调用这个方 法时，调用的是被子类重写之后的方法。 此种情况的前提： 使用对象的向上转型来创建父类对象。 通过发现，父类对象再调用子类的方法，明显的编译错误。 |
十、抽象类+接口
1. |
Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择一项） |
|
|
public class Person { public String name; public Person(String name) { this.name = name; } } public class Test { public static void main(String[] args) { final Person person = new Person("欧欧"); person.name = "美美"; person = new Person("亚亚"); } } |
|
|
|
|
|
A. |
final Person person = new Person("欧欧"); |
|
B. |
person.name = "美美"; |
|
C. |
person = new Person("亚亚"); |
|
D. |
没有错误 |
解析：
final Person person = new Person("欧欧"); person是一个final修饰的对象，所以它的内存地址不能改变
此题考点----final关键字
可以修饰类，此类变为终结类，不能有子类。例如：System Math
可以修饰变量，此变量变为常量，值不能再改变。
可以修饰方法，此方法不能被重写，允许被重载。
可以修饰对象，此对象引用地址不能再改变，但是对象的值允许改变。
2. |
如下Java代码运行的结果是（ B ）。（选择一项） |
|
|
public class Test { final int age; public Test(){ age=10; } public static void main(String[ ] args) { System.out.println(new Test().age); } } |
|
|
|
|
|
A |
输出：0 |
|
B. |
输出：10 |
|
C. |
输出：null |
|
D. |
运行时出现异常 |
解析： 成员变量是在类对象创建的时候分配存储空间并赋值。
new Test()---匿名对象,调用空参构造方法，在此类空参构造方法当中对age属性进行赋值 age=10,简单的说，赋值是在创建对象之前进行，可以通过，所以最后输出的结果是 10
3. |
以下代码中错误的语句是（ D ）。（选择一项） |
|
|
public class Something{ public static void main(String[] args){ final Other o=new Other(); new Something().addOne(o);//1 } public void addOne( Other o){ o.i++;//2 o = new Other();//3 } } class Other{ public int i; } |
|
|
|
|
|
A |
1 |
|
B. |
2 |
|
C. |
3 |
|
D. |
没有错误 |
解析：
Final 修饰对象o. 第一个是调用方法，没错，第二个是调用方法自加。第三个是在这个方法中， o是一个形参，本身不是上面的fianl修饰的对象o,所以没错。
final Other o=new Other(); 使用final修饰对象，对象的属性值可以改变，
引用不能变。
public void addOne( Other o){
o.i++;//2
o = new Other();//3 此时的o是参数类型Other类对象的引用
}
与第一题当中的区别：
final Person person = new Person("欧欧");
person.name = "美美";
person = new Person("亚亚");
person是同一个引用，不能再改变，而此题当中的Other类的对象引用o不是同一
个，在main方法当中存在一个引用是o，在addOne方法当中有一个对象的引用o
表示的不是同一个，所以编译能通过
4、抽象方法不能含有方法体，并且必须定义在抽象类中。（ 错 ）
解析：在接口中也有抽象方法
十一、异常
1、Java中，处理异常两大方式__捕获异常和抛出异常___try—catch 和 throws_____________。
2、 |
编译并运行如下Java程序，将输出（ D ）。（选择一项） |
||
|
public static void main(String[] args) { try { int num1 = 2; int num2 = 0; int result = num1 / num2; System.out.println(result); throw new NumberFormatException( ); } catch (ArrayIndexOutOfBoundsException e) { System.out.print("1"); } catch (NumberFormatException e) { System.out.print("2"); } catch (Exception e) { System.out.print("3"); } finally { System.out.print("4"); } System.out.print("5"); } |
||
|
|
|
|
|
A |
134 |
|
|
B. |
2345 |
|
|
C. |
1345 |
|
|
D. |
345 解析：此题考点-----捕捉异常 从以上代码发现，int result = num1 / num2; 被除数为零，发生异常 ArithmeticException算术异常，后续的输出语句不再执行，进入到catch 代码块寻找匹配的异常类型，发现没有catch代码块中没有ArithmeticException算术异常，只要让父类异常类型代替子类接收，此处体现了对象的多态-----对象的向上转型；执行此catch块中的代码，打印输出3， 再进行分析，catch块进行匹配了之后，执行finally代码块，输出4， 还有最后一句System.out.print("5");它不再try catch finally中，最后执行它， 输出5，所以------最后结果：345
|
|
3、 |
阅读如下Java代码，在控制台输入"-1",执行结果是（B）。（选择一项） |
||
|
public class Demo { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.print("请输入数字："); try { int num = input.nextInt(); if (num < 1 || num > 4) { throw new Exception("必须在1-4之间！"); } } catch (InputMismatchException e) { System.out.println("InputMismatchException"); } catch (Exception e) { System.out.println(e.getMessage()); } } } |
||
|
|
|
|
|
A |
输出：InputMismatchException |
|
|
B. |
输出：必须在1-4之间！ |
|
|
C. |
什么也没输出 |
|
|
D. |
编译错误 解析：此题考点-----try cath 中使用throw关键字 其一：只有try代码块中出现异常才会执行catch代码块。 其二：throw在代码块中出现，需要进行捕捉 其三：Exception当中的存在一个获取异常信息的方法---getMessage()方法 执行顺序： 第一步：在执行try代码块中，出现throw关键字，相当于出现异常。 第二步：和catch代码块中依次进行匹配，和最后一个catch块匹配上 执行此代码块中的执行语句-----调用getMessage()方法 输出结果："必须在1-4之间！"
|
|
十二、递归和查找
1. 常见的排序算法时间复杂度级别有哪些，按照效率从高到底排列
2. 递归的特点、优点和缺点。
优点：
1. 简洁
2.在树的前序，中序，后序遍历算法中，递归的实现明显要比循环简单得多。
缺点：
1.递归由于是函数调用自身，而函数调用是有时间和空间的消耗的：每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址以及临时变量，而往栈中压入数据和弹出数据都需要时间。->效率
2.递归中很多计算都是重复的，由于其本质是把一个问题分解成两个或者多个小问题，多个小问题存在相互重叠的部分，则存在重复计算，如fibonacci斐波那契数列的递归实现。->效率
3.调用栈可能会溢出，其实每一次函数调用会在内存栈中分配空间，而每个进程的栈的容量是有限的，当调用的层次太多时，就会超出栈的容量，从而导致栈溢出。->性能
十三、排序算法
十四、常用工具类作业
4. |
以下关于StringBuffer类的代码的执行结果是（ D ）。（选择一项） |
|
|
public class TestStringBuffer { public static void main(String args[]) { StringBuffer a = new StringBuffer("A"); StringBuffer b = new StringBuffer("B"); mb_operate(a, b); System.out.println(a + "." + b); } static void mb_operate(StringBuffer x, StringBuffer y) { x.append(y); y = x; } } |
|
|
|
|
|
A. |
A.B |
|
B. |
A.A |
|
C. |
AB.AB |
|
D. |
AB.B |
9. |
分析下面的Java程序，编译运行后的输出结果是（ D ）。（选择一项） |
|
|
public class Example { String str = new String("good"); char[] ch = { 'a', 'b', 'c' }; public static void main(String args[]) { Example ex = new Example( ); ex.change(ex.str, ex.ch); System.out.print(ex.str + "and"); System.out.print(ex.ch); } public void change(String str, char ch[]) { str = "test ok"; ch[0] = 'g'; } } |
|
|
|
|
|
A |
goodandabc |
|
B. |
goodandgbc |
|
C. |
test okandabc |
|
D. |
test okandgbc |
因为str是String类型，String的值是不变对象的，所谓的不变对象就是每次创建新的String，就是在堆中产生一个新的对象。因此ex.str属性依然指向原来的String地址，其它的值还是指向原值，没有改变。 而ch都指向同一个，修改的是ch指向的地址的内容，所以改变。
十五、容器
1. 在Java中 HashMap 集合的访问时间接近稳定，它是一种键值对映射的数据结构。这个数据结构是通过数组来实现的。
2. |
如下Java代码，输出的运行结果是（ A ）。（选择一项） |
||
|
public class Test { public static void main(String[ ] args) { List list.add("str1"); list.add(2, "str2"); String s=list.get(1); System.out.println(s); } } |
||
|
|
|
|
|
A |
运行时出现异常 |
|
|
B. |
正确运行，输出str1 |
|
|
C. |
正确运行，输出str2 |
|
|
D. |
编译时出现异常 解析：此题考点-----List集合中添加元素 add(int index,Object obj)方法指的是在指定位置添加元素。 执行到list.add("str1");之后，此集合中元素的size是1 但是执行list.add(2, "str2");的时候，向下标为2的位置，添加数据 发现：最大的下标值是1，怎么可能在下标值是2的位置添加元素 所以这会出现IndexOutOfBoundsException 下标越界异常。 |
|
3. |
以下Java代码的作用是首先将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（ D ）处错误。（选择一项） |
||
|
import java.util.List; public class Test { public int getIndexofArray(float[] f){ int rtn=-1; float objf=3.4; //此处小数后面应该加F或f List list=null; //此处数组只有声明，没有实例化 for(int i=0;i list.add(f[i]); } for(int i=0;i float tmp=(float)list.get(i); if(objf==tmp){ rtn=i; } } return rtn; } } |
||
|
|
|
|
|
A |
0 |
|
|
B. |
1 |
|
|
C. |
2 |
|
|
D. |
3 解析：同以上发现，有3个错误，具体看代码后面的注释。 |
|
4. |
分析如下Java 代码，编译运行后将输出（ B ）。（选择一项） |
||
|
public class Test { public Test() { } static void print(List al.add(2); al = new ArrayList al.add(3); al.add(4); } public static void main(String[] args) { List al.add(1); print(al); System.out.println(al.get(1)); } } |
||
|
|
|
|
|
A |
1 |
|
|
B. |
2 |
|
|
C. |
3 |
|
|
D. |
4 解析：此题考点------List集合相关方法 1 add(Object obj)添加元素的方法 2 get(int index) 根据索引值获取具体的对象 分析1.main方法中的a1是局部变量，同理print方法中的a1也是局部变量 2局部变量的作用域：只在当前方法或代码块中有效。 也就是main方法中的a1，a1.get(1)调用的是此方法中的List集合对象 对于print方法中的a1，它无能为力，鞭长莫及啊！ |
|
5. |
给定如下Java代码，编译运行的结果是（ C ）。（选择一项） |
||
|
public class Test { public static void main(String[] args) { Map String s = "code"; map.put(s, "1"); map.put(s, "2"); System.out.println(map.size()); } } |
||
|
|
|
|
|
A |
编译时发生错误 |
|
|
B. |
运行时引发异常 |
|
|
C. |
正确运行，输出：1 |
|
|
D. |
正确运行，输出：2 解析：此题考点----Map集合 Map集合特点： key—value键值对 映射关系 Key要求：无序，唯一 Value要求：无序，不唯一 如果发现，键相同----值不同的情况，那么以最后一个键值对为基准 添加到集合中，说白了发生了一次覆盖操作。 map.put(s, "1"); map.put(s, "2"); 两行代码出现了上述情况，所以这次向集合中添加元素只能添加一个 也就是map.put(s, "2"); 所以，此时集合中元素的个数是1
|
|
6、在类已经重写equals和hashCode方法的前提下，equals返回true，hashcode一定相等。（ √ ）
解析：此题考点-------equals和hashCode方法
Equals()方法，最原始存在于Object类中，表示对象在内存当中的地址值。
但是在某些情况下，不能满足子类的要求(想比较对象的内容)，此时需要重
写此方法。
重写此方法时，内部代码有涉及到哈希码的比较。
7、采用增强for循环遍历List或者Set，如果List或者Set没有加泛型，也能遍历。（ √ ）
解析：此题考点------集合的遍历for-each语句
格式如下：
for(数据类型 变量名称:数组/集合名称){
System.out.println(变量名称);
}
分析：数据类型-----元素是什么类型，此处就是什么类型
变量名称-----不要和其他的变量名称冲突即可。
数组/集合名称-------像 arr 或 list
如果集合框架没有使用泛型限制，那么元素的类型默认使用Object。
8、假设文件”a.txt”的长度为100字节，那么当正常运行语句”OutputStream f=new FileOutputStream(new File(“a.txt”));”之后，文件”a.txt”的长度变为0字节。（ √ ）
二十、多线程
1、一个正在执行的线程可能被人为地中断，让出CPU的使用权，暂时中止自己的执行，进入 阻塞 状态。
解析：此题考点------阻塞状态发生的条件
人为的中断正在执行的线程---- 执行wait() 、interrupt() 、sleep()方法等
2、 |
下列关于Thread类提供的线程控制方法的说法中，错误的是（C ）。（选择一项） |
|
|
|
|
|
A |
线程A中执行线程B的join()方法，则线程A等待直到B执行完成 |
|
B. |
线程A通过调用interrupt()方法来中断其阻塞状态 |
|
C. |
若线程A调用方法isAlive()返回值为false，则说明A正在执行中，也可能是可运行状态 |
|
D. |
currentThread()方法返回当前线程的引用 |
解析：此题考点------线程控制的论述
选项A： join()方法—强制加入，加入的线程执行完毕之后才能执行其他线程
选项B：interrupt()方法---线程中断，对。
选项C：isAlive()方法--判断一个线程是否在活动，如果在活动返回真，反之假
选项D：currentThread()方法返回正在执行的线程
从以上得知，C明显错误。
线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。
https://www.cnblogs.com/onlywujun/p/3565082.html
3、线程可以用yield使低优先级的线程运行。（ × ）
解析：此题考点------进程和线程
不管是进程还是线程，都是通过循环获得自己执行的时间片，获得CUP资源
二十一、网络编程
1、统一资源定位符URL是指向互联网“资源”的指针,由4部分组成：协议、存放资源的主机域名、_端口_________和资源路径和文件名。
2. ___IP地址___________用来标志网络中的一个通信实体的地址。通信实体可以是计算机，路由器等。
3. TCP的全称是____Transmission Control Protocol 传输控制协议__________________________。UDP的全称是_______User Datagram Protocol___用户数据报协议_________________________。
4、在Socket编程中，IP地址用来标志一台计算机，但是一台计算机上可能提供多种应用程序，使用 端口 来区分这些应用程序。
5、 |
以下说法中关于UDP协议的说法正确的是（ AD ）。（选择二项） |
||
|
|
|
|
|
A. |
发送不管对方是否准备好，接收方收到也不确认 |
|
|
B. |
面向连接 |
|
|
C. |
占用系统资源多、效率低 |
|
|
D. |
非常简单的协议，可以广播发送 解析： 此题考点-----UDP协议 TCP协议 一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议 。面向连接 、点到点的通信 、高可靠性 、占用系统资源多、效率低 UDP协议 ：一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务 |
|
6、 |
在基于TCP网络通信模式中，客户与服务器程序的主要任务是（BC ）。（选择二项） |
||
|
|
|
|
|
A |
客户程序在网络上找到一条到达服务器的路由 |
|
|
B. |
客户程序发送请求，并接收服务器的响应 |
|
|
C. |
服务器程序接收并处理客户请求，然后向客户发送响应结果 |
|
|
D. |
如果客户程序和服务器都会保证发送的数据不会在传输途中丢失 解析：此题考点------客户端和服务器端 客户端：向服务器发送请求 服务器端：响应客户端 选项A：说法正确，但是不是主要任务 选项B：符合主要任务 选项C：符合主要任务 选项D：说法正确，但是不是主要任务 |
|
7、TCP/IP传输控制协议是Internet的主要协议，定义了计算机和外设进行通信的规则。TCP/IP网络参考模型包括七个层次：应用层、会话层、表示层、传输层、网络层、链路层和物理层。（ × ）
解析：此题考点-------TCP/IP协议集
具体看选择题第一题解析，它包含四个层次：应用层、传输层、网络层、网络接口
