java面向对象考试题.doc

. -
第一题:
public static void main (String[] args){
String[] fileNames = { "abc.txt", "bcd.exe", "cde.exe","def.dat","efg.exe" };
for (String fileName : fileNames) {
if (fileName.endsWith(".exe")) {
System.out.print(fileName.substring(0, fileName.lastIndexOf(".exe"))+" ");
}
}
}
fileName.endsWith(".exe") 判断是否已".exe"结尾
substring(0,4) 截取0-3的字符串,不包含4
lastIndexOf(".exe") 获取".exe"最后一次出现的位置
答案:bcd cde efg

第二题:
public static void go(Long n) {
System.out.println("Long");
}
public static void go(Short n) {
System.out.println("Short");
}
public static void go(int n) {
System.out.println("int");
}
public static void main(String[] args) {
short y = 6;
long z = 7;
go(y);
go(z);
}
虽然y是short型的，但是编译器把它转换为int型
答案:int Long

第三题:
public static void main(String[] args){
String test = "Test A. Test B. Test C.";
String regex = "\\.\\s*";
String[] result = test.split(regex);
for(String s : result)
System.out.print(s + " ");
}
\s 空白字符 *表示0个或任意多个 text.split("\\.")按.拆分
答案: Test A Test B Test C

第四题:
public class AA{
private Long userId;
private String nickName;
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public static void main(String[] args){
AA m1=new AA();
m1.setUserId(new Long(100001));
m1.setNickName("mick");
AA m2=new AA();
m2.setUserId(new Long(100001));
m2.setNickName("mick");
System.out.println(m1==m2);
System.out.println(m1.equals(m2));
}
equals方法返回值也是return m1==m2
答案:false false

第五题
运行以下代码，输出为false的是：〔〕。
A.String st1 = "abc";System.out.println("abc" == st1);
B.String st2 =
"abc"System.out.println(st2.equals(newString("abc")));
C.Integer i = 100; System.out.println(100 == i);
D.ArrayList list = new ArrayList();
System.out.println(list.contains(null));
答案：D

第六题
public interface Cookie{
Cookie cookie=new Cart ("小面包","盼盼");
}
public class Cart implements Cookie{
private String name;
private String production;
public Cart(String name,String production){
this.name=name;
this.production=production;
}
public void smell(){
cookie =new Cart("蛋黄派","达利园");
}
}
final 要求属性不可更改cookie =new Cart("蛋黄派","达利园"); 这个修改了 cookie的地址，所以报错

第七题
(多项选择)请看以下代码：
public abstract class Shape {
int x;
int y;
public abstract void draw();
public void setAnchor(int x, int y) {
this.x = x; this.y = y;
}
}
以下选项中能正确使用Shape类的是：
A.public class Circle implements Shape { private int radius; }
B.public abstract class Circle extends Shape { private int radius; }
C.public class Circle extends Shape { private int radius; public void draw(); }
D.public class Circle extends Shape {
private int radius;
public void draw() {
}
}
抽象类不可以实例化,如果一个类继承了抽象类,必须重新其抽象方法
答案：BD

第八题
(多项选择)请看以下代码：
package .tarena;
public class Geodetics {
public static final double DIAMETER = 12756.32;
}
访问静态常量DIAMETER的方式正确的选项是：
A.import .tarena.Geodetics;
public class TerraCarta {
public double halfway(){
return Geodetics.DIAMETER/2.0;
}
}
B.import .tarena.Geodetics;
public class TerraCarta {
public double halfway(){
return DIAMETER/2.0;
}
}
C.import .tarena;
public class TerraCarta {
public double halfway(){
return Geodetics.DIAMETER/2.0;
}
}
D.import .tarena.*;
public class TerraCarta {
public double halfway(){
return Geodetics.DIAMETER/2.0;
}
}
答案：AD

第九题
(多项选择)在Java语言中，以下说法正确的选项是〔〕。
A.一个接口可以继承多个接口
B.一个类可以继承多个类
C.一个类可以实现多个接口
D.一个类可以有多个子类
答案：ACD

第十题
(多项选择)在<插入代码>处，填入以下代码编译正确的选项是：public void foo(int[] x) { < 插入代码> }
A.foreach(int z : x) System.out.println(z);
B.for(int z : x) System.out.println(z);
C.while( x.hasNext()) System.out.println( x.next());
D.for( int i=0; i< x.length; i++ ) System.out.println(x[i]);
答案：BD

第十一题
(多项选择)查看如下代码：
class A { protected int method (int a, int b) { return 0; }}
以下选项中，可以在 A 的子类中使用的是〔〕。
A.public int method (int a, int b) { return 0; }
B.private int method(int a, int b) { return 0; }
C.private int method(int a, long b) { return 0; }
D.public short method(int a, int b) { return 0; }
A：重写A类中的方法 C：重载A类中的方法
答案：AC

第十二题
(多项选择)在Java语言中，以下说法正确的选项是：〔〕。
A.StringBuffer和StringBuilder的区别在于：StringBuffer是线程平安的而 StringBuilder不是。
B.String是不可变对象，而StringBuffer中封装的字符串数据是可以动态改变的
C.判断两个StringBuilder对象的字符序列是否一样，可以调用其equlas方法进展比拟。
D.String的重写了equals方法，重写的逻辑是：字符序列一样的String对象 equals方法返回true。
答案：ABD

第十三题
(多项选择)题目代码的功能为：输出每个字符在一个字符串中出现的次数(不区分大小写)。
String str = "ewrwqFrewqfsadfdsfdsfs";
str=str.toLowerCase();
int max_length = 0;
while (str.length() > 0) {
?插入代码?
}
A. int length = str.length();
char first=str.charAt(0);
String strNew = str.replaceAll(String.valueOf(first), "");
if (length>strNew.length()) {
max_length = length - strNew.length();
System.out.println(first+":"+max_length);
}

B. int length = str.length();
char first=str.charAt(0);
String strNew = str.replaceAll(String.valueOf(first), "");
if (length>strNew.length()) {
max_length = length - strNew.length();
str = strNew;
System.out.println(first+":"+max_length);
}

C. int length = str.length();
String first = str.substring(0, 1);
String strNew = str.replaceAll(first, "");
if (length>strNew.length()) {
max_length = length - strNew.length();
str = strNew;
System.out.println(first+":"+max_length);
}

D. int length = str.length();
String first = str.substring(0, 1);
String strNew = str.replaceAll(first, "");
if (length>strNew.length()) {
max_length = length - strNew.length(); System.out.println(first+":"+max_length);
}
答案：BC

第十四题
(多项选择)下面的方法属于StringBuffer的是：〔〕。
A.size
B.insert
C.delete
D.length
答案：BCD

第十五题
(多项选择)请看以下代码：
public class Old {
public static Object get(List list) {
return list.get(0);
}
}
以下选项调用get方法，能编译通过的是：
A.Object o = Old.get(new LinkedList());
B.Object o = Old.get(new LinkedList<?>());
C.String s = Old.get(new LinkedList<String>());
D.String s = (String)Old.get(new LinkedList<String>());
答案：AD

1.重写必须继承，重载不用。
2.重写的方法名，参数数目一样，参数类型兼容，重载的方法名一样，参数列表不同。
3.重写的方法修饰符大于等于父类的方法，重载和修饰符无关。
4.重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常

public void main (int x){}

int d = 'a'+'b'+'c';对的

第十六题
(单项选择题)从下面四段〔A，B，C，D〕代码中选择出正确的代码段〔〕
(A)abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
(B)public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
(C)public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
(D)public class Something {
public int addOne(final int x) {
return ++x;
}
}
A. 抽象方法不能有方法体。B．方法中定义的是局部变量，不能用类成员变量修饰符 private。D．final 修饰为常量，常量的值不能被改变。

第十七题
(单项选择题)以下关于 interface 的说法正确的选项是〔〕
(A)interface 中可以有 private 方法
(B)interface 中可以有 final 方法
(C)interface 中可以有 function 实现
(D)interface 可以继承其他 interface
A. 接口中不可以有 private 的方法。B．接口中不可以有 final 的方法接口中的方法默认是 public abstract 的。C．接口中的方法不可以有实现

第十八题
(单项选择题)在创立对象时，必须〔〕
(A)先声明对象，然后才能使用对象
(B)先声明对象，为对象分配内存空间，然后才能使用对象
(C)先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
(D)上述说法都对
对象是先声明，声明后会在给对象在内存里开辟空间，之后初始化，再进展使用
答案：C

第十九题
(单项选择题)关于以下说法正确的选项是〔〕
1．class StaticStuff
2．{
3． static int x=10;
4． static {x+=5;}
5． public static void main(String args[])
6． {
7． System.out.println("x=" + x);
8． }
9． static {x/=3;}
10.}

(A)4 行与 9 行不能通过编译，因为缺少方法名和返回类型
(B)9 行不能通过编译，因为只能有一个静态初始化器
(C)编译通过，执行结果为：x=5
(D)编译通过，执行结果为：x=3
静态块是类加载的时候就会被执行到的，静态执行顺序是按照在类中出现的先后顺序执行。
答案：D

第二十题
(单项选择题)以下哪种说法是正确的〔〕
(A)本类中实例方法可以调用其他类中所有实例方法
(B)本类中实例方法可以调用其他类中类方法
(C)本类中实例方法可以直接通过方法名调用其他类的实例方法
(D)本类中实例方法可以直接通过方法名调用本类中其他实例方法
A. 本类实例方法不可以调用其他类的私有实例方法。B. 本类实例方法不可以调用其他类的私有类方法。C．本类实例方法不可以直接通过方法名调用其他类的实例方法。
答案：D

第二十一题
(多项选择题)在JAVA接口中可以定义( )。
(A)静态方法
(B)常量
(C)构造方法
(D)抽象方法
接口中只能定义常量和抽象方法。
答案：CD

第二十二题
(多项选择题)下面选项中哪两个可以在 A 的子类中使用〔〕
class A {
protected int method1 (int a, int b) {
return 0;
}
}
(A)public int method1(int a, int b) { return 0; }
(B)private int method1(int a, int b) { return 0; }
(C)private int method1(int a, long b) { return 0; }
(D)public short method1(int a, int b) { return 0; }
B子类重写父类的方法，访问权限不能降低;C属于重载;D子类重写父类的方法如果返回值类型是根本类型的话，要求一样。
答案：AC

第二十三题
(单项选择题)在下面程序的第 7 行补充上以下哪个方法,会导致在编译过程中发生错误〔〕 1) class Super{
2) public float getNum(){
3) return 3.0f;
4) }
5) }
6) public class Sub extends Super{
7) // TODO ...
8) }
(A)public float getNum(){retun 4.0f;}
(B)public void getNum(){}
(C)public void getNum(double d){}
(D)public double getNum(float d){retun 4.0f;}
方法重写、重载的问题。重写要求方法签名(方法名+形参列表)完全一样，返回值类型如果是根本类型或无返回值时必须一致。重载要求方法名一样且参数列表必须不同，与返回值类型无关。
答案：B

