【每日选择题】11~20天做选择题汇总

---

day 11   4 月23 日测验

---

1.下面哪个标识符是合法的？(D)
A "9HelloWorld"
B "_Hello World"
C "Hello*World"
D "Hello$World"

标识符只能是数字字母下划线组成的，而且不能以数字开头

2.以下java程序代码，执行后的结果是（C）

java.util.HashMap map=new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.size());

A 0
B null
C 1
D 2

Map中键只能出现一次，是惟一的，当出现相同的key时，会覆盖之前的key

 

3.Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是(C)
A ArrayList和LinkedList均实现了List接口
B ArrayList的访问速度比LinkedList快
C 添加和删除元素时，ArrayList的表现更佳
D HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

 

4.以下描述正确的是(B)
A CallableStatement是PreparedStatement的父接口
B PreparedStatement是CallableStatement的父接口
C CallableStatement是Statement的父接口
D PreparedStatement是Statement的父接口

PreparedStatement 是CallableStatement 的父接口, Statement 是PreparedStatement 的父接口

 

5.下列程序的运行结果（B）

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

A pingpong
B pongping
C pingpong和pongping都有可能
D 都不输出

调用的是t线程的run方法知识一个普通的代码，顺序是按照代码出现的顺序执行的

6.下列关于容器集合类的说法正确的是？(C)
A LinkedList继承自List
B AbstractSet继承自Set
C HashSet继承自AbstractSet
D WeakMap继承自HashMap

LinkedList 继承自AbstractSequentialList 实现了List 、Deque 、Cloneable 、java.io.Serializable 接
口
AbstractSet 继承自AbstractCollection ，实现了set 接口
HashSet 继承自AbstractSet ，实现了set 、Cloneable 、java.io.Serializable 接口

 

7.ArrayList list = new ArrayList(20);中的list扩充几次(A)
A 0
B 1
C 2
D 3

ArrayList的底层是数组，如果没有指定长度，则默认大小是10，若指定了大小，则初始大小就是指定值

 

8.以下程序的输出结果是？(B)

public class Example {
    String str = new String("good");
    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 ");
        System.out.print(ex.ch);
    }
    public static void change(String str, char ch[])
    {
        str = "test ok";
        ch[0] = 'g';
    }
}

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

调用change 的方法时，向该方法的str 传入了"good" 的地址，向该方法的数组传入了{'a','b','c'} 的地址，修改str ，将其指
向"test ok" ，但此时ex.str 依旧指向的是"good" .
修改ch 指向的数组的元素， ex.ch 指向的也是该数组，所以看到的是跟着变。

 

9.下面的方法，当输入为2的时候返回值是多少?（D）

public static int getValue(int i) {
    int result = 0;
    switch (i) {
    case 1:
        result = result + i;
    case 2:
        result = result + i * 2;
    case 3:
        result = result + i * 3;
    }
    return result;
}

A 0
B 2
C 4
D 10

switch 中如果没有break 会把后边的语句都执行，即第7、9 行代码都会执行到。

 

10.下列关于Java 并发的说法中正确的是(B)
A CopyOnWriteArrayList 适用于写多读少的并发场景
B ReadWriteLock 适用于读多写少的并发场景
C ConcurrentHashMap 的写操作不需要加锁，读操作需要加锁
D 只要在定义int 类型的成员变量i 的时候加上volatile 关键字，那么多线程并发执行i++ 这
样的操作的时候就是线程安全的了

copyonwritearraylist 适用于写少读多的并发场景
readwritelock : 读写锁，要求写写互斥、读写互斥，读读可以并发执行，在读多写少的情况下可以提高效率
concurrenthashmap 是同步的HashMap ，读写都需要加锁
volatile 只保证多线程操作的可见性，不保证原子性

 

---

 

day 12   4 月24 日测验

---

java.util.HashMap map=new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.size());

A "9HelloWorld"
B "_Hello World"
C "Hello*World"
D "Hello$World"

标识符有数字、美元( $ )、下划线( _ ) ，且不能以数字开头，不能使用已有的关键字 

2.以下java程序代码，执行后的结果是（C）

