Java面试题八

最新推荐文章于 2024-11-11 07:00:00 发布

原创最新推荐文章于 2024-11-11 07:00:00 发布 · 1.8k 阅读

1 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

17 篇文章

订阅专栏

本文提供了Java面试的三个部分：选择题、简答题和编程题。选择题涉及constructor的使用和数组特性；简答题涵盖了抽象类与接口的区别，sleep和wait的异同，以及TreeMap和HashMap的对比；编程题包括MySQL数据库连接、Socket通信和多线程并发操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

(此系列试题来源于Java面试宝典书籍)

一、选择题

1. 下列说法正确的是

A. class 中的 constructor 不可忽略
B. constructor 可以作为普通方法被调用
C. constructor 在一个对象被 new 时被调用
一个 class 只能定义一个 constructor

2. 下面正确的是

constructor 必须与 class 同名，但是方法不能与 class 同名
constructor 可以被继承，因此可以重写 Overriding，也可以被重载 Overloading
String 类是 final 类故不可以被继承
数组的大小可以任意改变，又称动态数组
try{}里有一个 return 语句，则紧跟在 try 后面的 finally{}里的 code 将在 return 后执行

解析：

1) constructor 必须与 class 同名，但是方法不能与 class 同名-----错可以同名，区别是构造器没有返回值

2) constructor 无法被继承，因此不可以重写 Overriding，但可以重载 Overloading

3) 数组的大小不可以任意改变，即数组确定就大小确定，动态数组是通过删除原来数组新建数组来实现动态的

/**
 * try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，还是在return之后执行？
 * @author Hongten
 * @date 2013-12-10
 */
public class TestC {

    public static void main(String[] args) {
        System.out.println("结果： " + new TestC().test());
    }
    
    static int test(){
        int i = 1;
        try {
            System.out.println("try里面的i : " + i);
            return i;
        }finally{
            System.out.println("进入finally...");
            ++i;
            System.out.println("fianlly里面的i : " + i);
        }
    }
}


// result:

// try里面的i : 1
// 进入finally...
// fianlly里面的i : 2
// 结果： 1

二、简答题

1. 抽象类和接口

2. sleep和wait

这两个方法来自不同的类分别是Thread和Object
最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。
wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)
sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

public class Test9 {

