Day16

Q1

下面有关 JAVA 异常类的描述,说法正确的有()

• 异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception
• 非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获
• Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
• RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须 被 try{}catch 语句块所捕获

题解

• Exception(异常) :是程序本身可以处理的异常
• Error(错误): 是程序无法处理的错误
• 检查异常(编译器要求必须处置的异常) ： 除Error，RuntimeException及其子类以外，其他的Exception及其子类都属于可查异常**[要么用try-catch语句捕获它，要么用throws子句声明抛出它]**
• 非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）

Q2

以下哪项不属于java类加载过程？

• 生成java.lang.Class对象
• int类型对象成员变量赋予默认值
• 执行static块代码
• 类方法解析

题解

类的加载包括：加载，验证，准备，解析，初始化

类加载的时候会赋予初值的是类变量，而非对象成员

Q3

表达式(short)10/10.2*2运算后结果是什么类型？

• short
• int
• double
• float

题解

java 黙认浮点类型为double
float数据类型有一个后缀为" f “或” F "
long类型有一个后缀，为" l " 或者" L "

Q4

以下代码段执行后的输出结果为

public class Test {
	public static void main(String args[]) {
		int x = -5;
		int y = -12;
		System.out.println(y % x);
	}
}

• -2

题解

使用%取余/模时，结果与被除数同符号

• -7 % 3 = -7 % -3 = -1
• 7 % 3 = 7 % -3 = 1
  使用rem(y, x)取余时，结果与被除数同符号
• rem(7, 3) = rem(7, -3) = 1
• rem(-7, 3) = rem(-7, -3) = -1
  使用mod(y, x)取模时，结果与除数同符号
• mod(7, 3) = mod(-7, -3) = -1
• mod(7, 3) = mod(-7, 3) = 1

Day17

Q1

以下各类中哪几个是线程安全的？( )

• ArrayList
• Vector
• Hashtable
• Stack

题解

• 线程同步：喂，SHE——Vector、Stack、Hashtable、enumerate
• vector：就比arraylist多了个同步化机制（线程安全）
• statck：堆栈类，先进后出
• hashtable：就比hashmap多了个线程安全
• enumeration：枚举，相当于迭代器

Q2

下列代码输出结果为（ ）

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}
public class TestDog{
    public static void main(String args[]){
        Animal a = new Animal();
        Animal b = new Dog(); 
        a.move();
        b.move();
        b.bark();
    }
}

• 编译错误

题解

编译错误：The method bark() is undefined for the type Animal。Animal中没有定义bark()方法。

编译看左边，运行看右边。也就是是编译的时候会把它当成左边的类型，运行的时候看右边类型的方法体。

Q3

java Thread中，run方法和start方法的区别，下面说法错误的是？

• 通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
• 他们都可以实现了多线程运行。
• run方法是thread的一个普通方法调用。
• 调用start方法后，一旦得到cpu时间片，就开始执行run()方法。

题解

start方法

• 用 start方法来启动线程，是真正实现了多线程
• 调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态
• 一旦得到cpu时间片，就开始执行run()方法
• 此时无需等待run()方法执行完毕，即可继续执行下面的代码

run方法

• run()方法只是类的一个普通方法
• 直接调用Run方法，程序中依然只有主线程这一个线程
• 程序执行路径只有一条，要顺序执行，要等待run方法体执行完毕后才可继续执行下面的代码

Q4

有这样一段程序：

public class Test{ 
    public static void main(String [] args){ 
        List list=new ArrayList(); 
        list.add("a");
        list.add("b");
        list.add("a");
        Set set=new HashSet(); 
        set.add("a"); 
        set.add("b"); 
        set.add("a"); 
        System.out.println(list.size()+","+set.size()); 
    } 
}

请问运行主要的程序会打印出的是什么（）

• 2,2
• 2,3
• 3,2
• 3,3

题解

list有序可重复，set无序不可重复

Q5

以下代码，运行结果是什么？

public class Test {
    private static int j = 0;

    private static Boolean methodB(int k) {
        j += k;
        return true;
    }

    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);

    }

    public static void main(String args[]) {
        methodA(0);
        System.out.println(j);
    }
}

• The program prints”0”
• The program prints”4”
• The program prints”8”
• The program prints”12”
• The code does not complete.

题解

condition 1 | condition 2、condition 1 || condition 2

• "|"是按位或：先判断条件1，不管条件1是否为true，都会执行条件2
• "||"是逻辑或：先判断条件1，条件1是否为true，决定是否执行条件2