java.util.HashMap map=new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.size());

A .0     B.null    C. 1    D.2

map<key,value>中的key是不能重复的，当插入map中已有的key时，会自动覆盖已有的key

 

3.Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是(C)
A ArrayList和LinkedList均实现了List接口
B ArrayList的访问速度比LinkedList快
C 添加和删除元素时，ArrayList的表现更佳
D HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

删除和插入元素，LinkedList表现更佳，ArrayList删除和插入元素时，会将后面的元素进行移动，效率不高

 

4.以下描述正确的是(B)
A CallableStatement是PreparedStatement的父接口
B PreparedStatement是CallableStatement的父接口
C CallableStatement是Statement的父接口
D PreparedStatement是Statement的父接口

Statement是PreParedStatement的父接口，

PrePareStatement是CallableStatement的父接口

 

5.下列程序的运行结果(B)

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

A pingpong
B pongping
C pingpong和pongping都有可能
D 都不输出

调用的是t的run方法，所以程序会按照顺序执行

如果调用的是t的start方法，则 pingpong和pongping都有可能

 

6.下列关于容器集合类的说法正确的是？(C)

A LinkedList继承自List

B AbstractSet继承自Set
C HashSet继承自AbstractSet
D WeakMap继承自HashMap

LinkedList 继承自AbstractSequentialList 实现了List 、Deque 、Cloneable 、java.io.Serializable 接
口
AbstractSet 继承自AbstractCollection ，实现了set 接口
HashSet 继承自AbstractSet ，实现了set 、Cloneable 、java.io.Serializable 接口

 

7.ArrayList list = new ArrayList(20);中的list扩充几次(A)
A 0
B 1
C 2
D 3

ArrayList默认大小是10.如果初始化指定大小则初始就是指定的大小，ArrayList扩容每次1.5倍

 

8.以下程序的输出结果是？(B)

public class Example {
    String str = new String("good");
    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 ");
        System.out.print(ex.ch);
    }
    public static void change(String str, char ch[]){
        str = "test ok";
        ch[0] = 'g';
    }
}

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

 

9.下面的方法，当输入为2的时候返回值是多少?(D)

public static int getValue(int i) {
    int result = 0;
    switch (i) {
    case 1:
        result = result + i;
    case 2:
        result = result + i * 2;
    case 3:
        result = result + i * 3;
    }
    return result;
}

A 0
B 2
C 4
D 10

switch中没有break，则会从开始的case一直执行完

 

10.下列关于Java并发的说法中正确的是（B）
A CopyOnWriteArrayList适用于写多读少的并发场景
B ReadWriteLock适用于读多写少的并发场景
C ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
D 只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

copyonwritearraylist 适用于写少读多的并发场景
readwritelock : 读写锁，要求写写互斥、读写互斥，读读可以并发执行，在读多写少的情况下可以提高效率
concurrenthashmap 是同步的HashMap ，读写都需要加锁
volatile 只保证多线程操作的可见性，不保证原子性

 

---

day 13   4 月26 日测验

---

1.下面有关JVM内存，说法错误的是？(C)
A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C 方法区用于存储JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，是线程隔离的
D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

方法区、堆是线程共享的，栈是线程私有的

 

2.下列程序段的输出结果是：（ B）

public void complicatedexpression_r(){
    int x=20, y=30;
    boolean b;
    b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
    System.out.println(b);
}

A true
B false
C 1
D 0

运算规则，先算&& ，再算||

 

3.输入流将数据从文件，标准输入或其他外部输入设备中加载道内存，在 java 中其对应于抽象类（）及其子类。（A）
A java.io.InputStream
B java.io.OutputStream
C java.os.InputStream
D java.os.OutputStream

输入输出流在io包中，输入流inputStream,输出流outputStream

4.以下程序的输出结果是(A)

public class Print{
    static boolean out(char c){
        System.out.println(c);
        return true;
    }
    public static void main(String[] argv){
        int i = 0;
        for(out('A');out('B') && (i<2);out('C')){
            i++;
            out('D');
        }
    }
}

