每天搞懂10道Java基础题day01

每日10道Java基础题

第一题

1.下面有关java的一些细节问题，描述错误的是？
A：构造方法不需要同步化
B：一个子类不可以覆盖掉父类的同步方法
C：定义在接口中的方法默认是public的
D：容器保存的是对象的引用

正确答案: B
解析：构造方法每次都是构造出新的对象，不存在多个线程同时读写同一对象中的属性的问题，所以不需要同步 。
如果父类中的某个方法使用了 synchronized关键字，而子类中也覆盖了这个方法，默认情况下子类中的这个方法并不是同步的，
必须显示的在子类的这个方法中加上 synchronized关键字才可。当然，也可以在子类中调用父类中相应的方法，
这样虽然子类中的方法并不是同步的，但子类调用了父类中的同步方法，也就相当子类方法也同步了
接口里面的变量为常量，其实际是 public static final ；接口里面的方法为抽象方法，其实际是public abstract。

第二题

2.public class SystemUtil{
public static boolean isAdmin(String userId){
return userId.toLowerCase()“admin”;
}
public static void main(String[] args){
System.out.println(isAdmin(“Admin”));
}
}
A：true
B：false
答案：B
解析：""是判断地址值是否相等。首先要知道toLowerCase()的底层实现是
return new String(result, 0, len + resultOffset);
所以底层new 了一个新的字符串并且返回。

第三题

3.关于访问权限说法正确 的是 ？ ( )
A:外部类前面可以修饰public,protected和private
B:成员内部类前面可以修饰public,protected和private
C:局部内部类前面可以修饰public,protected和private
D:以上说法都不正确
答案:B
解析：（ 1 ）对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。因为外部类没有处于任何类的内部，
也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
外部类的上一层单元是包，对于外部类来说，
只有两个作用域：同包或者任何位置，因此只需要两种控制权限：包控制权限和公开控制权限，即default和public。
（ 2 ）内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、
同一个包（ protected ）和任何位置（ public ）。
（ 3 ） 因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，
所以所有的局部成员都不能使用访问控制修饰符修饰。

第四题

4.instanceof运算符能够用来判断一个对象是否为:
A：一个类的实例
B：一个实现指定接口的类的实例
C：全部正确
D：一个子类的实例
答案：C
解析：instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

第五题

5.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
Object obj = it.next();
if (needDelete(obj)) //needDelete返回boolean，决定是否要删除
{
//todo delete
}
index ++;
}
A:it.remove();
B:list.remove(obj);
C:list.remove(index);
D:list.remove(obj,index);
答案: A
解析：如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：
for(int i=0;i<list.size();i++){
list.remove(…);
}
循环过程中list.size()的大小变化了，就导致了错误。
所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，
还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，
调用之前至少有一次next()方法的调用。

第六题

6.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
package NowCoder;
class Test {
public static void hello() {
System.out.println(“hello”);
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}
A:能编译通过，并正确运行
B:因为使用了未初始化的变量，所以不能编译通过
C:以错误的方式访问了静态方法
D:能编译通过，但因变量为null，不能正常运行
答案: A
解析：因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，
所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法！

第七题

7.将下列哪个代码（A、B、C、D）放入程序中标注的【代码】处将导致编译错误？
class A{
public float getNum(){
return 3.0f;
}
}
public class B extends A{
【代码】
}
A:public float getNum(){return 4.0f}
B:public void getNum(){}
C:public void getNum(double d){}
D:public double getNum(float d){return 4.0d}
答案: B
解析：这里访问权限都相同，返回类型都是基本类型，只看相不相同就可以
知道两同两⼩⼀⼤原则，却不清楚如果⽅法的返回类型是void和基本数据类型，则返回值重写时不可修改。
但是如果⽅法的返回值是引⽤类型，重写时是可以返回该引⽤类型的⼦类的。

第八题

8.下列描述错误的是?
A：类只能继承一个父类，但是可以实现多个接口
B：抽象类自身可以定义成员而接口不可以
C:抽象类和接口都不能被实例化(忽略匿名内部类)
D:一个类可以有多个父类和多个基接口
正确答案: B D
解析：a、java为单继承，多实现。可以实现多个接口。
b、接口允许定义成员，但必须是常量。
c、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
d、同A，单继承，多实现。

第九题

9.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
public class HelloB extends HelloA
{
public HelloB()
{
}
{
System.out.println(“I’m B class”);
}
static
{
System.out.println(“static B”);
}
public static void main(String[] args)
{
new HelloB();
}
}
class HelloA
{
public HelloA()
{
}
{
System.out.println(“I’m A class”);
}
static
{
System.out.println(“static A”);
}
}
A
static A
I’m A class
static B
I’m B class
B
I’m A class
I’m B class
static A
static B
C
static A
static B
I’m A class
I’m B class
D
I’m A class
static A
I’m B class
static B
正确答案: C
只要记住，不论怎样，必定先执行静态代码，子由父生，所以父类必先执行，由此可以筛选出答案C

第十题

10有关finally语句块说法正确的是（ ）
A:不管catch是否捕获异常，finally语句块都是要被执行的
B:在try语句块或catch语句块中执行到System.exit(0)直接退出程序
C:finally块中的return语句会覆盖try块中的return返回
D:finally 语句块在 catch语句块中的return语句之前执行
答案: A B C
结论：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

举例：

情况1：try{} catch(){}finally{} return;
显然程序按顺序执行。

情况2:try{ return; }catch(){} finally{} return;
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，最后执行try中return;
finally块之后的语句return，因为程序在try中已经return所以不再执行。

情况3:try{ } catch(){return;} finally{} return;
程序先执行try，如果遇到异常执行catch块，
有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，
最后执行catch块中return. finally之后也就是4处的代码不再执行。
无异常：执行完try再finally再return.

情况4:try{ return; }catch(){} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。

情况5:try{} catch(){return;}finally{return;}
程序执行catch块中return之前（包括return语句中的表达式运算）代码；
再执行finally块，因为finally块中有return所以提前退出。

情况6:try{ return;}catch(){return;} finally{return;}
程序执行try块中return之前（包括return语句中的表达式运算）代码；
有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
则再执行finally块，因为finally块中有return所以提前退出。
无异常：则再执行finally块，因为finally块中有return所以提前退出。

最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
编译器把finally中的return实现为一个warning。