周考三错题

typora-copy-images-to: 错题本图片

1下面不属于java.lang.RuntimeException子类的是(D)。运行时异常

A. java.lang.NullPointerException 空指针异常

B. java.lang.ArrayIndexOutOfException 数组越界

C. java.lang.IllegalArgumentException 错误参数

D. java.lang.ClassNotFoundException 找不到类 编译时异常

运行时异常是隐式向上抛的，非运行时异常不会隐式向上抛故必须显式指定throws怎样去解决。

throw用于抛出异常对象；

• 1、如果异常对象为运行时，则方法参数列表后面可以不使用throws，也可以将异常抛给方法调用者；try-catch

2、如果异常对象为检查时，则方法参数列表后面使用throws抛出创建该对象的类；或try-catch

throw与throws的区别： 抛出的东西不同：throw抛出的是具体的异常对象，而throws抛出的是抽象的异常类； 使用位置不同：throw一般用在方法体中，也可用在代码块中，但是如果抛出的是检查时异常类创建的对象，则必须使用try-catch自行处理； throws只能用在方法声明括号后面；

编译时异常必须用throws，运行时异常可以选择用throws。

​​​​​​​ 

2调用test$1方法，输出的结果是( B )。

public void test$1() {
System.out.println(dao()); //调用dao()
}
​
private int dao() {
try {
  access();  //1.调用access() 抛出异常
  return 1;
}catch(SQLException e) {
  System.out.println("catch"); // 2.打印异常
  return -1;  //4.返回-1
}finally{
  System.out.println("finally"); // 3.最终打印
}
}
​
private void access() throws SQLException {
throw new SQLException();
}

输出：catch

finally

-1

 

代码中既有return和finally，finally中的代码在return前面执行------> 这里强调的是在return的结束方法之前执行

3调用下面的测试代码( )。

public static void main(String[] args) throws Exception {
EmpService empService = new EmpService();
  empService.checkEmp();
}
控制台提示如下异常信息：
Exception in thread "main" thre.ServiceException: //服务异常
at thre.EmpServic.checkEmp(EmpServic.java:9)
at thre.CoreTest.main(CoreTest.java:16)
Caused by: thre.DAOException: //数据访问失败
  at thre.EmpDAO.getEmp(EmpDAO.java:7)
  at thre.EmpServiccheckEmp(EmpServicjava:7)
     ... 1 more

下列正确的推断的是： C

A. ServiceExcepiton一定是RuntimeException的子类

B. ServiceException一定不是RuntimeException的子类

C. EmpService的checkEmp方法抛出异常ServiceException

的原因是由于其调用的EmpDAO的getEmp方法抛出了DAOException

D. EmpDAO的getEmp方法抛出异常DAOException

的原因是由于其调用的EmpService的checkEmp方法抛出了ServiceException

4 FileOutputStream的构造方法声明抛出java.io.IOException，则下面语句会有编译错误的是（ C）

A. public void fun() throws IOException{ }

B. public void fun() throws IOException {

new FileOutputStream("fil.txt");

}

C. public void fun() 加throws FileNotFoundException {

 try {

new FileOutputStream("fil.txt");

  }catch(IOException e) {
​
      //TODO 处理语句

throw e;

 }

}

D. public void fun() throws IOException {

try {

new FileOutputStream("fil.txt");

} finally {

//TODO 处理语句

}

}

1. 以下代码运行输出是( D )

public class  Animal{
   private String name ="Joan"; //私有属性 只能在本类访问
   int age = 0;
}
​
public class Dog extends Animal{
   public String color;
   
   public static void main(String[] args){
       Animal ani = new Dog(); // 向上转型 展示类型Animal 真实类型Dog
       System.out.println(ani.name); //子类转父类 传参使用展示类型
   }
}

A. 没有输出

B. 输出: Joan

C. 运行报错

D. 编译报错

7.下面程序不抛出异常且可以输出理应的精确运算结果是(D )。

A. BigDecimal b1 = new BigDecimal(3);

BigDecimal b2 = new BigDecimal(2.9);

BigDecimal b3 = b1.subtract(b2); //subtract 减法 double类型 精度丢失

System.out.println(b3); //0.100000000000000088

B. BigDecimal b1 = new BigDecimal("1");

BigDecimal b2 = new BigDecimal("3");

BigDecimal b3 = b1.divide(b2); //1/3 除法 商为0 抛算术异常ArithmeticException 非终止十进制扩展；没有精确可表示的十进制结果。

System.out.println(b3);

C. BigDecimal b1 = new BigDecimal(0.1);

BigDecimal b2 = new BigDecimal(0.2);

BigDecimal b3 = b1.add(b2); //0.300000000000000016653

System.out.println(b3);