A ABDCBDCB
B BCDABCD
C 编译错误
D 运行错误

out方法永远返回true，所以for循环取决于i，for循环了两次

 

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

java编译成的是字节码文件。被JVM翻译成机器码

java源文件生成的是.class文件，与系统无关

机器码和字节码是两个概念，javac编译生成的是.class字节码文件，java运行是将字节码文件翻译成机器码

JVM的版本会影响

 

6.（A）仅包含方法定义和常量值。
A 接口
B 变量
C 单元
D 成员

 

7下面程序的运行结果：(B)

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夹杂在中间

 

线程调用run()方法只是一行普通的代码，代码执行的顺序是按照代码的顺序的

只有当调用线程的start()方法是才会两种情况都有可能出现

 

8.默认类型等价表示是哪一项(C)

public interface IService {
    String NAME="default";
}

A public String NAME="default";
B public static String NAME="default";
C public static final String NAME="default";
D private String NAME="default";

接口中的属性只能用public static final来修饰

9.有以下类定义：

abstract class Animal{
    abstract void say();
}
public class Cat extends Animal{
    public Cat(){
        System.out.printf("I am a cat");
    }
    public static void main(String[] args) {
        Cat cat=new Cat();
    }
}

运行后：(B)

A I am a cat
B Animal能编译，Cat不能编译
C Animal不能编译，Cat能编译
D 编译能通过，但是没有输出结果

继承抽象类必须重写抽象类中的所有方法，或者子类也是抽象类

所以这个题有两种改法

1.在Cat中重写Animal中的say方法

2.将Cat设置成抽象类

10.类Test1定义如下

public class Test1{//1
    public float aMethod(float a,float b){}//2
    //3
}//4

将以下哪种方法插入行3是不合法的。(C)
A public int aMethod(int a,int b){}
B private float aMethod(int a,int b,int c){}
C public float aMethod(float a,float b){}
D public float aMethod(float a,float b,float c){}

方法重载时要求参数类型或个数不一致，对返回值没有要求

 

---

day 14   4 月27 日测验

---

1.在Java中，以下关于方法重载和方法重写描述正确的是？(D)
A 方法重载和方法的重写实现的功能相同
B 方法重载出现在父子关系中，方法重写是在同一类中
C 方法重载的返回值类型必须一致，参数项必须不同
D 方法重写的返回值类型必须相同或相容。

方法重载是同一个类中的两个函数，要求参数类型或参数个数不相同，对返回值类型没有要求

方法重写是父类子类中的，要求返回值类型必须相同或相容

2.下列哪些语句关于内存回收的说明是正确的? ( B)
A 程序员必须创建一个线程来释放内存

B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象

 

3._（A）___技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
A 流媒体
B 多媒体
C 复合媒体
D 音视媒体

 

4.在 java 中 , 以下 __C___ 类的对象以键 - 值的方式存储对象
A java,util.List
B java,util.ArrayList
C java,util.HashMap
D java,util.LinkedList

 

5.下列语句正确的是：(D)
A 形式参数可被字段修饰符修饰
B 形式参数不可以是对象
C 形式参数为方法被调用时真正被传递的参数
D 形式参数可被视为local variable

形式参数只能用final 修饰符，其它任何修饰符都会引起编译器错误
形式参数为方法被声明时的参数

 

6.下列哪种情况可以终止当前线程的运行？(D)
A 当一个优先级高的线程进入就绪状态时
B 当该线程调用sleep()方法时
C 当创建一个新线程时
D 抛出一个异常时

AB只会让线程阻塞，暂时停止，不会终止，线程异常或者线程正常结束才会终止当前线程

 

7.A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：(A)

1.A a0=new A();
2.A a1=new B();
3.A a2=new C();

以下哪个说法是正确的？
A 第1行,第2行和第3行的声明都是正确的
B 第1,2,3行都能通过编译，但第2,3行运行时出错
C 第1,2行能通过编译，但第3行编译出错
D 只有第1行能通过编译

 

8.在java7中,下列哪个说法是正确的:(D)
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collection接口
C Arrays.asList方法返回java.util.ArrayList对象
D SimpleDateFormat对象是线程不安全的

