Java：笔试题

1.boolean类型不能赋值数值类型，未初始化boolean类型不能使用判断条件，也就boolean类型的变量是没有默认值

boolean tag;                     //并未初始化
System.out.println(tag);         //未初始化就使用，编译不通过
tag = 1;                         //不能对boolean类型赋值数值
tag = 0;                
if(tag != 0){}                   //不能与数值进行比价运算
if(tag){}                        //未初始化不能使用
        
tag = true;                      //赋值之后正常使用
if(tag){}

2.Object类没有equals（）方法只有equals（Object obj）方法

/**
 * 编译不通过，Object类没有equals()方法，只有equals(Object obj)方法
 */
public class A {
    protected boolean equals() {
        return super.equals();
    }
}

3.Servlet的生命周期一般可以用三个方法来表示

　　init()：仅执行一次，负责在装载Servlet时初始化Servlet对象,

　　service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。

　　destory()：在停止并且卸载Servlet时执行，负责释放资源。

初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。

ServletRequest 和ServletResponse是在调用service方法时才构造的

4.两个boolean类型 && 操作的时候必须全为true才为true，若第一个为false则短路，|| 只要一个为true就为true，如果第一个为true则短路

//测试短路操作
boolean flag1 = true;
boolean flag2 = false;
System.out.println(flag2 && flag1);//第一个为false短路
System.out.println(flag1 || flag2);//第一个为true短路

5.java序列化

http://regedit-123.iteye.com/blog/1109191

http://www.cnblogs.com/xdp-gacl/p/3777987.html

6.时间复杂度是度量算法执行的时间长短；　

空间复杂度是度量算法所需存储空间的大小.

不过一般我们说的时间复杂度是指他运行时计算的次数,空间复杂度是指运行完一个程序所需内存的大小.

http://www.cnblogs.com/songQQ/archive/2009/10/20/1587122.html

7. Vector & ArrayList
1） Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
2）当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

8.FileOutStream文件覆盖操作或者追加操作

　　　　　　　System.err.println("文件操作覆盖");
            FileOutputStream fos = new FileOutputStream(new File("test.txt"));
            fos.write("hello".getBytes());
            fos.close();
            
            System.err.println("文件操作覆盖");
            FileOutputStream fos2 = new FileOutputStream(new File("test.txt"));
            fos2.write("word".getBytes());
            fos2.close();
            
            System.err.println("文件操作追加");
            FileOutputStream fos3 = new FileOutputStream(new File("test.txt"),true);
            fos3.write("append".getBytes());
            fos3.close();
            
            System.out.println("文件操作读取");
            FileInputStream fis = new FileInputStream(new File("test.txt"));
            byte[] buffer = new byte[1024];
            StringBuilder sb = new StringBuilder();
            int len = 0;
            while((len = fis.read(buffer)) != -1){
                sb.append(new String(buffer,0,len));
            }
            System.out.println(sb.toString());
            
            System.out.println("文件操作读取");
            BufferedReader bfr = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
            StringBuilder sb2 = new StringBuilder();
            String line = "";
            while((line = bfr.readLine())!=null ){
                sb2.append(line);
            }
            System.out.println(sb2.toString());

9.String没有初始化的话，编译不通过

String str;
int x = 100;
if(x < 100) str = "";
if(x > 100) str = "";
System.out.println(str.length());

10.JSP隐含对象是页面中的一些Java对象，JSP容器让这些Java对象可以为开发者所使用。开发者不用明确的声明就可以直接使用他们。JSP隐含对象也叫做预定义变量。下面列出了JSP页面中的隐含对象： application page request response session exception out config pageContext

11.自定义异常类区别于API中的标准异常类，指的是开发人员自己创建的异常类。只要继承API中某个异常类就可以自定义一个异常类，常常集成Exception类。自定义异常类主要是为了标记业务逻辑中非正常事件流，避免与API中的标准异常混淆

12.需要提供默认的构造函数，没有默认的构造函数，在Parent2中编译不通过