第二十四题
(单项选择题)关于以下程序代码的说明正确的选项是〔〕
1． class HasStatic{
2． private static int x=100;
3． public static void main(String args[ ]){
4． HasStatic hs1=new HasStatic();
5． hs1.x++;
6． HasStatic hs2=new HasStatic();
7． hs2.x++;
8． hs1=new HasStatic();
9． hs1.x++;
10． HasStatic.x--;
11． System.out.println("x="+x);
12． }
13．}
(A)5 行不能通过编译，因为引用了私有静态变量
(B)10 行不能通过编译，因为 x 是私有静态变量
(C)程序通过编译，输出结果为：x=103
(D)程序通过编译，输出结果为：x=102
静态变量是所有对象所共享的，所以上述代码中的几个对象操作是同一静态变量x，静态变量可以通过类名调用。
答案：D

第二十五题
(单项选择题)栈是一种〔〕
(A)存取受限的线性构造
(B)存取不受限的线性构造
(C)存取受限的非线性构造
(D)存取不受限的非线性构造
栈〔stack〕在计算机科学中是限定仅在表尾进展插入或删除操作的线性表。
答案：A

第二十六题
(单项选择题)请问，以下哪些修饰符不能用于顶层类？
(A)public
(B)private
(C)abstract
(D)final
对于顶层类(外部类)来说，只有两种修饰符：public和默认(default)。因为外部类的上一单元是包，所以外部类只有两个作用域：同包，任何位置。因此，只需要两种控制权限：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。但是private可以修饰class的，只不过该类不能使顶层类，可以是内部类内部类的上一级是外部类，那么对应的有四种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。当一个内部类使用了private修饰后，只能在该类的外部类内部使用
答案：BCD