    /**
     * java中的sleep()和wait()的区别
     * @author Hongten
     * @date 2013-12-10
     */
    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable{
        @Override
        public void run(){
            synchronized (Test9.class) {
                System.out.println("enter thread1...");
                System.out.println("thread1 is waiting...");
                try {
                    //调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
                    Test9.class.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 is going on ....");
                System.out.println("thread1 is over!!!");
            }
        }
    }

    private static class Thread2 implements Runnable{
        @Override
        public void run(){
            synchronized (Test9.class) {
                System.out.println("enter thread2....");
                System.out.println("thread2 is sleep....");
                try {
                    //在调用sleep()方法的过程中，线程不会释放对象锁。
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread2 is going on....");
                System.out.println("thread2 is over!!!");
                //如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
                //方法，则线程永远处于挂起状态。
                Test9.class.notify();
            }
        }
    }
}

result:

enter thread1...
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
thread1 is going on ....
thread1 is over!!!

3. TreeMap 和 HashMap 有什么不同点

HashMap：基于哈希表实现。使用 HashMap 要求添加的键类明确定义了 hashCode()和 equals()[可以重写hashCode()和 equals()]，为了优化 HashMap 空间的使用，您可以调优初始容量和负载因子
TreeMap：基于红黑树实现。TreeMap 没有调优选项，因为该树总处于平衡状态
HashMap 通过 hashcode 对其内容进行快速查找
TreeMap 中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用 TreeMap（HashMap 中元素的排列顺序是不固定的）
HashMap 非线程安全 TreeMap 线程安全
HashMap：适用于在 Map 中插入、删除和定位元素 Treemap：适用于按自然顺序或自定义顺序遍历键(key)

4. throws和throw

5. length()和length

java 中的 length 属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性
java 中的 length()方法是针对字符串 String 说的,如果想看这个字符串的长度则用到 length()这个方法

三、编程题

1. mysql数据库连接

statement

import java.sql.*;

public class ConnSql {

    //数据库地址
    private static final String url = "jdbc:mysql://localhost:3306/test";
    private static final String name = "com.mysql.jdbc.Driver";
    private static final String username = "root";
    private static final String password = "root";

    public static void main(String[] args) throws Exception{

        Connection conn =  null;
        Statement stm = null;
        ResultSet rs = null;
        try{
            // 加载驱动
            Class.forName(name);
            // 获得连接
            conn = DriverManager.getConnection(url,username,password);
            // 执行查询
            stm = conn.createStatement();
            String sql = "select * from student";
            rs = stm.executeQuery(sql);
            // 获得结果集
            while (rs.next()){
                int id = rs.getInt("sid");
                String name = rs.getString("sname");
                int age = rs.getInt("sage");
                String sex = rs.getString("ssex");

                System.out.print("ID:"+id+" ");
                System.out.print("name:"+name+" ");
                System.out.print("age:"+age+" ");
                System.out.print("sex:"+sex+" ");
                System.out.println();
            }
        }catch (SQLException se){
            se.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 关闭资源
            try{
                if (rs!=null){
                    rs.close();
                }
                if (stm!=null){
                    stm.close();
                }
                if (conn!=null){
                    conn.close();
                }
            }catch (SQLException e2){
                e2.printStackTrace();
            }
        }
        
    }
}

prepastatement

import java.sql.*;

public class ConnSql {

    //数据库地址
    private static final String url = "jdbc:mysql://localhost:3306/test";
    private static final String name = "com.mysql.jdbc.Driver";
    private static final String username = "root";
    private static final String password = "root";

    public static void main(String[] args) throws Exception{

        Connection conn =  null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try{
            // 加载驱动
            Class.forName(name);
            // 获得连接
            conn = DriverManager.getConnection(url,username,password);
            // 执行查询
            String sql = "select * from student";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            // 获得结果集
            while (rs.next()){
                int id = rs.getInt("sid");
                String name = rs.getString("sname");
                int age = rs.getInt("sage");
                String sex = rs.getString("ssex");

                System.out.print("ID:"+id+" ");
                System.out.print("name:"+name+" ");
                System.out.print("age:"+age+" ");
                System.out.print("sex:"+sex+" ");
                System.out.println();
            }
        }catch (SQLException se){
            se.printStackTrace();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 关闭资源
            try{
                if (rs!=null){
                    rs.close();
                }
                if (ps!=null){
                    ps.close();
                }
                if (conn!=null){
                    conn.close();
                }
            }catch (SQLException e2){
                e2.printStackTrace();
            }
        }

    }
}

2. 请编写一 socket 的程序，客户端向服务器端发送字符串，服务器端在返回相同的字符串

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Base_Server {
    public static final int PORT = 12345;//监听的端口号

    public static void main(String[] args) {
        System.out.println("服务器启动...\n");
        Base_Server server = new Base_Server();
        server.init();
    }

    public void init() {
        try {
            ServerSocket serverSocket = new ServerSocket(PORT);
            while (true) {
                // 一旦有堵塞, 则表示服务器与客户端获得了连接  
                Socket client = serverSocket.accept();
                // 处理这次连接  
                new HandlerThread(client);
            }
        } catch (Exception e) {
            System.out.println("服务器异常: " + e.getMessage());
        }
    }

    private class HandlerThread implements Runnable {
        private Socket socket;
        public HandlerThread(Socket client) {
            socket = client;
            new Thread(this).start();
        }

        public void run() {
            try {
                // 读取客户端数据  
                DataInputStream fromClient = new DataInputStream(socket.getInputStream());
                String clientInputStr = fromClient.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
                // 处理客户端数据  
                System.out.println("客户端：" + clientInputStr);

                // 向客户端回复信息  
                DataOutputStream toClient = new DataOutputStream(socket.getOutputStream());
                System.out.print("服务端：");
                // 发送键盘输入的一行  
                String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
                toClient.writeUTF(s);

                toClient.close();
                fromClient.close();
            } catch (Exception e) {
                System.out.println("服务器异常: " + e.getMessage());
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (Exception e) {
                        socket = null;
                        System.out.println("服务端 finally 异常:" + e.getMessage());
                    }
                }
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class Base_Client {
    public static final String IP_ADDR = "127.0.0.1";//服务器地址
    public static final int PORT = 12345;//服务器端口号

    public static void main(String[] args) {
        System.out.println("客户端启动...");
        System.out.println("当接收到服务器端字符为 \"OK\" 的时候, 客户端将终止\n");
        while (true) {
            Socket socket = null;
            try {
                //创建一个流套接字并将其连接到指定主机上的指定端口号
                socket = new Socket(IP_ADDR, PORT);

                //读取服务器端数据
                DataInputStream froServer = new DataInputStream(socket.getInputStream());
                //向服务器端发送数据
                DataOutputStream toServer = new DataOutputStream(socket.getOutputStream());
                System.out.print("客户端：");
                String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
                toServer.writeUTF(str);

                String ret = froServer.readUTF();
                System.out.println("服务端：" + ret);
                // 如接收到 "OK" 则断开连接
                if ("OK".equals(ret)) {
                    System.out.println("客户端将关闭连接");
                    Thread.sleep(500);
                    break;
                }
                toServer.close();
                froServer.close();
            } catch (Exception e) {
                System.out.println("客户端异常:" + e.getMessage());
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        socket = null;
                        System.out.println("客户端 finally 异常:" + e.getMessage());
                    }
                }
            }
        }
    }
}

3. 写一个多线程，四个线程对一个int变量，2个加1，2个减1，输出

import jdk.management.resource.internal.inst.FileOutputStreamRMHooks;

public class Test11 {

    int j = 1;

    public synchronized void inc(){
        j++;
        System.out.println(Thread.currentThread().getName()+"-inc:"+j);
    }

    public synchronized void dec(){
        j--;
        System.out.println(Thread.currentThread().getName()+"-dec:"+j);
    }

    class T1 implements Runnable{

        @Override
        public void run() {
            inc();
        }
    }

    class T2 implements Runnable{

        @Override
        public void run() {
            dec();
        }
    }

    public static void main(String[] args) {
        Test11 t = new Test11();

        T1 t1 = t.new T1();
        T2 t2 = t.new T2();

        for (int i=0;i<2;i++){
            Thread thread1 = new Thread(t1);
            thread1.start();

            Thread thread2 = new Thread(t2);
            thread2.start();
        }
        
        // result:
        // Thread-0-inc:2
        // Thread-3-dec:1
        // Thread-2-inc:2
        // Thread-1-dec:1
    }
}