Java SE 易错题_赋值相当于生成了一个-CSDN博客

本文链接：https://blog.csdn.net/qq_21953671/article/details/79248318

一、初始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<String> list=new ArrayList<String>(); 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<f.size( );i++){//此处数组没有size()方法，只有length属性 list.add(f[i]); } for(int i=0;i<list.size( );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<Integer> al) { al.add(2); al = new ArrayList<Integer>(); al.add(3); al.add(4); } public static void main(String[] args) { List<Integer> al = new ArrayList<Integer>(); 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, String> map = new HashMap<String, String>(); 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：说法正确，但是不是主要任务