D. BigDecimal b1 = new BigDecimal(“3”);

BigDecimal b2 = new BigDecimal(“2.9”);

BigDecimal b3 = b1.subtract(b2);

System.out.println(b3); //0.1

BigDecimal 大小数 需要字符串来避免精度丢失

c.set(Calendar.MONTH, 1); 0-11 2月

c.set(Calendar.DATE, 32); 自动往前加 闰年2月29天 +3 =3月3日

9 关于自定义异常类MyException的实现如下，若该段代码正常运行，则以下说法正确的是（C ）。

 private String detail;
public  MyException(String message) {
   detail = message;
}
public String toString() {
   return "MyException[" + detail + "]";
}
​
​
public class People {
   private int num = 0;
   public void setnum(int value){
       if ((value<0)||(value>100)){
           throw new MyException("Out of bound.value= "+value);  //2
​
       }
   }
}
public static void main(String[] args) {
   try {
       throw new MyException("An Exception occurred~");  //1
   } catch (MyException e) {
       System.out.println(e);
   }
   try {
       People p = new People();
       p.setnum(102);
   } catch (MyException e1) {
       System.out.println(e1);
   }
}

A. 输出结果为 MyException[]

B. MyException[Out of bound.value= 102]

C. MyException属于Runtime异常

D. MyExcption属于checked异常

E. 输出结果为MyException[An Exception occurred~]

11.public String makinStrings(){ String s=”Fred”; 常量 类加载

s=s+”47”;

s=s.substring(2,5);

s=s.toUpperCase ();

return s.toString(); 不产生新对象

} //执行后创建的对象有3个对象

一共有6个对象

以上代码被执行后有( E )个对象。 执行该方法之后执行了（3 ）个对象

A.1 B.2 C.3 D.4 E.5 F.6

1. 已知变量a和obj的定义如下：

Object[] a1 = { "a", "b", "c" };

Object obj = a1;

则下面语句运行时会抛出异常的是(C )。

A. Object[] a2 = (Object[])obj;

B. String str1 = (String)((Object[])obj)[1]

C. String[] a3 = (String[])obj

D. String str2 = (String)a1[2]

public class Point {
private int x;
private int y;
​
public boolean equals(Object obj) {
   if(obj.x == this.x && obj.y == this.y){ //obj.x obj。y报错
       return true;
   }
   return false;
}
}

int i = ss.indexOf("cde", 3); （开始位置，第几个）

18.关于下面程序片段,( B )的结论是正确.

String a =”Java”;

String b=”Java”;

String x =”Ja”;

String y = “va”;

String c = x+y; // //编译时没计算出来 a == c false 变量直接拼接 开辟新的地址码

A. a和b指向同一个实例对象,a和c指向同一个实例对象

B. a和b指向同一个实例对象,a和c不指向同一个实例对象

C. a和b不指向同一个实例对象,a和c指向同一个实例对象

D. a和b不指向同一个实例对象,a和c不指向同一个实例对象

String s = new String(“hello”); String s1 = "hello";

s和s1 所指向的地址值不一样。但是最终指向的都是常量池中的"hello”;

并不是把 s 的值进行了修改。而是在常量池中创建了新的地址存放了“qwe”， 然后s 指向“qwe”这个新地址

3.常量：先进行拼接，然后再常量池中找。找到了直接给地址值；找不到开辟空间在赋值；

变量：直接进行拼接，然后赋值，再将地址值传给main方法中的引用

1. 下列代码运行的结果是( B )

public class Example{

　　String str=new String("good"); //new 地址码

　　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 "+ex.ch);

　　}

　　public void change(String str,char ch[]){

　　　　str="test ok"; //常量池新创建 地址码 赋给str 与ex.str两码事

　　　　ch[0]='g'; //传的是地址码

　　}

}

A、 good and abc

B、 good and gbc

C、test ok and abc

D、 test ok and gbc

Random random = new Random();

int ran = random.nextInt(3); //大于等于1 小于3

\22. 给出下面的代码运行结果：**（** C ）

public static void main(String args[]) {

Set ts = new TreeSet();

ts.add("a"); 字符串

ts.add("c");

ts.add("b");

Iterator it = ts.iterator();

while(it.hasNext()){

System.out.print(it.next());

}

}

输出：abc

\22. 阅读下面代码，其中共有（3）处错误。

import java.util.List;

public class Test{

public int getIndexOfArray(float[] f){

int rtn = -1;

float objf = 3.4; //double 强制转换为float

		List list = null;

for(int i = 0; i < f.size();i++){ //f是数组 是f.length()

list.add(f(i));

}

for( int i = 0; i < list.size();i++){

float temp = (float)list.get(); //get()里面没有i

if(objf == temp){

rtn = i;

}

}

return rtn；

}

}