Q6

Test.main()函数执行后的输出是（ ）

class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue());
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {
            try {
                value ++;
                return value;
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
        }
    }
    static class B extends A {
        public B () {
            super(5);
            setValue(getValue()- 3);
        }
        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
}

• 6 7 7
• 22 34 17
• 22 74 74
• 11 17 34

题解

1、执行new B()

• 由于B继承于A，先执行A的无参构造方法
• A没有写无参构造方法，系统默认提供的，就不产生影响
• 执行B的无参构造方法，进入执行super(5)

2、执行super(5)

• 调用父类A的有参构造方法，传递值v = 5，需要运行setValue(v)
• 此时B重写了A的setValue()方法，所以执行B.setValue(v)，此时B.value = 10
• 接着B构造方法中，执行setValue(getValue()- 3)，首先是执行B.getValue()

3、执行B.getValue()

• B类没有重写此方法，使用A的此方法，此时B.value = 10，value++后，为B.value = 11
• 在return value返回前执行finally代码块，先将value = 11存放到栈顶
• finally代码块中执行setValue(11)，由于当前还是B类对象，所以执行B.setValue(11)
• 得到2*11，即第一个打印的是22，然后返回栈顶的11，执行setValue(11 - 3)

4、执行setValue(11 - 3)

• 由于仍然是B构造方法内的setValue()方法，于是得到2 * 8 = 16，即new B()后，B.value = 16
• 此时开始执行new B().**getValue()**方法

5、B.value.getValue()

• 原理同【3】，value++后，value = 17返回前保存在栈顶
• finally代码块执行时，由于value = 17仍是B类对象，所以第二个打印的是2 * value = 34
• 然后返回的value = 17，最后打印输出17

Day18

Q1

关于Java中的ClassLoader下面的哪些描述是错误的：( )

• 默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
• 一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
• 类装载器需要保证类装载过程的线程安全
• ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
• ClassLoader的父子结构中，默认装载采用了父优先
• 所有ClassLoader装载的类都来自CLASSPATH环境指定的路径

题解

• 启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用程序类加载器（Application ClassLoader）
• 比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义
• 类只需加载一次就行，因此要保证类加载过程线程安全，防止类加载多次
• D选项，不存在找父类加载器，父类为空则启动类加载器作为父类加载器，父类加载失败，抛出ClassNotFoundException异常
• 只有应用程序类加载器(Application ClassLoader)负责加载用户类路径(ClassPath)上所指定的类库

Q2

以下代码运行结果是什么？

package algorithms.com.guan.javajicu;  
public class Inc {  
    public static void main(String[] args) {  
       Inc inc = new Inc();  
       int i = 0;  
       inc.fermin(i);  
       i= i ++;  
       System.out.println(i); 
   
    }  
    void fermin(int i){  
       i++;  
    }  
}  

• 0

题解

i=i++;  等同于：
	temp=i； (等号右边的i)
	i=i+1;      (等号右边的i)
	i=temp;   (等号左边的i)

i=++i;  则等同于：
	i=i+1;
	temp=i;
	i=temp;

Q3

反射最大程度破坏了面向对象的以下哪个特性？

• 封装
• 多态
• 继承
• 抽象

题解

反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性

即，反射可以访问原类的私有方法，私有成员变量，因此，反射破坏了Java的封装性

Q4

下面关于volatile的功能说法正确的是哪个

• 原子性
• 有序性
• 可见性
• 持久性

题解

• synchronized保证三大性：原子性，有序性，可见性
• volatile保证有序性，可见性，不能保证原子性

Q5

如果希望监听TCP端口9000，服务器端应该怎样创建socket?

• new Socket(“localhost”,9000);
• new ServerSocket(9000);
• new Socket(9000);
• new ServerSocket(“localhost”,9000);

题解

• ServerSocket(int port) 是服务端绑定port端口，调accept()监听等待客户端连接，它返回一个连接队列中的一个socket。
• Socket(InetAddress address , int port)是创建客户端连接主机的socket流，其中InetAddress是用来记录主机的地址，port指定端口。
  

Q6

下面有关java基本类型的默认值和取值范围，说法错误的是？

• 字节型的类型默认值是0，取值范围是-2^7—27-1
• boolean类型默认值是false，取值范围是true\false
• 字符型类型默认是0，取值范围是-2^15 —2^15-1
• long类型默认是0，取值范围是-2^63—263-1

题解

Q7

off-heap是指那种内存（）

