javaStudy_day19(上)

选择题(20分)

1.运行结果是:

System.out.println("====>"+a==b );         (编译出错)

 

2.下面代码运行结果是:

int j = 0; 

for(int i=0; i<100; i++) { 

  j = j++; 

} 

结果: j =   0    ,i =   99

 

3.结果是:

class  A{

    public staticvoid main(String[] args){

       method();

    }

 

    static voidmethod(){

       try{

           System.out.println(“Hello”);

           System.exit(0);

         }finally{

           System.out.println(“good-bye”);

         }

    }

 }

 

编译运行后，输出的结果是：（ a ）

a) “Hello”

b) “good-bye”

c) “Hello”后面是”good-bye”

d) 代码不能通过编译

 

4.public class Test{

   public staticvoid stringReplace(String text){

       text=text.replace('j','L');

    }

    public staticvoid bufferReplace(StringBuffer text){

       text=text.append("c");

     }

   public staticvoid main(String args[]){  

        StringtextString=new String("java");

       StringBuffer textBuffer=new StringBuffer("java");

       stringReplace(textString);

       bufferReplace(textBuffer);

       System.out.println(textString+textBuffer);

      }

   }

   A、编译并运行输出Lava   javac

   B、编译并运行输出java    java

   C、编译并运行输出java    javac

   D、编译并运行输出Lava   java

                                                  C

  

5、给定JAVA程序Test.java如下，编译运行，结果是( C).(选择一项)

    package com;

    public classTest{

       protected void talk(){

          System.out.print("talk");

       }

    }

     

    给定Test的子类Test2,代码如下:

    packagecom.util;

    import com.*;

    public classTest2 extends Test{

        public static void main(String [] args){

          Test tt=new Test();

          tt.talk();

        }

    }

A、输出字符串:talk

B、输出字符串:talk talk

C、编译错误:在com.util.Test2中无法访问方法talk()

D、编译错误

 

6.下面方法返回结果是多少?   3

static int test(){

    int x = 1;

    try {

       x++;

    } finally {

       return ++x;

    }

}

 

 

7.下列说法正确的是? E

A.List, Set, Map继承自Collection接口; 没map

B.Error不可以声明抛出;

C.new Calendar();可以创建日历对象; Calendar为抽象类

D.同步方法的同步监听对象是 this;   不一定

E.两个对象(x.equals(y) == true)，但却可有不同的hashcode;

 

8.找出下列代码的问题所在.

A.

abstract class Something {

   privateabstract String doSomething ();抽象方法不能使private修饰

}

 

B.

public class Something {

   public intaddOne(final int x) {

       return ++x;

   }

}

 

C.

class Something {

    int i;

    public voiddoSomething() {

       System.out.println("i = " + i);

    }

}

D.

public class Something {

     public staticvoid main(String[] args) {

        Somethings = new Something();

       System.out.println("s.doSomething() returns " +doSomething());

    }

     public StringdoSomething() {

        return"Do something ...";

    }

}静态方法不能直接调用非静态成员

 

E.

interface  A{

   int x = 0;

}

class B{

   int x =1;

}

class C extends B implements A {

   public voidpX(){

     System.out.println(x);                x值不确定

   }

   public staticvoid main(String[] args) {

      newC().pX();

   }

}

 

F.

interface Playable {

    void play();

}

interface Bounceable {

    void play();

}

interface Rollable extends Playable, Bounceable {

    Ball ball =new Ball("PingPang");

}

class Ball implements Rollable {

    private Stringname;

    public StringgetName() {

        returnname;

    }

    publicBall(String name) {

        this.name= name;       

    }

   public voidplay() {

        ball = newBall("Football");

       System.out.println(ball.getName());

    }

}  接口里的变量默认全是公共的全局常量,也就是说对象的引用不能改变

 

9.  下面代码结果是?  AB

    LinkedList list= new LinkedList();

    list.add("A");

    list.add("B");

    list.add("C");

    list.add("D");

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

       System.out.println(list.poll());

    }

 

10.以下代码能否编译通过，假如能编译通过，运行时出现什么情况？

public class Abs{

    static int[]a=new int[4];

    static Object[]o=new Object[4];

    static Strings[];

 

    public staticvoid main(String args[]){

       System.out.println(a[0]);

       System.out.println(o[3]);

       System.out.println(s);

    }

}   0 null null

 

主观题(40分):

 

1.  谈谈你理解的Java的引用传递或值传递.

