每周一练-选择题1

题目1， 下列哪种情况可以终止当前线程的运行？

A.当一个优先级高的线程进入就绪状态时
B.当该线程调用sleep()方法时
C.当创建一个新线程时
D.抛出一个异常时

答案：D

1.1 解析：

• 优先级高的并不一定会马上执行。
• sleep（）阻塞一个线程并不会终止
• 创建一个新的线程时也不会终止另一个线程
• 当抛出一个异常后程序会结束，所以线程也会被终止

1.2.扩展知识：

区分“终止”和“阻塞”：

• 终止：这个线程不会在进入“就绪态”，宣告死亡，即“死亡状态”
• 阻塞：进入阻塞态的线程还可以再进入“就绪态”，等待下一次 CPU 时间。

然后是对线程的 5 个状态的理解：

1. 新建，刚刚新建的线程，还未进入就绪队列
2. 就绪，进入就绪队列的线程拥有了获得 CPU 时间的机会，但不是一定会马上执行，与线程调度有关。
3. 运行，获得了 CPU 时间，正在被执行的线程。
4. 阻塞，进入阻塞状态的线程只是暂时失去了 CPU 时间，该类线程没有结束，“阻塞态”的线程只能进入到“就绪态”。
5. 死亡，死亡的线程即彻底结束了。

下面总结下使一个线程进入阻塞状态的方法：

1. sleep() / suspend()
2. 发生IO阻塞
3. 等待同步锁
4. 等待通知

解除一个线程的阻塞状态，使之进入就绪态的方法：

1. sleep() 指定的睡眠时间到了
2. IO阻塞解除
3. 获得同步锁
4. 收到通知
5. 调用了 suspend() 的线程阻塞后，再调用 resume() 解除阻塞

题目2：在jdk1.5之后，下列 java 程序输出结果为?

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A. true,false
B. true,true
C. false,true
D. false,false
E. 对于不同的环境结果不同
F. 程序无法执行

答案：B

2.1.解析：

System.out.println(i==j);
基本型和其封装型进行“==”运算符的比较，封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
System.out.println(j.equals(i));
基本型和封装类型调用equals(),参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型
System.out.println(i.equals(j));
编译出错，基本类型不能调用equals();

2.2.扩展：

Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(b==c);//false
System.out.println(b2==c2);//true

System.out.println(b==c);
两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false

题目3 下列Java代码中的变量a、b、c分别在内存的哪个存储区存放。

class A {
	private String a = “aa”;
	public boolean methodB() {
		String b = “bb”;
		final String c = “cc”;
	}
}

A 堆区、堆区、堆区
B 堆区、栈区、堆区
C 堆区、栈区、栈区
D 堆区、堆区、栈区
E 静态区、栈区、堆区
F 静态区、栈区、栈区

答案：C

3.1.解析

a是成员变量，应该在堆区存放，b,c是局部变量，应该在栈区存放

题目4.下列代码的输出结果是什么？

public class ZeroTest {
	public static void main(String[] args) {
		try{
			int i = 100 / 0;
			System.out.print(i);
		}catch(Exception e){
			System.out.print(1);
			throw new RuntimeException();
		}finally{
			System.out.print(2);
		}
			System.out.print(3);
	}
}

A 3
B 123
C 1
D 12

答案：D

4.1.解析

首先执行try，遇到算术异常，抛出，执行catch，打印1，然后抛出RuntimeException，缓存异常，执行finally，打印2，然后抛出RuntimeException。如果catch中没有RuntimeException，则执行结果为123

4.2.扩展

static void Main(string[] args)  
{  
    try  
    {  
        throw new AccessViolationException();  
        Console.WriteLine("error1");  
    }  
    catch (Exception e)  
    {  
        Console.WriteLine("error2");  
    }  
    Console.WriteLine("error3");  
} 

上面这段代码输出：
error2
error3
本题知识点总结：
1.若catch(){}、finally{}块中，若有throw 语句，则try{}catch(){} finally{}块之外的代码不执行。
2.try{}中throw，则下面代码正常执行
扩展内容借鉴自：https://blog.csdn.net/qq_42390340/article/details/108326171

题目5.下面有关JVM内存，说法错误的是？

A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的

B Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的

C 方法区用于存储JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，是线程隔离的

D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

答案：C

5.1解析

方法区在JVM中也是一个非常重要的区域，它和堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息，静态变量，常量。

题目6. 输入流将数据从文件，标准输入或其他外部输入设备中加载道内存，在 java 中其对应于抽象类（）及其子类。

A java.io.InputStream
B java.io.OutputStream
C java.os.InputStream
D java.os.OutputStream

答案：A

6.1 解析

java.io.InputStream : 此抽象类是表示字节输入流的所有类的超类
java.io.OutputStream : 此抽象类是表示字节输出流的所有类的超类

题目7.下面关于程序编译说法正确的是（）

A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
B java编译出来的目标文件与具体操作系统有关
C java在运行时才进行翻译指令
D java编译出来的目标文件，可以运行在任意jvm上

答案：C

7.1 解析

A项，java编译成的是字节码，再被各个系统的jvm翻译成本系统可以识别的机器码，从而实现了“一次编写，到处运行”的跨平台特性
B项，java源文件生成的是.class文件，与系统无关
D项，不一定，还与jvm的版本有关系

题目8.下面程序的运行结果：()