class Parent1 {
//    Parent1(){
//        
//    }
    Parent1(String s){
        System.out.println(s);
    }
}
class Parent2  extends Parent1{
    Parent2(){
        System.out.println("parent2");
    }
}
public class Child extends Parent2 {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

13.XML的用途：用到了数据存贮，信息配置两方面。在做数据交换平台时，将数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再对XML文件中还原的相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中

14.什么是反射机制：通过类的说明，可以得到类的父类，实现的接口，内部类，构造函数，方法和属性，并可以根据构造器实例创建一个对象，唤起方法，取属性，修改属性值

15.HashTable与HashMap的区别

16.聚合与组合：依赖关系是一种瞬时关系，A依赖B，指的是A的某个行为的参数是B的类型，也就是说，A要想实现这个行为，必须依赖B的实例。 A关联B，是一种长久的关系。是B作为A的属性存在，只要实例化一个A的对象，就会为这个A的对象实例化一个B的对象，作为它的属性使用，可以在A中任何需要使用B的地方使用B。

17.只能用public修饰interface

18.Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

19.结束方法 finalize() 可以用来帮助优化对象,该方法在释放对象时被子引用,它是 java 中为了有效地进行垃圾收集而引入的一个特殊方法, finalize() 方法属于 java.lang.Object 的系统类方法,它能被所有类访问, 当一个对象实例已经完全没有被任何变量引用时,则可以对它进行垃圾收集标记,在进行”垃圾收集”之前,系统将自动调用对象的 finalize() 方法,释放对象实例所占用的系统资源.

20. Statement：用于执行静态SQL语句并返回它所生成结果的对象，在执行时确定sql；

　　PrepareStatement：表示预编译的SQL语句对象，

SQL语句被预编译并存储在PrepareStatement对象中，然后可以使用此对象高效的多次执行该语句，可以传递参数，在得到PrepareStatement对象时确定sql；

21.字节流，字符流。

　　字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。

　　在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

　　补充：关于Java的IO需要注意的有两点：

　　　　　一是两种对称性（输入和输出的对称性，字节和字符的对称性）；

　　　　　二是两种设计模式（适配器模式和装潢模式）。

另外Java中的流不同于C#的是它只有一个维度一个方向。补充：下面用IO和NIO两种方式实现文件拷贝，这个题目在面试的时候是经常被问到的

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    public static void fileCopy(String source, String target) throws IOException {
        try (InputStream in = new FileInputStream(source)) {
            try (OutputStream out = new FileOutputStream(target)) {
                byte[] buffer = new byte[4096];
                int bytesToRead;
                while((bytesToRead = in.read(buffer)) != -1) {
                    out.write(buffer, 0, bytesToRead);
                }
            }
        }
    }

    public static void fileCopyNIO(String source, String target) throws IOException {
        try (FileInputStream in = new FileInputStream(source)) {
            try (FileOutputStream out = new FileOutputStream(target)) {
                FileChannel inChannel = in.getChannel();
                FileChannel outChannel = out.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4096);
                while(inChannel.read(buffer) != -1) {
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                }
            }
        }
    }
}

22.HQL语句：

http://blog.csdn.net/v123411739/article/details/28644007

23.单元测试时，以下哪项是最小的测试单元：方法

24.try catch finally语句块，如果有返回值的时候，需要先执行finally，再返回：执行结果---

　　　　finally 语句块
　　　　和是：43

public class Demo {
    public int add(int a, int b) {
        try {
            return a + b;
        } catch (Exception e) {
            System.out.println("catch 语句块");
        } finally {
            System.out.println("finally 语句块");
        }
        return 0;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println("和是：" + demo.add(9, 34));
    }
}

25.排序算法复杂度和稳定性

26.抽象方法不能写出大括号，有了body体就不再是抽像的了

27.环境变量可在编译source code时指定是错误的

28.C是错误的，方法区用于存储JVM加载的类信息以及类相关的东西，比如类变量、常量等，是线程隔离的，但是编译器编译后的代码等数据，是线程共享的

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

29.Servlet是用来处理客户端请求并产生动态网页内容的Java类。Servlet主要是用来处理或者是存储HTML表单提交的数据，产生动态内容，在无状态的HTTP协议下管理状态信息

30.服务器网络编程中，解决回话跟踪的方法有：

　　　　Cookie;Session;URL重写;

　　　　cookie在J2EE项目中的使用，Java中把Cookie封装成了java.servlet.http.Cookie类。

　　　　每个Cookie都是该 Cookie类的对象。服务器通过操作Cookie类对象，对客户端Cookie进行操作。

　　　　通过request.getCookies()获取客户端提交的所有Cookie（以Cookie[]数组形式返回），通过 response.addCookie(Cookiecookie)向客户端设置Cookie。

　　　　Cookie对象使用key-value属性对的形式保存用户状态，一个Cookie对象保存一个属性对，一个request或者response同时使用多个Cookie。

// 服务器端获取cookie 
Cookie[]cookies = request.getCookies(); 
for (int i = 0; cookies != null && i < cookies.length;i++) { 
         Cookiecookie = cookies[i]; 
         if("username".equals(cookie.getName())) { 
         } 
      } 
//服务器端设置cookie 
 String username = "sa"; 
 Cookie usernameCookie = new Cookie("username", username); 
 response.addCookie(usernameCookie);

31.我们可以使用任何类作为Map的key，然而在使用它们之前，需要考虑以下几点：

（1）如果类重写了equals()方法，它也应该重写hashCode()方法。

（2）类的所有实例需要遵循与equals()和hashCode()相关的规则。请参考之前提到的这些规则。

（3）如果一个类没有使用equals()，你不应该在hashCode()中使用它。