• JVM GC能管理的内存
• JVM进程管理的内存
• 在JVM老年代内存区
• 在JVM新生代内存

题解

堆外内存意味着把内存对象分配在Java虚拟机的堆以外的内存，这些内存直接受操作系统管理（而不是虚拟机）

Day19

Q1

CMS垃圾回收器在那些阶段是没用用户线程参与的

• 初始标记
• 并发标记
• 重新标记
• 并发清理

题解

• CMS全称 Concurrent Mark Sweep，是一款并发的、使用标记-清除算法的垃圾回收器
  
• 初始标记(STW initial mark)
  • 需要虚拟机停顿正在执行的任务；但是很快就完成了
• 并发标记(Concurrent marking)
  • 初始标记的基础上继续向下追溯标记；应用程序的线程和并发标记的线程并发执行，所以用户不会感受到停顿
• 并发预清理(Concurrent precleaning)
  • 虚拟机查找在执行并发标记阶段新进入老年代的对象
• 重新标记(STW remark)
  • 暂停虚拟机，收集器线程扫描在CMS堆中剩余的对象
• 并发清理(Concurrent sweeping)
  • 清理垃圾对象，这个阶段收集器线程和应用程序线程并发执行
• 并发重置(Concurrent reset)
  • 重置CMS收集器的数据结构，等待下一次垃圾回收

Q2

关于多线程和多进程，下面描述正确的是（）：

• 多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
• 线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
• 线程的通信速度更快，切换更快，因为他们在同一地址空间内。
• 一个线程可以属于多个进程。

题解

• 线程之间共享进程获得的数据资源，所以开销小，但不利于资源的管理和保护
• 进程执行开销大，但是能够很好的进行资源管理和保护
• 线程的通信速度更快，切换更快，因为他们共享同一进程的地址空间

Q3

根据下面的代码，

• String s = null;
  会抛出NullPointerException异常的有（）
• if( (s!=null) & (s.length()>0) )
• if( (s!=null) && (s.length()>0) )
• if( (s==null) | (s.length()==0) )
• if( (s==null) || (s.length()==0) )

题解

• String s=null;没有给s开辟任何空间，当执行length()方法时候，因为没有具体指向的内存空间，所以报出NullPointerException没有指向的错误
• & 和 | 是位运算，前后的表达式都会执行
• && 和 || 是逻辑运算，前面表达式满足条件则后面表达式不会执行

Q4

以下代码运行结果是什么？

class Value{
    public int i=15;
}
public class Test{
    public static void main(String argv[]){
        Test t=new Test( );
        t.first( );
    }

public void first( ){
    int i=5;
    Value v=new Value( );
    v.i=25;
    second(v,i);
    System.out.println(v.i);
}

public void second(Value v,int i){
    i = 0;
    v.i = 20;
    Value val = new Value( );
    v = val;
    System.out.println(v.i+" "+i);
   }
}

• 15 0 20

题解

• 解此类题，不同方法的变量名另外取名字，可以避免搞混淆

Q5

下列叙述中，错误的是（ ）

• File类能够存储文件属性
• File类能够读写文件
• File类能够建立文件
• File类能够获取文件目录信息

题解

• 能够读写文件的是数据流（OutputStream和InputStream）
  

Q6

下列关于包（package）的描述，正确的是（）

• 包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
• import语句将所对应的Java源文件拷贝到此处执行。
• 包（package）是Eclipse组织Java项目特有的一种方式。
• 定义在同一个包（package）内的类可以不经过import而直接相互使用。

题解

• 为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间
• import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件
• Java提供的包机制与IDE没有关系
• 定义在同一个包（package）内的类可以不经过import而直接相互使用

Q7

以下程序的运行结果是？

• foobar

题解

• 线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果
• 手动调用run方法和普通方法调用没有区别

Day20

Q1

在Java中下面Class的声明哪些是错误的？

• public abstract final class Test { abstract void method(); }
• public abstract class Test { abstract final void method(); }
• public abstract class Test { abstract void method() { } }
• public class Test { final void method() { } }

题解

• A — final修饰的类为终态类，不能被继承；抽象类是必须被继承的才有其意义
• B — final修饰的方法为终态方法，不能被重写；而继承抽象类，必须重写其方法
• C — 定义的抽象方法没有实体时候，大括号必须省略

Q2

下面哪些情况可以引发异常：

• 数组越界
• 指定URL不存在
• 使用throw语句抛出
• 使用throws语句

题解

• throws出现在方法头，表示可能会出现异常；
• throw是在方法体，抛出了异常，执行throw则一定抛出了某种异常