第二十七题
(多项选择题)如下哪些不是 java 的关键字〔〕
(A)const
(B)null
(C)false
(D)this
java中，null、true、false都不属于java 的关键字，它们都属于字面量值，都有着特殊的用途，且不建议作为标识符使用。
答案：BC

第二十八题
(多项选择题)下面关于变量及其X围的陈述哪些是不正确的〔〕
(A)类中的普通属性是类的实例变量
(B)实例变量用关键字static声明
(C)局部变量在局部X围外也可以被使用
(D)局部变量在使用前必须被初始化
由static修饰的变量称为类变量或是静态变量，局部变量作用域只在局部X围内部。
答案：BC

第二十九题
子类A继承了父类B，A a = new A();
那么①父类B静态代码块②父类B非静态代码块③父类B构造函数④子类A静态代码块⑤子类A非静态代码块⑥子类A的构造函数的执行顺序是：
①->④->②->③->⑤->⑥

第三十题
写出下面代码的运行结果：
publicclass A{
intage = 9;
public A(intag){
intage = 8;
age = ag;
System.out.print(age);
}
public A(){
this.age = 6;
}
publicstaticvoid main(String[] args){
A a1 = new A(0);
A a2 = new A();
System.out.println( ""+ a1.age +""+ a2.age);
}
}
答案： 0 9 6

super〔参数〕：调用父类中的某一个构造函数〔应该为构造函数中的第一条语句〕。
this〔参数〕：调用本类中另一种形式的构造函数〔应该为构造函数中的第一条语句〕。
class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 

    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 

    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 

public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法〔1〕 
       prt("子类·调用父类〞无参数构造方法“： "+"A chinese coder."); 
    } 

    Chinese(String name) { 
       super(name);// 调用父类具有一样形参的构造方法〔2〕 
       prt("子类·调用父类〞含一个参数的构造方法“： "+"his name is " + name); 
    } 

    Chinese(String name, int age) { 
       this(name);// 调用具有一样形参的构造方法〔3〕 
       prt("子类：调用子类具有一样形参的构造方法：his age is " + age); 
    } 

    public static void main(String[] args) { 
       Chinese = new Chinese(); 
       = new Chinese("codersai"); 
       = new Chinese("codersai", 18); 
    } 

- word.zl.