java中简述使用JDBC完成数据库 *** 作的基本步骤(简述采用jdbc访问数据库的步骤)

创建一个以JDBC连接数据库的程序，包含7个步骤：

1、加载JDBC驱动程序：

在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），这通过javalangClass类的静态方法forName(StringclassName)实现。

例如：

try{

//加载MySql的驱动类

ClassforName("commysqljdbcDriver");

}catch(e){

Systemoutprintln("找不到驱动程序类，加载驱动失败！");

e();

}

成功加载后，会将Driver类的实例注册到类中。

2、提供JDBC连接的URL

61连接URL定义了连接数据库时的协议、子协议、数据源标识。

61书写形式：协议：子协议：数据源标识

协议：在JDBC中总是以jdbc开始

子协议：是桥连接的驱动程序或是数据库管理系统名称。

数据源标识：标记找到数据库来源的地址与连接端口。

例如：（MySql的连接URL）

jdbc:mysql:

//localhost:3306/testuseUnicode=true&=gbk;

useUnicode=true：表示使用Unicode字符集。如果设置为

gb2312或GBK，本参数必须设置为true。=gbk：字符编码方式。

3、创建数据库的连接

61要连接数据库，需要向javasql请求并获得Connection对象，该对象就代表一个数据库的连接。

61使用的(Stringurl,Stringusername，Stringpassword)方法传入指定的欲连接的数据库的路径、数据库的用户名和

密码来获得。

例如：

//连接MySql数据库，用户名和密码都是root

Stringurl="jdbc:mysql://localhost:3306/test";

Stringusername="root";

Stringpassword="root";

try{

Connectioncon=

(url,username,password);

}catch(se){

Systemoutprintln("数据库连接失败！");

se();

}

4、创建一个Statement

61要执行SQL语句，必须获得javasqlStatement实例，Statement实例分为以下3

种类型：

1、执行静态SQL语句。通常通过Statement实例实现。

2、执行动态SQL语句。通常通过实例实现。

3、执行数据库存储过程。通常通过实例实现。

具体的实现方式：

Statementstmt=con();

PreparedStatementpstmt=conprepareStatement(sql);

CallableStatementcstmt=

conprepareCall("{CALLdemoSp(,)}");

5、执行SQL语句

Statement接口提供了三种执行SQL语句的方法：executeQuery、executeUpdate

和execute

1、ResultSetexecuteQuery(StringsqlString)：执行查询数据库的SQL语句

，返回一个结果集（ResultSet）对象。

2、intexecuteUpdate(StringsqlString)：用于执行INSERT、UPDATE或

DELETE语句以及SQLDDL语句，如：CREATETABLE和DROPTABLE等

3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的

语句。

具体实现的代码：

ResultSetrs=stmtexecuteQuery("SELECTFROM");

introws=stmtexecuteUpdate("INSERTINTO");

booleanflag=stmtexecute(Stringsql);

6、处理结果

两种情况：

1、执行更新返回的是本次 *** 作影响到的记录数。

2、执行查询返回的结果是一个ResultSet对象。

61ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些

行中数据的访问。

61使用结果集（ResultSet）对象的访问方法获取数据：

while(rsnext()){

Stringname=rsgetString("name");

Stringpass=rsgetString(1);//此方法比较高效

}

（列是从左到右编号的，并且从列1开始）

7、关闭JDBC对象

*** 作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声

明顺序相反：

1、关闭记录集

2、关闭声明

3、关闭连接对象

if(rs!=null){//关闭记录集

try{

rsclose();

}catch(SQLExceptione){

eprintStackTrace();

}

}

if(stmt!=null){//关闭声明

try{

stmtclose();

}catch(SQLExceptione){

eprintStackTrace();

}

}

if(conn!=null){//关闭连接对象

try{

connclose();

}catch(SQLExceptione){

eprintStackTrace();

}

}

首先说明一下序列化的知识：java中的序列化()机制能够将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；然后在需要的时候，可以根据字节流中的信息来重构一个相同的对象

序列化机制在java中有着广泛的应用，EJB、RMI等技术都是以此为基础的

序列化机制是通过java

io

类和java

io

类来实现的

在序列化(serialize)一个对象的时候，会先实例化一个对象，然后调用其writeObject()方法；在反序列化(deserialize)的时候，则会实例化一个对象，然后调用其readObject()方法

上面您的错误，就是在于有一个或者几个没有"序列化"的数据，导致没有办法创建输出流，导致发生的java

io

之所以要序列化，我猜测是因为您的数据里面存在一个对象型的数据，但是该对象没有实现序列化

比如：您有一个字段为address，这个字段您是通过一个类Address来描述的，Address里面可能有province、city、street等等属性或者一些setter和getter，如果这个类，没有实现序列化，往往会出现这个问题

毕竟没有看到程序，是我的一个猜测，请检查一下程序或者发出来进行进一步讨论

望list中放的是什么，取出来就要是什么。
如果是一个类的对象，则需要强制转换后，然后显示
如：list里放的是Student类的一些对象
使用list的get(int index)方法返回的是Object的对象
需要强制转换为Student类的对象
Student stu = (Student)listNameget(int index)
然后用stu去取得相应的属性，显示出来
做一个循环即可
if(listName != null){
for(int i = 0; i< listNamesize(); i++){
Student stu = (Student)listNameget(int index);
//然后显示内容
}
}

多个数据，每行输入一个，最后输入换行。
你前面输入一个数据就要输换行，才算一行啊。那你这岂不是只能输入1个数据。
需求都前后矛盾。
是不是说多个数据按空格分开，输入换行时，输出？