HashMap在单线程中使用synchronize大大提高效率，在多线程中使用hashTable来确保安全，hashTable使用synchronize关键字来确保线程安全，但是synchronize是对整张表加锁，在保证安全的同时效率大大降低，ConcurrentHashMap使用分段加锁机制来确保安全

Arrays.asList 方法返回java.util.ArraysList 对象

 

9.给定代码：

public class SwitchTest{//1
    public static void main(String[] args) {//2
        System.out.println("value="+switchit(4));//3
    }//4
    public static int switchit(int x) {
        int j=1;
        switch (x) {
            case 1:j++;
            case 2:j++;
            case 3:j++;
            case 4:j++;
            case 5:j++;
            default:j++;
        }
        return j+x;
    }
}

 

第三行将输出什么？(B)
A value=6
B value=8
C value=3
D value=5
E value=4

 

10.关于以下程序段，正确的说法是：（）

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

 

 

---

day 15   4 月28 日测验

---

1.用命令方式运行以下代码的运行结果是（C）

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

2.若有定义语句： int a=10 ; double b=3.14 ; 则表达式 'A'+a+b 值的类型是（C）

A char
B int
C double
D float

有浮点数的运算结果都是浮点数

 

3.指出下列程序运行的结果（B）

public class Example{
    String str = new String("good");
    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 ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[ ]){
        str = "test ok";
        ch[0] = 'g';
    }
}

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

4.下列说法正确的是(B)
A 在类方法中可用this来调用本类的类方法
B 在类方法中调用本类的类方法可直接调用
C 在类方法中只能调用本类的类方法
D 在类方法中绝对不能调用实例方法

类方法可以通过实例调用实例方法，通过类名调用其他类的类方法，本类的类方法可以直接调用

 

5.可将语句块或方法设为同步使用的语句是（A）
A synchronized
B static
C abstract
D final

 

6.已知如下类说明：（D）

public class Test{
    private float f=1.0f;
    int m=12;
    static int n=1;
    public static void main(String args[]){
        Test t=new Test();
    }
}

如下哪些使用是正确的（）
A t.f = 1.0
B this.n
C Test.m
D Test.n

实例边变量要通过实例调用，类变量通过类名或实例调用

7.有以下代码:

class A{
    public A(String str){
    }
}
public class Test{
    public static void main(String[] args) {
        A classa=new A("he");
        A classb=new A("he");
        System.out.println(classa==classb);
    }
}

请问输出的结果是:(A)
A false
B true
C 报错
D 以上选项都不正确

 

8.以下哪项不属于java类加载过程？(B)
A 生成java.lang.Class对象
B int类型对象成员变量赋予默认值
C 执行static块代码
D 类方法解析

成员变量的赋值是在对象创建的时候

 

9.如果一个方法或变量是"private"访问级别，那么它的访问范围是:（D）
A 在当前类，或者子类中
B 在当前类或者它的父类中
C 在当前类，或者它所有的父类中
D 在当前类中

10.java中下面哪个能创建并启动线程（C）

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()

 

---

day 16   4 月29 日测验

---

1.如果希望监听TCP端口9000，服务器端应该怎样创建socket?(B)
A new Socket("localhost",9000);
B new ServerSocket(9000);
C new Socket(9000);
D new ServerSocket("localhost",9000);

服务端监听ServerSocket ss = new ServerSocket(int port)
客户端连接Soceket s = new Socket(String host,int port)
网络编程服务器端只需要监听客户端的端口

new Socket("localhost",9000);　//客户端连接端口 
new ServerSocket(9000);　//服务器端监听端口

 

2.下列哪个类的声明是正确的？(D)
A abstract final class HI{}
B abstract private move(){}
C protected private number;
D public abstract class Car{}
 

final和abstract不能同时用来修饰类，

因为abstract用来修饰类表示类是抽象类，可以被继承

而final用来修饰类，表示这个类是最终类，不能被继承

abstract用来修饰方法表示是抽象方法，抽象方法不能有方法体，而且抽象方法不能是私有的，因为抽象方法需要在其他类中重写，所以不能是私有的

 

 

