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();//手动解锁
}
}