....main...

{  

    Object o =new Object();//语句A

    show(o);//语句B

}

voidshow(Object obj){//语句C

}

语句A执行完之后,在JVM的堆内存有一个内存空间(,取个名叫XX,假设地址是0x9527),

栈内存里有一块内存空间 o, o持有着XX的地址0x9527,也就是o指向了ox9527这块地址空间;

语句B的时候,有参数传递:

Java里引用传递或值传递其实都是把变量拥有的的16进制地址拷贝一份,付给一个其他变量;

是把o拥有的地址0x9527拷贝一份给了栈里新的一块空间obj;

    也就是说obj也是拥有着堆里面地址为0x9527的空间;

2.  你对抽象类和接口是怎么理解的;

相同点:

    都位于继承的顶端,用于被其他实现或继承;

    都不能实例化;

    都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

    抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

    一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

二者的选用:

    优先选用接口,尽量少用抽象类;

    需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

3.  说说你对GC的理解;

当使用new 创建对象的时候,JVM会再堆空间为某一个对象开辟一块内存空间用来存储对象的数据.

    当堆里面内存空间不被栈里任一内存空间引用的时候,就成了垃圾,

    成了垃圾的对象并不会马上被垃圾回收器回收,这取决于Java垃圾回收器的调度,是我们不能控制的,

    对象的垃圾回收会自动的去调用Object里面的finalize方法,不需要我们自己去调用;

    为了强制回收垃圾,我们可以使用Runtime.getRuntime().gc();

4.  说说 wait(),sleep(),await()方法的理解;

sleep是Thread的方法,

    表示正在执行的线程主动让出CPU,让CPU去执行其他线程,

    在sleep指定的时间过后,cpu才会回到这个线程上继续往下执行,

    如果当前线程进入了同步锁,调用sleep不会释放对象锁;

    使用Thread来调用;

   

    wait是Object类的方法,对此对象调用wait方法导致当前线程放弃对象锁,

    进入等待,等待被唤醒,只有其他线程调用了notify方法(或notifyAll)后

    当前线程才准备获得对象锁进入运行状态;

    使用同步监听对象来调用;

   

    await是java.util.concurrent.locks.Condition接口里的方法,

    和wait具有相同的语义,只是进入等待之后,其他线程只有调用signal方法(或signalAll方法)

    才可以唤醒当前线程对象.

    使用Condition对象来调用;

5.  说说你对final,finally,finalize的理解;

final 用于声明字段,方法和类,分别表示字段不可变,方法不可覆盖,类不可继承。

    使用final修饰引用类型变量的时候,表示变量的引用地址不可变,内容可变;

 

    局部内部类要访问局部变量,局部变量必须定义成final类型;

   

    ...main...{

        finalint age = 17;

       

        classInner{

           publicvoid show(){

               System.out.println(age);

           }

        }

       

    }

 

     finally是异常处理语句结构的一部分,表示总是执行。

 

     finalize是Object类的一个方法，

 在垃圾收集器执行的时候会调用被回收对象的此方法，

 JVM不保证此方法总被调用;

6.  详述你对线程3种同步方式的理解;

1.同步代码块:

        synchronized(同步监听对象)

        {

           //需要同步的代码

        }

       

        同步监听对象取值通常有:

                  1.同一份资源;

                  2.this,此时只能使用实现方式,继承时不能使用this

                 3.同步代码块所在类的字节码,  OOXX.class(JVM中相同的字节码,只有一份)

   

    2. 同步方法: 

               非静态方法默认使用的是this作为同步监听对象;

               静态方法默认是使用的是方法所在类的字节码对象;

   

        1.直接在run方法前 使用synchronized:

               但是,此时只能用实现方式,

        2.一般情况下,我们单独写一个方法,并使用同步,在run方法里,调用;

   

    3. 使用可重入锁:

               java.util.concurrent.locks.Lock接口:

                  java.util.concurrent.locks.ReentrantLock类:

       

        写法格式:

       

           1.创建ReentrantLock 对象;

           2.在需要同步的方法里,

               (1).进入方法后,获取锁

               (2).把需要同步的代码,放在 try 块里;

               (3).在 finally 块里,手动解锁;

           语法格式:

 

           privatefinal ReentrantLock lock  = newReentrantLock();

           publicvoid m(){

               lock.lock();//获取锁

              

               try{

                  //需要同步的代码

               }finally{

                  lock.unlock();//手动解锁

               }

           }