3.java 接口的修饰符可以为（D）
A private
B protected
C final
D abstract

 

4.jre 判断程序是否执行结束的标准是（A）
A 所有的前台线程执行完毕
B 所有的后台线程执行完毕
C 所有的线程执行完毕
D 和以上都无关

后台线程不会阻止进程的终止。属于某个进程的所有前台线程都终止后，该进程就会被终止。所有剩余的后台线程都会停止且不会完成。

 

5.s=( )//s 的值是什么？(E)

int i=5;
int s=(i++)+(++i)+(i--)+(--i);

A 28
B 25
C 21
D 26
E 24
F 23

 

6.如下语句通过算术运算和逻辑运算之后i和 j的结果是（D ）

int i=0;
int j=0;
if((++i>0)||(++j>0))
{
    //打印出i和j的值。
}

A i=0;j=0
B i=1;j=1
C i=0;j=1
D i=1;j=0

对于或运算（A||B）如果A是正确则不会继续往后执行，直接结果就是正确

 

7.下面不属于Object类中方法的是:(B)
A hashCode()
B finally()
C wait()
D toString()

 

8.下列哪项不属于jdk1.6垃圾收集器？(D)
A Serial收集器
B parNew收集器
C CMS收集器
D G1收集器

1.Serial收集器 
单线程收集器，收集时会暂停所有工作线程（我们将这件事情称之为Stop The World，下称STW），使用复制收集算法，虚拟机运行在Client模式时的默认新生代收集器。 

2.ParNew收集器 
ParNew 收集器就是Serial的多线程版本，除了使用多条收集线程外，其余行为包括算法、STW、对象分配规则、回收策略等都与Serial收集器一摸一样。对 应的这种收集器是虚拟机运行在Server模式的默认新生代收集器，在单CPU的环境中，ParNew收集器并不会比Serial收集器有更好的效果。 

3.Parallel Scavenge收集器 
Parallel Scavenge收集器（下称PS收集器）也是一个多线程收集器，也是使用复制算法，但它的对象分配规则与回收策略都与ParNew收集器有所不同，它是 以吞吐量最大化（即GC时间占总运行时间最小）为目标的收集器实现，它允许较长时间的STW换取总吞吐量最大化。 

4.Serial Old收集器 
Serial Old是单线程收集器，使用标记－整理算法，是老年代的收集器，上面三种都是使用在新生代收集器。 

5.Parallel Old收集器 
老年代版本吞吐量优先收集器，使用多线程和标记－整理算法，JVM 1.6提供，在此之前，新生代使用了PS收集器的话，老年代除Serial Old外别无选择，因为PS无法与CMS收集器配合工作。 

6.CMS（Concurrent Mark Sweep）收集器 
CMS 是一种以最短停顿时间为目标的收集器，使用CMS并不能达到GC效率最高（总体GC时间最小），但它能尽可能降低GC时服务的停顿时间，这一点对于实时或 者高交互性应用（譬如证券交易）来说至关重要，这类应用对于长时间STW一般是不可容忍的。CMS收集器使用的是标记－清除算法，也就是说它在运行期间会 产生空间碎片，所以虚拟机提供了参数开启CMS收集结束后再进行一次内存压缩。 

 

 

9.instanceof运算符能够用来判断一个对象是否为:(C)
A 一个类的实例
B 一个实现指定接口的类的实例
C 全部正确
D 一个子类的实例

instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

interface A{
	
}
class B implements A{
	 
}
class C extends B{
	 
}
public class Iinstanceof {

