在jdbc中，我定义了一个数据库类

其中定义了一些静态的数据库引用
private static Connection ct = null;
        private static ResultSet rs = null;
        private static PreparedStatement ps = null;
试问，在这个类中，到底使用纯静态的方法和引用好呢？还是使用一个简单类
也就是创建对象的方式得到比较好呢

不太好意思，你的问题我没太看明白，给你个jdbc操作mysql数据库实例代码参考一下，希望能对你有所帮助

1. package com.ty.test;
   
2. 
   
3. import java.sql.*;
   
4. 
   
5. public class TestMysql {
   
6.        
   
7.         //测试如何操作mysql数据库
   
8.         public static void main(String args[])
   
9.         {
   
10.                 Connection ct=null;
    
11.                 PreparedStatement ps=null;
    
12.                 ResultSet rs=null;
    
13.                 try {
    
14.                         //1.加载驱动
    
15.                         Class.forName("com.mysql.jdbc.Driver");
    
16.                         //2.得到链接
    
17.                         ct=DriverManager.getConnection
    
18.                         ("jdbc:mysql://localhost:3306/spdb1?useUnicode=true&characterEncoding=UTF-8","root","数据库的密码");
    
19.                         //3.创建ps<ps代表预编译的sql对象>
    
20.                         ps=ct.prepareStatement("select * from test14");
    
21.                         //4.执行
    
22.                         rs=ps.executeQuery();
    
23.                         while(rs.next())
    
24.                         {
    
25.                                 System.out.println("姓名="+rs.getString("name")+" 薪水="+rs.getFloat("sal"));
    
26.                         }
    
27.                 } catch (Exception e) {
    
28.                         // TODO: handle exception
    
29.                 }finally{
    
30.                         //关闭
    
31.                         if(rs!=null)
    
32.                         {
    
33.                            try {
    
34.                                 rs.close();
    
35.                         } catch (Exception e) {
    
36.                                 // TODO Auto-generated catch block
    
37.                                 e.printStackTrace();
    
38.                         }
    
39.                         rs=null;
    
40.                         }
    
41.                         if(ps!=null)
    
42.                         {
    
43.                                 try {
    
44.                                         ps.close();
    
45.                                 } catch (Exception e) {
    
46.                                         // TODO Auto-generated catch block
    
47.                                         e.printStackTrace();
    
48.                                 }
    
49.                                 ps=null;
    
50.                         }
    
51.                         if(ct!=null)
    
52.                         {
    
53.                                 try {
    
54.                                         ct.close();
    
55.                                 } catch (SQLException e) {
    
56.                                         // TODO Auto-generated catch block
    
57.                                         e.printStackTrace();
    
58.                                 }
    
59.                                 ct=null;
    
60.                         }
    
61.                 }
    
62.         }
    
63. 
    
64. }
    

复制代码

我来回答楼主的提问，这个问题可以从多个方面来看，是否定义成静态的，得看实际情况，
如果你只是单线程访问，那就定义成静态的吧，如果涉及到多线程，那就最好不要使用静态的。

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