Q3

关于下面的一段代码，以下哪些说法是正确的：

public static void main(String[] args) {
    String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

• System.out.print(a == b)打印出来的是false
• System.out.print(a == c)打印出来的是true
• System.out.print(b == c)打印出来的是false
• System.out.print(b == d)打印出来的是true

题解

• a是运行时动态加载的，此时会在堆内存中生成一个myString字符串，指向堆内存字符串地址
• b是编译时静态加载的，此时会在常量池中存放一个myString字符串，指向常量池字符串地址
• c会在编译时对"my" + "String"进行拼接成myString字符串，再去常量池查找，找到之后指向该字符串地址
• d是c的脚本，地址相同
• String的==比较的是地址值是否相同

Q4

在创建派生类对象，构造函数的执行顺序（）

• 基类构造函数，派生类对象成员构造函数，派生类本身的构造函数
• 派生类本身的构造函数，基类构造函数，对象成员构造函数
• 基类构造函数，派生类本身的构造函数，派生类对象成员构造函数
• 对象成员构造函数，基类构造函数，派生类本身的构造函数

题解

父类静态域 ——> 子类静态域 ——> 父类成员初始化 ——> 父类构造块 ——> 父类构造方法 ——> 子类成员初始化 ——> 子类构造块 ——> 子类构造方法

Q5

以下代码执行后输出结果为（ ）

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

• blockAblockBblockA
• blockAblockAblockB
• blockBblockBblockA
• blockBblockAblockB

题解

• 静态域：用staitc声明，jvm加载类时执行，仅执行一次
• 构造代码块：类中直接用{}定义，每一次创建对象时执行。
  • 1 静态域 ：首先执行，第一个静态域是一个静态变量 public static Test t1 = new Test(); 创建了Test 对象，会执行构造块代码，所以输出blockA。然后执行第二个静态域（即静态代码块）输出blockB。
  • 2 main():Test t2 = new Test()执行，创建Test类对象，只会执行构造代码块（创建对象时执行），输出blockA。
  • 3 构造代码块只会在创建对象时执行，没创建任何对象了，所以没输出
  • 4 构造函数：使用默认构造函数，没任何输出

Q6

根据以下接口和类的定义，要使代码没有语法错误，则类Hero中应该定义方法( )

interface Action{
	void fly();  
}

class Hero implements Action{  //……  }

• private void fly(){}
• void fly(){}
• protected void fly(){}
• public void fly(){}

题解

• 接口中的fly()方法，默认权限是public
• 接口实现类中的fly()方法，权限不能比原本接口的低，因此也是public

Q7

在 Java 中，存放字符串常量的对象属于（ ）类对象。

• Character
• String
• StringBuffer
• Vector

题解

Character 字符封装类
String 常量池中字符串
StringBuffer 存放字符数组
Vector 数组

Q8

下面程序段执行后b的值是()。

Integer integ =new Integer(9);
boolean b = integ  instanceof  Object;

• true

题解

instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例，而Object是所有类的父类。

Day21

Q1

下面有关值类型和引用类型描述正确的是（）？

• 值类型的变量赋值只是进行数据复制，创建一个同值的新对象，而引用类型变量赋值，仅仅是把对象的引用的指针赋值给变量，使它们共用一个内存地址。

• 值类型数据是在栈上分配内存空间，它的变量直接包含变量的实例，使用效率相对较高。而引用类型数据是分配在堆上，引用类型的变量通常包含一个指向实例的指针，变量通过指针来引用实例。

• 引用类型一般都具有继承性，但是值类型一般都是封装的，因此值类型不能作为其他任何类型的基类。

• 值类型变量的作用域主要是在栈上分配内存空间内，而引用类型变量作用域主要在分配的堆上。

题解

记住

Q2

以下哪一个不是赋值符号？

• +=
• <<=
• <<<=
• >>>=

题解

<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符

Q3

下面不是面向对象的基本原则的是？

• 单一职责原则（Single-Resposibility Principle）
• 开放封闭原则（Open-Closed principle）
• 抽象类原则（Abstract-Class principle）
• 依赖倒置原则（Dependecy-Inversion Principle）
• 接口隔离原则（Interface-Segregation Principle）

题解

• 单一职责原则：一个类，最好只做一件事，只有一个引起它的变化
• 开放封闭原则：软件实体对扩展开放，对修改封闭的
• Liskov替换原则：体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础
• 依赖倒置原则：依赖于抽象
• 接口隔离原则：使用多个小的专门的接口，而不要使用一个大的总接口

Q4

对于文件的描述正确的是（ ）

• 文本文件是以“.txt”为后缀名的文件，其他后缀名的文件是二进制文件。
• File类是Java中对文件进行读写操作的基本类。
• 无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException异常。
• Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作。

题解

• 计算机中大部分的文件还是二进制文件，二进制文件只有用对应的应用才能读懂的文件
• File类是对文件整体或者文件属性操作的类，不能操作文件内容；文件内容是用IO流操作的
• 当输入过程中意外到达文件或流的末尾时，抛出EOFException异常；正常情况读到文件末尾时，返回一个特殊值表示文件读取完成

Day22

Q1

选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     } 

• public abstract void method(int a);
• consInt=constInt+5;
• public int method();
• public abstract void anotherMethod(){}

题解

• A：抽象类可以包含抽象方法
• B：类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中
• C: 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
• D: 该方法使用abstract修饰，是抽象方法，但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法

Q2

ServletConfig接口默认是哪里实现的？

• Servlet
• GenericServlet
• HttpServlet
• 用户自定义servlet

题解

Q3

下面代码在main()方法中第八行后可以正常使用的是（ ）

public class Test
{ 
    private int a=10; 
    int b=20; 
    static int c=1; 
    public static void main(String arg[])
    { 
        Test t = new Test(); 
    } 
 } 

• t.a
• this.c
• Test.b
• Test.c

题解

• 在private修饰不能在外部类中调用，main方法属于Test类的方法， 所以对象 t 可以在他自己的类方法中调用它的private
• static 方法中没有this 这么一说
• b不是static变量

Q4

有关hashMap跟hashTable的区别，说法正确的是？

• HashMap和Hashtable都实现了Map接口
• HashMap是非synchronized，而Hashtable是synchronized
• HashTable使用Enumeration，HashMap使用Iterator
• HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

题解

Q5

Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）

• 加载Servlet类及.class对应的数据
• 创建servletRequest和servletResponse对象
• 创建ServletConfig对象
• 创建Servlet对象

题解

Day23

Q1

以下哪些方法可以取到http请求中的cookie值（）?

• request.getAttribute
• request.getHeader
• request.getParameter
• request.getCookies

题解

• 1）Cookie[] getCookies()

  • 返回一个数组，包含客户端发送该请求的所有的 Cookie 对象。

• 2）Object getAttribute(String name)

  • 以对象形式返回已命名属性的值，如果没有给定名称的属性存在，则返回 null。

• 3）String getHeader(String name)

  • 以字符串形式返回指定的请求头的值。Cookie也是头的一种；

• 4）String getParameter(String name)

  • 以字符串形式返回请求参数的值，或者如果参数不存在则返回 null。

Q2

下面代码的输出是什么？

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }

    public void callName()
    {
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

• null

题解

创造Sub子类时，首先调用父类的构造方法Base()；

父类的Base()内执行callName()方法，但是子类中也有callName()方法；

由于是创造子类对象，所以使用子类的callName()方法；

此时子类还未构造完全，baseName变量还未执行赋值，所以值为null

Q3

String s = new String(“xyz”);创建了几个StringObject？

• 两个或一个都有可能

题解

String对象的两种创建方式:

• 第一种方式: String str1 = “aaa”; 是在常量池中获取对象(“aaa” 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象)，

• 第二种方式: String str2 = new String(“aaa”) ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 “aaa” 字符串对象）。

Q4

关于下面程序，哪些描述是正确的: ( )

public class While {
	public void loop() {
		int x= 10;
		while ( x )  {
			System.out.print("x minus one is " + (x - 1));
			x -= 1;
		}
	}
}

• 行4有语法错误

题解

while（）中表达式的判断，在C语言中大于0的int值都会被认为是true，而java中没有这个机制，必须是boolean类型的

Q5

以下程序的运行结果是：( )

TreeSet<Integer> set = new TreeSet<Integer>();
TreeSet<Integer> subSet = new TreeSet<Integer>();
for(int i=606;i<613;i++){
	if(i%2==0){
	set.add(i);
	}
}

subSet = (TreeSet)set.subSet(608,true,611,true);
set.add(629);
System.out.println(set+" "+subSet);

• 编译失败
• 发生运行时异常
• [606, 608, 610, 612, 629] [608, 610]
• [606, 608, 610, 612, 629] [608, 610,629]

题解

subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的

• 最后添加的是609，不是629的话，结果是：[606, 608, 609, 610, 612] [608, 609, 610]

Day24

Q1

以下可以正确获取结果集的有

• Statement sta=con.createStatement();
  ResultSet rst=sta.executeQuery(“select * from book”);
• Statement sta=con.createStatement(“select * from book”); ResultSet rst=sta.executeQuery();
• PreparedStatement pst=con.prepareStatement();
  ResultSet rst=pst.executeQuery(“select * from book”);
• PreparedStatement pst=con.prepareStatement(“select * from book”);
  ResultSet rst=pst.executeQuery();

题解

创建Statement是不传参的，PreparedStatement是需要传入sql语句

Q2

下面有关java的引用类型，说法正确的有？

• 对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
• 如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
• 如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
• 一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间

题解

Q3

下面哪些属于JSP内置对象及方法？

• request
• out
• application
• config

题解

• JSP对象 怎样获得
  • out->response.getWriter
  • request ->Service方法中的req参数
  • response ->Service方法中的resp参数
  • session ->request.getSession
  • application ->getServletContext
  • exception ->Throwable
  • page ->this
  • pageContext ->PageContext
  • Config ->getServletConfig

Q4

此代码片段输出正确的值是（）

public class CharToString {
 public static void main(String[] args)
 {
  char myChar = 'g';
  String myStr = Character.toString(myChar);
  System.out.println("String is: "+myStr);
  myStr = String.valueOf(myChar);
  System.out.println("String is: "+myStr);
 }
}

• String is: g
  String is: g

题解

toString和valueOf返回的都是字符串，只有char变成 int 的时候才会变为对应的ASCII码

Day25

Q1

character流和byte流的区别不包括（）

• 每次读入的字节数不同
• 前者带有缓冲，后者没有。
• 前者是字符读入，后者是字节读入。
• 二者没有区别，可以互换。

题解

字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同

Q2

Java语言中，下面哪个语句是创建数组的正确语句？( )

• float f[][] = new float[6][6];
• float []f[] = new float[6][6];
• float f[][] = new float[][6];
• float [][]f = new float[6][6];
• float [][]f = new float[6][];

题解

二维数组定义，一维长度必须定义，二维可以后续定义

Q3

以下代码可以使用的修饰符是：（）

public interface Status {
 /*INSERT CODE HERE*/   int MY_VALUE=10;
 }

• final
• static
• abstract
• public

题解

• abstract只能修饰类和方法 不能修饰字段
• 接口中字段的修饰符：public static final（默认不写）
  接口中方法的修饰符：public abstract（默认不写）

Q4

阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
	public static void hello() {
	    System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}

• 能编译通过，并正确运行
• 因为使用了未初始化的变量，所以不能编译通过
• 以错误的方式访问了静态方法
• 能编译通过，但因变量为null，不能正常运行

题解

Test test=null;也会加载静态方法，所以test中包含Test类的初始化数据(静态/构造/成员属性)
因此test.hello是会调用到hello方法的

Q5

多态的表现形式有()

• 重写
• 抽象
• 继承
• 封装

题解

继承是根源，重写是表现形式

Q6

下列叙述错误的是（ ）

• java程序的输入输出功能是通过流来实现的
• java中的流按照处理单位可分成两种：字节流和字符流
• InputStream是一个基本的输出流类。
• 通过调用相应的close（）方法关闭输入输出流

题解

• 要判断InputStream是节点流还是处理流，是输出流还是输入流
• 节点流的前缀都是名词，如File，String，Char等
  处理流的前缀都是动词，如input，print，bufferd等

Q7

关于异常的编程，以下描述错误的是：（ ）

• 在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
• int i=Integer.parseInt(”123a”);将产生NumberFormatException
• int a[]=null; a[0]=1; 将产生NullPointerException
• 输入输出流编程中，读和写时都要抛出IOException

题解

运行异常是程序运行时由虚拟机帮助捕获，运行时异常包括数组的溢出，内存的溢出空指针，分母为0等！

Q8

J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的（ ）方法

• service
• doget
• dopost
• init

题解

由HttpServlet调用service()方法，来判断调用doGET或doPOST

Day26

Q1

Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( )

• Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
• 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
• 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
• Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
• Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
• Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

题解

A：Class类在java.lang包下，错；
B：动态代理可以通过接口与类实现，通过反射形成新的代理类，这个代理类增强了原来类的方法。对；
C：反射可以强制访问private类型的成员，对；
D：反射并不能对类进行修改，只能对类进行访问，错；
E：反射机制对永生堆要求较多，对；
F：即使使用换成，反射的效率也比调用类的方法低，错；

Q2

java程序内存泄露的最直接表现是（ ）

• 频繁FullGc
• jvm崩溃
• 程序抛内存控制的Exception
• java进程异常消失

题解

java是自动管理内存的，通常情况下程序运行到稳定状态，内存大小也达到一个 基本稳定的值
但是内存泄露导致Gc不能回收泄露的垃圾，内存不断变大.
最终超出内存界限，抛出OutOfMemoryExpection

Q3

以下代码执行的结果显示是多少（）？

public class Demo{
	public static void main(String args[]){
		int count = 0;
		int num = 0;
		for(int i = 0; i <= 100; i++){
			num = num + i;
			count = count++;
		}
		System.out.println("num * count = " + (num * count));
	}
}

• num * count = 505000
• num * count = 0
• 运行时错误
• num * count = 5050

题解

count = count++ 原理是 temp = count； count = count+1 ； count = temp；
因此count始终是0 这仅限于java 与c是不一样的

Q4

以下哪些内存区域属于JVM规范？（ ）

• 方法区
• 实例变量
• 静态变量
• 程序计数器
• 虚拟机栈

题解

Day27

Q1

**
有以下代码片段：
请问输出的结果是：**

String str1="hello";
String str2="he"+ new String("llo");
System.out.println(str1==str2);

• false

题解

用+拼接字符串时会创建一个新对象再返回

Q2

在Web应用程序中，( )负责将HTTP请求转换为HttpServletRequest对象

• Servlet对象
• HTTP服务器
• Web容器
• JSP网页

题解

web容器是一种服务程序，而这个程序就是处理从客户端发出的请求
servlet是运行在服务器端的小应用程序，是接收网络服务的请求和产生响应的一种方式
servlet的功能：接受http请求，产生动态http响应

Q3

下面有关Java的说法正确的是（ ）

• 一个类可以实现多个接口
• 抽象类必须有抽象方法
• protected成员在子类可见性可以修改
• 通过super可以调用父类构造函数
• final的成员方法实现中只能读取类的成员变量
• String是不可修改的，且java运行环境中对string对象有一个对象池保存

题解

被abstract修饰的类就是抽象类，有没有抽象方法无所谓

子类继承父类，并重写父类的protected成员方法，该方法的可见性可以修改，这是对的，因为子类继承父类的方法，访问权限可以相同或往大了改

Q4

关于ThreadLocal类 以下说法正确的是

• ThreadLocal继承自Thread
• ThreadLocal实现了Runnable接口
• ThreadLocal重要作用在于多线程间的数据共享
• ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
• ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

题解

ThreadLocal继承Object，相当于没继承任何特殊的
ThreadLocal没有实现任何接口
ThreadLocal并不是一个Thread，而是Thread的局部变量

Q5

jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些

• 栈空间满
• 年轻代空间满
• 老年代满
• 持久代满
• System.gc()

题解

Day28

Q1

下列哪些方法是针对循环优化进行的

• 强度削弱
• 删除归纳变量
• 删除多余运算
• 代码外提

题解

常见的代码优化技术有：复写传播，删除死代码, 强度削弱，归纳变量删除
编译原理之代码优化

Q2

Hashtable 和 HashMap 的区别是：

• Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
• HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
• Hashtable 线程安全的，而 HashMap 是线程不安全的
• Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
• HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许

题解

Q3

下面有关java threadlocal说法正确的有？

• ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
• 线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
• 在Thread类中有一个Map，用于存储每一个线程的变量的副本
• 对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

题解

无

Q4

下列哪个选项是Java调试器？

• java.exe
• javadoc.exe
• jdb.exe
• javaprof.exe

题解

javac.exe是编译.java文件
java.exe是执行编译好的.class文件
javadoc.exe是生成Java说明文档
jdb.exe是Java调试器
javaprof.exe是剖析工具

Q5

下面为true的是

Integer i = 42; 
Long l = 42l; 
Double d = 42.0; 

• (l == d)
• i.equals(d)
• l.equals(42L)

题解

包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱
包装类的equals()方法不处理数据转型

Q6

关于Float，下列说法错误的是()

• Float是一个类
• Float在java.lang包中
• Float a=1.0是正确的赋值方法
• Float a= new Float(1.0)是正确的赋值方法

题解

Float是类，float不是类

查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中

Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换

Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

Day29

Q1

关于抽象类与接口，下列说法正确的有？

• 优先选用接口，尽量少用抽象类
• 抽象类可以被声明使用，接口不可以被声明使用
• 抽象类和接口都不能被实例化

题解

1. 一个子类只能继承一个抽象类,但能实现多个接口
2. 抽象类可以有构造方法,接口没有构造方法
3. 抽象类可以有普通成员变量,接口没有普通成员变量
4. 抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意,接口只能public static final(默认)
5. 抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法
6. 抽象类可以有静态方法,接口不能有静态方法
7. 抽象类中的方法可以是public、protected;接口方法只有public

Q2

以下代码返回值是什么？

public boolean returnTest()
{
    try {
        return true;
    } catch (Exception e) {
    } finally {
        return false;
    }
}

• false

题解

一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效

Q3

在使用super和this关键字时，以下描述错误的是（）

• 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
• super()和this()不一定要放在构造方法内第一行
• this()和super()可以同时出现在一个构造函数中
• this()和super()可以在static环境中使用，包括static方法和static语句块

题解

• super和this都只能位于构造器的第一行
• 不能同时使用，因为会造成初始化两次
• 都指的是对象，均不可以在static环境中使用

Q4

以下程序的输出结果为

class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");
    }
}