	public static void main(String[] args) {
		A ab=new B();
		A ac=new C();
		B bc=new C();
		B bb=new B();
		C cc=new C();
		//对象实现一个接口，用这个对象和这个接口进行instanceof判断，都为true。
		System.out.println("ab instanceof A="+(ab instanceof A));
		System.out.println("ac instanceof A="+(ac instanceof A));
		System.out.println("bc instanceof A="+(bc instanceof A));
		System.out.println("bb instanceof A="+(bb instanceof A));
		System.out.println("cc instanceof A="+(cc instanceof A));
		//对象和父类进行instanceof判断，都为true
		System.out.println("ab instanceof B="+(ab instanceof B));
		System.out.println("ac instanceof B="+(ac instanceof B));
		System.out.println("bc instanceof B="+(bc instanceof B));
		System.out.println("bb instanceof B="+(bb instanceof B));
		System.out.println("cc instanceof B="+(cc instanceof B));
		//对象和他的子类进行instanceof判断为false
		System.out.println("ab instanceof C="+(ab instanceof C));
		System.out.println("ac instanceof C="+(ac instanceof C));
		System.out.println("bc instanceof C="+(bc instanceof C));
		System.out.println("bb instanceof C="+(bb instanceof C));
		System.out.println("cc instanceof C="+(cc instanceof C));
	}
}

 

 

10.对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（D）
A float
B char
C short
D double

 

 

---

day 17   5 月7 日测验

---

1.以下哪项是类实例化的语句？(D)
A varName ClassName=new varName();
B ClassName varName=new ClassName(new ClassName);
C ClassName varName=ClassName();
D ClassName varName=new ClassName();

 

2.下列关于 java 语言的特点，描述错误的是（C）
A java是跨平台的编程语言
B java支持分布式计算
C java是面向过程的编程语言
D java支持多线程

 

3.当你编译和运行下面的代码时，会出现下面选项中的哪种情况？(B)

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

A 编译时错误
B 编译通过并输出结果false
C 编译通过并输出结果true
D 编译通过并输出结果null

局部变量必须初始化，成员变量和类变量不需要初始化，他们具有默认值：

• 整型(byte、int、short、long):0
• 浮点型(double、float):0.0
• 布尔型(boolean):false
• 字符型(char):\u0000
• 引用类型(String):null

 

4.以下叙述正确的是(D)
A 实例方法可直接调用超类的实例方法
B 实例方法可直接调用超类的类方法、
C 实例方法可直接调用子类的实例方法
D 实例方法可直接调用本类的实例方法

实例方法调用超类的方法，超类的方法必须是public或protected

实例方法可直接调用实例方法可静态方法

静态方法调用实例方法必须使用实例调用，调用静态方法可直接调用

 

5.Java 语言用以下哪个类来把基本类型数据封装为对象（A）
A 包装类
B Class
C Math
D Object

 

6.c变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：
0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（C）
A 1
B -(2^62+2^61+2^60+1)
C 2^62+2^61+2^60+1
D 2^59+(2^55+2^54+…+2^2+2^1+2^0)

 

7.HashSet子类依靠()方法区分重复元素。(C)
A toString(),equals()
B clone(),equals()
C hashCode(),equals()
D getClass(),clone()

 

8.以下代码在编译和运行过程中会出现什么情况(A)

public class TestDemo{
    private int count;
    public static void main(String[] args) {
        TestDemo test=new TestDemo(88);
        System.out.println(test.count);
    }
    TestDemo(int a) {
        count=a;
    }
}

A 编译运行通过，输出结果是88
B 编译时错误，count变量定义的是私有变量
C 编译时错误，System.out.println方法被调用时test没有被初始化
D 编译和执行时没有输出结果

 

9.以下程序执行的结果是：(C)

class X{
    Y y=new Y();
    public X(){
        System.out.print("X");
    }
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

A ZYXX
B ZYXY
C YXYZ
D XYZX

10.有这么一段程序：

public class Test{
    public String name="abc";
    public static void main(String[] args){
        Test test=new Test();
        Test testB=new Test();
        System.out.println(test.equals(testB)+","+test.name.equals(testB.name));
    }
}

请问以上程序执行的结果是（）
A true,true
B true,false
C false,true
D false,false

第一个比较的是两个Test的对象是否一致，一个是test一个是TestB，分别在堆的两块内存空间，所以是false。

第二个比较的时候name的值是否一致，都是abc，true

 

 

 

---

day 18   5 月8 日测验

---

 

 

 

 

 

 

---

day 19   5 月10 日测验

---

 

 

 

---

day 20   5 月11 日测验

---

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---