public class Test1 {
public static void main(String[] args) {
FourElements e1 = new FourElements(1, 2, 3, 4D);
FourElements e2 = new FourElements(11, 22, 33, 44d);

FourElements e3 = e1calculate(e2);
Systemoutprintln("After calcualting, the result is: " + e3toString());
}
}
class FourElements{
private double a, b, c, d;
public FourElements(double a, double b, double c, double d){
thisa = a;
thisb = b;
thisc = c;
thisd = d;
}

public FourElements calculate(FourElements element2){
double newA = thisa + element2getA();
double newB = thisb - element2getB();
double newC = thisc element2getC();
double newD = thisd / element2getD();
return new FourElements(newA, newB, newC, newD);

}
public double getA() {
return a;
}
public double getB() {
return b;
}
public double getC() {
return c;
}
public double getD() {
return d;
}

public String toString(){
return "a = " + a + ", b = " + b + ", c = " + c + ", d = " + d;
}
}

public class Util{

public static void main(String[] args){

javautilScanner sc = new javautilScanner(Systemin);

String[] arr = new String[5];

for(int i = 0; i < arrlength; i++){

arr[i] = scnext();

}

//这里使用utilArrays的代码输出数组

Systemoutprintln(javautilArraystoString(arr));

}

}

扩展资料：

java中接受用户输入的其他方法

package 控制台接受输入;

import javaioBufferedReader;

import javaioIOException;

import javaioInputStream;

import javaioInputStreamReader;

import javanioBuffer;

import javautilScanner;

public class InputCode {

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

/

Scanner类中的方法

完美

/

Scanner input =new Scanner(Systemin);

Systemoutprintln("please input your name ");

String name=inputnextLine();

Systemoutprintln(name);

/

缺点：只能接受用户输入的一个字符

/

Systemoutprintln("enter your name");

char name1 = 0;

try {

//inputstream中的read()方法放回输入流中下一个字符

name1 = (char) Systeminread();

} catch (IOException e) {

eprintStackTrace();

}

Systemoutprintln(name1);

/

InputStreamReader和BufferedReader方法

优点：可以获取字符串

缺点：获取的是int或者string人需要强转

/

//通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader

//包装所有其 read() *** 作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，

//BufferedReader in= new BufferedReader(new FileReader("fooin"));

Systemoutprintln("enter your name");

InputStreamReader input1=new InputStreamReader(Systemin);

BufferedReader in=new BufferedReader(input1);

String name2=inreadLine();

Systemoutprintln(name2);

}

}

java中有两种数据类型：基本类型和引用类型。
基本类型有8个：
整数类型 byte、short、int、long
浮点数类型 float、double
字符型 char
布尔类型 boolean
引用类型包括三种：
类 Class
接口 Interface
数组 Array
基本类型是通过诸如 int a = 5; long b = 6L;的形式来定义的，称为自动变量，自动变量存放的是字面值，不是类的实例，它存放在内存的堆栈中，数据大小和生存期必须是确定的，存取速度比较快，在堆栈中的字面值可以共享，也就是说我们定义一个int a = 5;然后又定义了一个int b = 5;这时a与b在内存中指向的是同一个字面常量。
引用类型一般是通过new关键字来创建，比如Integer num = new Integer(3);它存放在内存的堆中，可以在运行时动态的分配内存大小，生存期也不必事先告诉编译器，当引用类型变量不被使用时，Java内部的垃圾回收器GC会自动回收走。引用变量中存放的不是变量的内容，而是存放变量内容的地址。
在参数传递时，基本类型都是传值，也就是传递的都是原变量的值得拷贝，改变这个值不会改变原变量，而引用类型传递的是地址，也就是参数与原变量指向的是同一个地址，所以如果改变参数的值，原变量的值也会改变。这点要注意。
在java中，8种基本类型在java中都有对应的封装类型，也就是引用类型：
整数类型 Byte、Short、Integer、Long
浮点数类型 Float、Double
字符型 Character
布尔类型 Boolean
有时候我们会看到这样的语句 Integer num = 3;Boolean b = true;这样定义也能行得通，其实这里面有一个自动装箱的问题，即java自动把3这个字面常量封装成了Integer对象，同理也有自动拆箱。
还有些需要注意的比较特殊的地方：
1Integer类型
Integer i1 = 3;
Integer i2 = 3;
此时i1 == i2 返回的是true
Integer i1 = 128;
Integer i2 = 128;
此时i1 == i2返回的是false，
这时因为Integer的数值在-128～127之间时，即在int的范围内，默认是按照基本类型int来存放的，仍旧存在堆栈中，如果超出了int的范围，就按照对象的方式来存放和比较了。

2、String类型
String类型我们有时候也会直接这样定义：
String s = "abc";
这里的"abc"称为字符串常量，也是存在堆栈中的，s中存放的就是指向这个堆栈地址的引用，如果再定义一个
String s1 = "abc";
这时，s与s1存放的是同一个地址的引用，即s与s1指向的是同一个字符串常量，
s == s1的值是true，
但是如果有
String s2 = new String("abc");
这时s == s2则为false，因为使用new之后，每次生成的对象都不是同一个，即使存储的内容相同。
上面的s == s1，s == s2其实比较的都是地址，并不是里面的内容。如果要比较内容，可以使用equals()方法。
其他的就不多说了，打起来太慢了，可以自己去看一下java编程思想。

---