• 编译错误

题解

子类的构造方法会隐式去调用 父类无参的构造方法（不会在代码中显示）

如果父类没有无参的构造方法，就必须在子类构造方法第一行显示调用父类的有参构造方法

否则编译失败

Q5

以下哪个不属于JVM堆内存中的区域（）？

• survivor区
• 常量池
• eden区
• old区

题解

• jvm堆内存：新生代（一个Eden区，两个Survivor区），老年代（old区）
• 常量池：属于 PermGen（方法区）

Q6

list是一个ArrayList的对象，代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
    Object obj = it.next();
    if (needDelete(obj))  //needDelete返回boolean，决定是否要删除
    {
        //todo delete
    }
    index ++;
}

• it.remove();
• list.remove(index);

题解

• 在循环的过程中调用集合的remove()方法，就会导致循环出错
• 循环过程中list.size()的大小变化了，就导致了错误

Day30

Q1

下列代码片段中，存在编译错误的语句是()

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

• 语句1
• 语句2
• 语句3
• 语句4

题解

• 表达式运算时，byte,short,char型的值将被提升为int型
• 语句1：b1, b2会转为int型，但是b3是byte型，需改为b3=(byte)(b1+b2)
• 语句2：b4, b5被final修饰，不会转型，正确
• 语句3：b4不会转型，但是b1会转型，需改为b8=(byte)(b1+b4)
• 语句4：同语句3；且b7被final修饰，只能赋值一次