public static void main(String args[]) {
		Thread t=new Thread(){
		public void  run(){
			dianping();
			
		}
	};
	t.run();
	System.out.print("dazhong");
	}
	static void dianping(){
		System.out.print("dianping");
}

A dazhongdianping
B dianpingdazhong
C a和b都有可能
D dianping循环输出，dazhong夹杂在中间

答案：B

题目9.在Java中，以下关于方法重载和方法重写描述正确的是？

A 方法重载和方法的重写实现的功能相同
B 方法重载出现在父子关系中，方法重写是在同一类中
C 方法重载的返回值类型必须一致，参数项必须不同
D 方法重写的返回值类型必须相同或相容。

答案：D

9.1 解析

方法重载（overload）：
1.必须是同一个类
2.方法名（也可以叫函数）一样
3.参数类型不一样或参数数量不一样
4.返回值类型可以不同

方法的重写（override）：
1.方法名相同，参数类型相同
2.子类返回值类型小于等于父类方法返回类型，
3.子类抛出异常小于等于父类方法抛出异常，
4.子类访问权限大于等于父类方法访问权限。

题目10.下列哪些语句关于内存回收的说明是正确的? ( )

A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象

答案：B

10.1 解析

A、JVM一旦启动，就会创建一个守护线程来监测是否需要有对象内存被释放。
C、无法直接释放。
D、不可以指定时间，System.gc()，只是提醒JVM可以进行一次Full GC，但是什么时候真正执行，还是不知道的。

题目11.下列语句正确的是：

A 形式参数可被字段修饰符修饰
B 形式参数不可以是对象
C 形式参数为方法被调用时真正被传递的参数
D 形式参数可被视为local variable

11.1 解析

A项，形参可以被看作是局部变量local variable
B项，对于形式参数只能用final修饰符，其他任何修饰符都会引起编译器报错，但是用这个修饰符有限制，就是在方法中不能对参数做任何修改，所以，一般情况下，一个方法的形参不用final修饰
C项，真正被传递的是实参的值，不是形参
D项，形参可以是对象，如果形参时对象，那么形参里面存储的就是对象的引用

题目12.下列哪种情况可以终止当前线程的运行？

A 当一个优先级高的线程进入就绪状态时
B 当该线程调用sleep()方法时
C 当创建一个新线程时
D 抛出一个异常时

答案：D

A项，优先级高不一定马上执行
B项，进入sleep，并没有终止当前线程的运行
C项，当创建新的线程，并不会终止当前线程

题目13.关于下面一段程序，说法正确的是？

String s1="abc"+"def";//1
String s2=new String（s1);//2
if(s1.equals(s2))//3
System.out.println(".equals succeeded");//4
if(s1==s2)//5
System.out.println("==succeeded");//6

A 行4，行6都不执行
B 行6执行，行4不执行
C 行4执行，行6不执行
D 行4，行6都将执行

答案：C
equals()：比较两个字符串内容是否相等
==：比较两个字符串地址值是否相等

题目14.用命令方式运行以下代码的运行结果是（）

public class f{
	public static void main(String[] args){
	String foo1 = args[1];
	String foo2 = args[2];
	String foo3 = args[3];
	}
}

命令: java f a b c
A 程序编译错误
B a b c
C 程序运行错误
D f

答案：C

题目15.若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（）

A char
B int
C double
D float

答案：C
自动类型转换：在任何涉及两种数据类型的操作中，它们之间等级较低的类型会被转换成等级较高的类型。double>int>char，因此结果是double类型

题目16.下列说法正确的是

A 在类方法中可用this来调用本类的类方法
B 在类方法中调用本类的类方法可直接调用
C 在类方法中只能调用本类的类方法
D 在类方法中绝对不能调用实例方法

答案：B
A项，类方法通过类调用，this和对象实例相关联
C项，在类方法中可以调用外部其他类的方法，通过创建实例对象调用类的实例方法
D项，静态方法中不可以调用非静态方法，如下：

 public static void staticMethod() {
		
		//nonStaticMethod();编译时就错了
	}
	
	public void nonStaticMethod() {
	}

题目17.可将语句块或方法设为同步使用的语句是（）

A synchronized
B static
C abstract
D final

答案：A

题目18.以下哪项不属于java类加载过程？

A 生成java.lang.Class对象
B int类型对象成员变量赋予默认值
C 执行static块代码
D 类方法解析

答案：B
类的加载包括：加载，验证，准备，解析，初始化。

题目19.java中下面哪个能创建并启动线程（）

public class MyRunnable implements Runnable { 
     public void run() { 
         //some code here 
     } 
 }

A new Runnable(MyRunnable).start()
B new Thread(MyRunnable).run()
C new Thread(new MyRunnable()).start()
D new MyRunnable().start()

19.1解析

首先：创建并启动线程的过程为：定义线程–>实例化线程–>启动线程。

• 定义线程： 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
• 实例化线程：
  1、如果是扩展java.lang.Thread类的线程，则直接new即可。
  2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：
  Thread(Runnable target)
  Thread(Runnable target, String name)
  Thread(ThreadGroup group, Runnable target)
  Thread(ThreadGroup group, Runnable target, String name)
  Thread(ThreadGroup group, Runnable target, String name, long stackSize)
  所以A、D的实例化线程错误。
• 启动线程： 在线程的Thread对象上调用start()方法，而不是run()或者别的方法。
  所以B的启动线程方法错误。