Java面向对象面试题
- 选择填空部分 - （60％）
1（多选）。下面写法正确的是（B / C / d）
a）浮点数f = 3.14;
b）双d = 3.14e2;
c）int i = 0015;八进制数
d）char c = 65535;
的java的炭是两个字节的存储空间。也就是16位，2的16次方为65536，也就是0-65535。
2.以下说法正确的是（d）
a）int类型的局部变量默认值是0
b）变量可以定义在类外
c）方法或代码块可以定义在类外
d）变量，方法和代码块都不可以定义在类外
3.下面哪些数组定义是正确的（d）
a）float [] =新浮[3]
b）float f2 [] = new float []
c）float [3] f1 = new float [3] // float [] f1 = new float [3]
d）浮动f4 [] = {1,3,5}
4.下面代码的输出结果为（b）中
int [] [] a = {{1,2}，{3,4}，{5,6}};
的System.out.println（则为a.length）;
- 6
- 3
- 2
- 异常
5.下列修饰符能用来修饰接口（接口）的是（b）中
A.private
B.public
C.protected
D.static
6.下列代码符合构造器结构的是（c）中
a）public void MyClass（）{......}
b）私人MyClass（）
c）MyClass（）{......}
d）静态MyClass（）{......}
7（多选）。下面代码输出为假的是（A / d）
字符串a =“a”;
String b = new String（“b”）;
final String fa =“a”;
final String fb =“b”;
字符串ab =“ab”;
a）System.out.println（（（a + b）== ab））;
b）System.out.println（（（fa + fb）== ab））;
c）System.out.println（（a == fa））;
d）System.out.println（（b == fb））;
e）System.out.println（（“a”+“b”）==（“ab”））;
通过新创建的字符与基本直接定义的字符拼接的结果与新创建的效果一样
8.JDK 1.5及以上版本中，下面代码输出为false的是（c）
int a = 100;
整数b = new Integer（100）;
整数c = Integer.valueOf（100）;
一个）的System.out.println（A == B）;
b）中的System.out.println（A == C）;
c）中的System.out.println（B == C）;
d）的System.out.println（b.equals（C））;
9.以下代码运行后输出的结果是（c）中
| 公共课MC {
static private int num = 0;
public static void main（String [] args）{ MC a = new MC（）; MC b =新MC（）;
a.num ++; b.num ++;
的System.out.println（MC.num）; } } |
一个）0
B）1
c）2名
d）编译错误
10. ArrayList list = new ArrayList（20）;中的列表扩充几次（a）
一个）0
B）1
c）2名
d）3
ArrayList list = new ArrayList（）; 这种是默认创建大小为10的数组，每次扩容大小为1.5倍
ArrayList list = new ArrayList（20）; 这种是指定数组大小的创建，创建时直接分配其大小，没有扩充。
所以，扩充为0次
11.下列有关等于方法与散列码方法的说法正确的是（d）
a）HashSet / HashMap / Hashtable类来存储数据时，都是根据存储对象的euqal方法进行判断是否相同的
B）当两个对象使用等于方法比较返回为真时，其哈希码会自动变为相同的值
c）MyClass类的等于方法的结构为：public boolean equals（MyClass obj）{......}
d）根据JVM的相关协定，当obj1.hashCode（）== obj2.hashCode（）为假时，obj1.equals（obj2）也应为false
12（多选）。下面说法正确的是（B / d）
一）抽象类中的属性不能用静态的修饰
B）抽象类中的抽象方法不能用私人修饰
三）抽奖类中的方法不能用静态的修饰
d）抽象类中的抽象方法不能用静态的修饰
13.下面说法错误的是（c）中
A）接口中的抽象方法只能被公众和抽象的修饰，因此可以不写
b）接口中的成员变量默认都是public static final修饰，因此可以不写
C）接口只能继承接口，抽象类只能继承抽象类
d）抽象类能够继承普通类和抽象类，也可以实现接口
14.Java使用的默认编码集为（d）
一）ASCII
B）ISO-8859-1
C）GB2312
d）的unicode
15.以下代码运行的结果为（a）中
| 公共课MC { public static void main（String [] args）{ 的System.out.println（ “1”）; } }
class mm扩展MC { public static void main（String [] args）{ 的System.out.println（ “2”）; } } |
a）第1
b）第2
C）编译异常
d）死循环
16.以下代码运行的结果是（F）
| 公共课MC { public static void main（String [] args）{ MC mc = new MC（）; mc.fun（）; }
private void throwE（）抛出IOException { //执行这个方法，模拟抛出异常。 抛出新的IOException（）; }
private void fun（）{ 尝试{ throwE（）; 的System.out.println（ “1”）; 回归; } catch（IOException e）{ // TODO自动生成的catch块 的System.out.println（ “2”）; 回归; } finally { 的System.out.println（ “3”）; } } } |
a）编译异常
b）1 3
c）1 2
d）2
e）3
f）2 3
17.完全二叉树共有27个节点，其叶子节点有多少（b）中
一）11
B）14
C）17
d）21
18。以下关于最终关键字说法错误的是（c）中
A）final不能修饰抽象类
B）最终修饰的类不能被继承
C）最终修饰的方法不能被重载
D）最终修饰的变量不允许被再次赋值
19。以下不是对象类定义的方法是（d）
A）克隆（）
B）finalize（）//垃圾回收
C）toString（）
D）hasNext（）扫描仪
20.面向对象的7大设计原则：里氏原则，依赖倒置，迪米特法则，单一职责，接口隔离，开闭原则，缺少（聚合复用）
21.下列说法正确的有（c）中
A）类中的构造方法不可省略
b）中构造方法必须与类同名，但方法不能与类同名
C）构造方法在一个对象被新时执行
d）一个类只能定义一个构造方法
22.下列说法正确的是（c）中
一个）子类能够重写父类的构造方法
B）子类对象生成时，先执行子类的构造方法，再执行父类的无参构造方法
C）当父类没有无参构造方法时，子类构造器的第一句必须使用超（参数列表）方法显式调用父类的构造器
d）子类无法在构造方法中使用此（参数列表）显示调用自身的其他重载构造方法。
23.阅读下面代码，其运行结果为（a）
|
公共课MC {
private String text =“helloword”;
静态的 { System.out.println（“静态代码块”）; }
public MC（）{ 的System.out.println（ “构造”）; }
{ System.out.println（“代码块”）; }
public static void main（String [] args）{ MC mc = new MC（）; 的System.out.println（this.text）; } } |
a）编译出错
b）输出：
静态代码块
代码块
构造函数
HELLOWORD
C）输出：
静态代码块
构造函数
代码块
HELLOWORD
d）输出：
构造函数
静态代码块
代码块
HELLOWORD
24.多态的表现形式为：（a）中
a)重写
b)接口
c)权限
d)垃圾回收
25．阅读下列代码，其运行结果为：(c)
| public class MC extends father{
private String text="text2";
public static void main(String[] args) { MC mc=new MC(); System.out.println(mc.getText()); } }
class father{ private String text="text1"; public String getText() { return text; } } |
a) 编译出错
b) 运行异常
c) text1
d) text2
26．下列打印语句会输出(c)
System.out.println(4|3);
a)4
b)3
c)7
d)0
27．下列哪个类的声明是正确的(d)
a)abstract private move(){}
b)abstract final class HI{}
c)protected private number;
d)public abstract class Car{}
28．对于main方法内定义的整形数组int[] a=new int[10]，以下说法正确的是(a)
a)a[0]的值为0
b)a[0]的值为null
c)编译错误，a数组未初始化
d)a[10]的值为0
29．以下排序算法中，不是稳定排序算法的是(d)
a)冒泡排序
b)插入排序
c)归并排序
d)快速排序 不是稳定排序算法
30．以下程序运行的结果是(a)
| public class MC{
public static void main(String[] args) { String a="11"; String b="11"; System.out.println((a==b)+" "+a.equals(b)); } } |
a) true true
b) false true
c) true false
d) false false
——编程部分——（40%）
1． 现有一个ArrayList，定义如下：（10%）
| List list.add(1); list.add(3); list.add(3); list.add(7); list.add(1); list.add(5); list.add(5); list.add(5); |
请在下方方框内完成方法removal，对该list进行去重，并将结果存放在一个新的List列表中并返回。例如上述list的去重结果应为1,3,7,5（可以打乱顺序）
（注，如果需要这些单词：迭代器拼写Iterator
| public List //进行去重操作
} |
方法一:使用java8新特性stream进行List去重
List newList = list.stream().distinct().collect(Collectors.toList());
System.out.println(“java8新特性stream去重:”+newList);
list.add(39);
方法二:双重for循环去重
for (int i = 0; i < list.size(); i++) {
for (int j = 0; j < list.size(); j++) {
if(i!=j&&list.get(i)==list.get(j)) {
list.remove(list.get(j));
}
}
}
System.out.println(“双重for循环去重:”+list);
list.add(39);
方法三:set集合判断去重,不打乱顺序
Set set1 = new HashSet();
List newList1 = new ArrayList();
for (Integer integer : list) {
if(set1.add(integer)) {
newList1.add(integer);
}
}
System.out.println(“set集合判断去重:”+list);
list.add(39);
方法四:遍历后判断赋给另一个list集合
List newList2 = new ArrayList();
for (Integer integer : list) {
if(!newList2.contains(integer)){
newList2.add(integer);
}
}
System.out.println(“赋值新list去重:”+newList2);
list.add(39);
方法五:set和list转换去重
Set set2 = new HashSet();
List newList3 = new ArrayList();
set2.addAll(list);
newList3.addAll(set2);
System.out.println(“set和list转换去重:”+newList3);
2． 现有int类型的数组定义如下：（10%）
| int[] in= {5,3,7,2,8,1,9,5}; |
请在下方方框内完成方法sort，对该in数组进行从小到大排序，并将结果存放在out数组中并返回。其排序结果应为1 2 3 5 5 7 8 9。
（注：可以使用冒泡排序、插入排序、归并排序或快速排序）
| public int [] sort（int [] in）{ //进行排序操作 int [] out = new int [in.length];
退出; } |
3。现有INT类型的数组定义同第2题，请在下方方框内完成方法洗牌，对该在数组进行洗牌，要求每次洗牌的结果为随机顺序。
（注：如果需要这些单词：随机数类随机，产生0-N的随机数nextInt（N））（10％）
| public void shuffle（int [] in）{ //进行洗牌
} |
4。现有一从小到大排列的数组定义如下：（10％）
| int [] in = {1,4,5,6,9,9,11,11,15,17}; //共10个元素 |
请在下方方框内完成方法二，利用二分查找找到参数关键在数组中存在的位置，并将其位置作为返回。倘若数组中不存在此值，则返回-1，如果存在多个相同的元素，则随意返回其中某个元素的位置即可例如键= 11时，返回6或7;键= 17时，返回8;键= 10时，返回-1。
| public int binary（int [] in，int key）{
返回-1; } |