Q2

以下代码返回结果为：

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);

• true、false

题解

• Integer类型在-128–>127范围之间是被缓存了的
• 也就是每个对象的内存地址是相同的，即a与b的引用地址相同
• 大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，即c与d不同

Q3

设 a 是 A 类同一个包下的一个实例，下列语句调用哪个是错误的？（）

class A{
	int  i;
	static  String  s;

	void  method1() {   }

	static  void  method2()  {   }
}

• System.out.println(a.i)；
• a.method1();
• A.method1();
• A.method2();

题解

非静态方法只能通过实例对象来调用，不能直接通过类名调用

静态方法（static）才能通过类名直接调用

Q4

下面关于静态方法说明正确的是

• 在静态方法中可用this来调用本类的类方法
• 在静态方法中调用本类的静态方法时可直接调用
• 在静态方法中只能调用本类中的静态方法
• 在静态方法中绝对不能调用实例方法

题解

静态方法中不能用this.实例方法，因为此时对象还没有

静态方法中，可以调用其他类的静态方法

静态方法中可以调用实例方法，但是必须要new一个对象

Q5

Java与C++的区别

• Java是解释型语言，源码—>编译：中间码—>解释：机器码
  C++是编译型语言，源码—>编译：机器码
• Java可以利用JVM跨平台
  C++比Java执行速度快
• Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义
  C++中还有面向过程的东西，比如是全局变量和全局函数
• Java中没有指针，但是有引用
  C++中有指针
• Java中类都是单继承的，继承都有传递性
  C++支持多继承
• Java中JVM有GC机制，不需要开发者管理内存；也会出现OOM和内存泄漏的问题
  C++需要开发者管理内存
• Java中有Object的finalize方法
  C++中有析构函数
• Java中不可以运算符重载
  C++运算符可以重载
• Java中强制自动转型会出现ClassCastException（类型不匹配）
  C++中支持强制自动转型