（4）用户自定义key类的最佳实践是使之为不可变的，这样，hashCode()值可以被缓存起来，拥有更好的性能。不可变的类也可以确保hashCode()和equals()在未来不会改变，这样就会解决与可变相关的问题了。

比如，我有一个类MyKey，在HashMap中使用它。 //传递给MyKey的name参数被用于equals()和hashCode()中 MyKey key=new MyKey('Pankaj');//assume hashCode=1234 myHashMap.put(key，'Value'); //以下的代码会改变key的hashCode()和equals()值 key.setName('Amit');//assume new hashCode=7890 //下面会返回null，因为HashMap会尝试查找存储同样索引的key，而key已被改变了，匹配失败，返回null myHashMap.get(new MyKey('Pankaj')); 那就是为何String和Integer被作为HashMap的key大量使用。

32.C/S 模式, 即客户端( Clinet)和服务器端 (Server)的两层结构模式, 其特点就是主要业务逻辑集中在客户端,因此,也带来了一定的弊端 : 首先,在安装,调试,维护,升级方面比较因难, 因为每个客户端的配置不同,所以在配置的时候,必须对每个客户端进行配置. 由于主要业务逻辑集中在客户端,系统的安全受到影响.

B/S 模式, 即浏览器端(Browers)和服务器端(Server)的结构模式, 其核心是用浏览器(Browers)取代C/S模式中的客户端。其优点是：首先，在维护，升级的时候，只须对服务器端进行维护和升能就可以了。由于客户端就是浏览器，有利于系统的安全。

33.早期的JDK中，switch（expr）中，expr可以是byte、short、char、int。从5版开始，Java中引入了枚举类型（enum），expr也可以是枚举，从JDK 7版开始，还可以是字符串（String）。长整型（long）是不可以的。

34.计算任意两个日期之间间隔的天数

import java.util.Calendar;
public class Ex14 {
public static void main(String[] args) {
　　Calendar c1 = Calendar.getInstance();
　　c1.set(2010, 7, 1);
　　Calendar c2 = Calendar.getInstance();
　　long ca1 = c1.getTimeInMillis();
　　long ca2 = c2.getTimeInMillis();
　　// 计算天数    
　　long days = (ca2 - ca1) / (24 * 60 * 60 * 1000);
　　System.out.println(days);
　　}
}

35.子类不可以继承父类的构造方法，只可以调用父类的构造方法。子类中所有的构造函数都会默认访问父类中的空参数构造函数，这是因为子类的构造函数内第一行都有默认的super（）语句。super（）表示子类在初始化时调用父类的空参数的构造函数来完成初始化。一个类都会有默认的空参数的构造函数，若指定了带参构造函数，那么默认的空参数的构造函数，就不存在了。这时如果子类的构造函数有默认的super（）语句，那么就会出现错误，因为父类中没有空参数的构造函数。因此，在子类中默认super（）语句，在父类中无对应的构造函数，必须在子类的构造函数中通过this或super（参数）指定要访问的父类中的构造函数。

36.final关键字的作用：

(1)修饰类：表示该类不能被继承；

(2)修饰方法：表示方法不能被重写；

(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

37.throw用来在方法体内抛出异常，而throws用来在方法声明处声明异常。这两个关键字有着一定的联系。如果一个方法中使用了throw关键字抛出了异常，那么要么立即用try/catch语句进行捕获，要么就是用throws进行声明，否则将出现编译错误。然而，并不是只有使用了throw关键字之后才能使用throws关键字，语法上来说，任何一个方法都可以直接使用throws关键字，抽象方法也可以使用。

38.Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的

39.软件维护的四类维护活动是：纠错性维护，适应性维护，完善性维护和预防性维护。

40.打印昨天的当前时刻

public class YesterdayCurrent {  
    public static void main(String[] args){  
        Calendar cal = Calendar.getInstance();  
        cal.add(Calendar.DATE, -1);  
        System.out.println(cal.getTime());  
    }  
}

41.方法内部不能含有静态变量

package test4;

public class Test {
    public  int aMethod() {
        static int i = 0;//编译错误
        i++;
        return i;
    }

    public static void main(String args[]) {
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println(j);
    }
}

42.关于Java并发的说法中正确的是（B）

CopyOnWriteArrayList适用于写多读少的并发场景
ReadWriteLock适用于读多写少的并发场景
ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

43.switch case 语句

        //如果没有第一个匹配的那么任何一个都不会执行
        //一旦有一个匹配，那么就会继续往下执行，直到break结束
        //执行结果为default zero
        int i = 9;
        switch (i) {
        default:
            System.out.println("default");
        case 0:
            System.out.println("zero");
            break;
        case 1:
            System.out.println("one");
        case 2:
            System.out.println("two");
        }

44.就ArrayList与Vector主要从二方面来说. 一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的。二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半。

45.

posted @ 2016-08-03 14:40 桃源仙居阅读(186) 评论(0) 收藏举报

刷新页面返回顶部

桃源仙居

Java：笔试题

公告