datatruncation是什么意思_datafication

ja.sql.SQLException: #22007 Query怎么解决啊日期的转换

（2）如两作数均不为double，当作数之一为float，则另一作数先被转换为float，再参与运算。

ja.sql.SQLException错误！

datatruncation是什么意思_datafication

datatruncation是什么意思_datafication

Ja代码

ORA-00904: --invalid column name 无效列名

ORA-00942: --table or view does not exist 表或者视图不存在

ORA-01400: --cannot insert NULL into () 不能将空值插入

ORA-00936:--缺少表达式

ORA-00933:--SQL 命令未正确结束

ORA-01722:--无效数字：（一般可能是企图将字符串类型的值填入数字型而造成）

org.hibernate.exception.DataException: Out of range value for column 'id' at row 1

这个系统会抛出ClassCastException异常信息。

如题：错误并不是因为字段过长而导致出错的,

1. 可能是因为数据库里的表设置的字符集不相同。

2. 也可能真是数据库字段里数据库确实过长(我是遇到的这种情况)。

例如：在同一个数据库中，存在utf8的表，也存在gbk_chinese_ci的表。

解决办法：alter table `cms_activity_test` convert to character set gbk collate gbk_chinese_ci;(单独修改指定表的字符集)

补充：通过在网上查找资料，一般都是修改数据库Mysql的默认字符集Conversion of double to byte.和修改单个数据库的字符集

C语言这段truncation什么意思

"构造方法RandomAccessFile(File file,String mode)中的参数mode表示()" A.?读流的方法 B.?写流的方法 C.?读/写流的方法 D.?流的打开方式 D

截断、截断的意思。在C/C++中，将一个超出某类型范围的整数赋给这个类型的变量时，将自动从右端开始截取这个变量能承载的长度赋值。比如，char a=321;，执行后a值是65。因为a的取值范围是-128~127，321(101000001)被从右端起截取了8位(1字节)赋给了a，e printStackTrace();而01000001刚好是十进制数65。

ja中的强制类型转换

方式一：捕获处理

用(String)做强制类型转换和用String.valueOf()区别在于：

1、定义两个字节数据类型a、b、c，分别赋予1和2和a+b的值，进行加法运算的式子a+b=3，得出的结果“3”将会被编译环境判定为整形数据，把这个整形数据赋值给c，系统将会报错，这样就需要用到格式为“目标数据类型 变量 = (目标数据类型) 数据；”的强制转换语句。

String 就是直接强制转化成String型的字符串，且有优先级限制，像int i=123;不能String s=(String)i。

而String.valueOf()里面的参数转换可以是double、long、char[] 、long等等，没限制，所以String s=String.valueOf(i)。

toString()方法返回的是这个对象的字符串表示，就像是这个对象的名字一样，任何对象都可以有自己的名字，你可以重写其toString()方法，给其赋予任意的名字。

但是调用toString()方法的对象不能为 null，否则会抛出异常：ja.lang.NullPointerException。

例子如下：

扩展资料：

ja中强制类型转换

在Ja中强制类型转换分为基本数据类型和引用数据类型两种，这里我们讨论的后者，也就是引用数据类型的强制类型转换。

在Ja中由于继承和向上转型，子类可以非常自然地转换成父类，但是父类转换成子类则需要强制转换。

因为子类拥有比父类更多的属性、更强的功能，所以父类转换为子类需要强制。那么，是不是只要是父类转换为子类就会成功呢？其实不然，他们之间的强制类型转换是有条件的。

当我们用一个类型的构造器构造出一个对象时，这个对象的类型就已经确定的，也就说它的本质是不会再发生变化了。

举个例子来说明。比如系统中存在Father、Son两个对象。首先我们先构造一个Son对象，然后用一个Father类型变量引用它：

Father father = new Son();

在这里Son 对象实例被向上转型为father了，但是请注意这个Son对象实例在内存中的本质还是Son类型的，只不过它的能力临时被消弱了而已，如果我们想变强怎么办？将其对象类型还原！

Son son = (Son)father;

这条语句是可行的，其实father引用仍然是Father类型的，只不过是将它的能力加强了，将其加强后转交给son引用了，Son对象实例在son的变量的引用下，恢复真身，可以使用全部功能了。

前面提到父类强制转换成子类并不是总是成功，那么在什么情况下它会失效呢？

当引用类型的是父类本身的类型时，强制类型转换就会产生错误。例如：

Father father = new Father();

Son son = (Son) father;

所以编译器在编译时只会检查类型之间是否存在继承关系，有则通过；而在运行时就会检查它的真实类型，是则通过，否则抛出ClassCastException异常。

所以在继承中，子类可以自动转型为父类，但是父类强制转换为子类时只有当引用类型真正的身份为子类时才会强制转换成功，否则失败

Ja中的强制类型转换的转换方式如下：

当用一个类型的构造器构造出一个对象时，这个对象的类型就已经确定的，也就说它的本质是不会再发生变化了。

在Ja中可以通过继承、向上转型的关系使用父类类型来引用它，这个时候是使用功能较弱的类型引用功能较强的对象。但是将功能较弱的类型强制转功能较强的对象时，就不一定可以行了。

扩展资料：

在Ja项目的实际开发和应用中，常常需要用到将对象转为String这一基本功能。常用的转换方法有Object.toString()，（String）要转换的对象，String.valueOf(Object)等。

强制类型转换具有两种形式：显式强制转换和隐式强制类型转换。

强制类型转换是把父类型转换为子类型。因为子类型比父类型的内涵要丰富，无非就是属性更多功能更强，所以要把父类型转换为子类型，需要强制。

比如：

long a = 10 ;

int b = (int) a。

通过 (int)可以强制转型 , 但是这样会丢失精度 , 比如a如果超过了b的范围 , 那么强转成int型, 只会等于int的值。

参考资料来源：

强制类型转换有两种，转换方法如下（都需要使用C语言）：

1、显式强制类型转换：

TYPE b = (TYPE) a；其中，TYPE为类型描述符，如int，float等。经强制类型转换运算符运算后，返回一个具有TYPE类型的数值，这种强制类型转换作并不改变作数本身，运算后作数本身未改变，例如：

int n=0xab65；

char a=（char）n；

2、隐式强制类型转换：

隐式类型转换发生在赋值表达式和有返回值的函数调用表达式中。在赋值表达式中，如果赋值符左右两侧的作数类型不同，则将赋值符右边作数强制转换为赋值符左侧的类型数值后，赋值给赋值符左侧的变量。如：

int n；

double d=3.88；

n=d；//执行本句后，n的值为3，而d的值仍是3.88。

扩展资料：

类型转换遵循以下规则：

1、若参与运算量的类型不同，则先转换成同一类型，然后进行运算。

2、转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。

a、若两种类型的字节数不同，转换成字节数高的类型。

b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型。

3、所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。

4、char型和short型（在visual c++等环境下）参与运算时，必须先转换成int型。

5、在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分直接舍去。

C++语言编译系统提供的内部数据类型的隐式自动转换规则如下：

1、执行算术运算时，低类型(短字节)可以转换为高类型(长字节)；例如： int型转换成double型，char型转换成int型等等；

3、函数调用时，将实参的值传递给形参，系统首先会自动隐式地把实参的值的类型转换为形参的类型，然后再赋值给形参；

4、函数有返回值时，系统首先会自动隐式地将返回表达式的值的类型转换为函数的返回类型，然后再赋值给调用函数返回；

参考资料：

强制类型转换分两种形式：

1. 显式强制类型转换 ：

C中显式强制类型转换很简单，格式如下： TYPE b = (TYPE) a， 其中，TYPE为类型描述符，如int，float等。

经强制类型转换运算符运算后，返回一个具有TYPE类型的数值，这种强制类型转换作并不改变作数本身，运算后作数本身未改变。

2.隐式强制类型转换：

隐式类型转换发生在赋值表达式和有返回值的函数调用表达式中。

在赋值表达式中，如果赋值符左右两侧的作数类型不同，则将赋值符右边作数强制转换为赋值符左侧的类型数值后，赋值给赋值符左侧的变量。

在函数调用时，如果return后面表达式的类型与函数返回值类型不同，则在返回值时将return后面表达式的数值强制转换为函数返回值类型后，再将值返回。

扩展资料：

强制类型转换规则、格式、注意事项及异常处理：

1.转换规则：

从存储范围大的类型到存储范围小的类型。

具体规则为：

double→float→long→int→short(char)→byte

2.语法格式为：

(转换到的类型)需要转换的值

示例代码：

double d = 3.10;

int n = (int)d;

3.注意问题：

4.异常处理：

try{可能发生异常的代码；}catch(捕获的异常类型 变量名){处理异常的代码.... }

捕获处理要注意的细节：

（1） 如果try块中代码出了异常经过了处理之后，那么try-catch块外面的代码可以正常执行。

（2）如果try块中出了异常的代码，那么在try块中出现异常代码后面的代码是不会执行了。

（3） 一个try块后面是可以跟有多个catch块的，也就是一个try块可以捕获多种异常的类型。

（4） 一个try块可以捕获多种异常的类型,但是捕获的异常类型必须从小到大进行捕获，否则编译报错。

方式二：抛出处理

抛出处理要注意的细节：

（1）如果一个方法的内部抛出了一个异常 对象，那么必须要在方法上声明抛出。

（2）如果调用了一个声明抛出异常 的方法，那么调用者必须要处理异常。

（3）如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行了（一个方法遇到了throw关键字，该方法也会马上停止执行的）。

（4） 在一种情况下，只能抛出一种类型异常对象。

参考资料：

强制类型转换分两种形式：

1. 显式强制类型转换 ：

C中显式强制类型转换很简单，格式如下： TYPE b = (TYPE) a， 其中，TYPE为类型描述符，如int，float等。

经强制类型转换运算符运算后，返回一个具有TYPE类型的数值，这种强制类型转换作并不改变作数本身，运算后作数本身未改变。

2.隐式强制类型转换：

隐式类型转换发生在赋值表达式和有返回值的函数调用表达式中。

在赋值表达式中，如果赋值符左右两侧的作数类型不同，则将赋值符右边作数强制转换为赋值符左侧的类型数值后，赋值给赋值符左侧的变量。

在函数调用时，如果return后面表达式的类型与函数返回值类型不同，则在返回值时将return后面表达式的数值强制转换为函数返回值类型后，再将值返回。

扩展资料：

内部数据类型的隐式自动转换规则如下：

1、执行算术运算时，低类型(短字节)可以转换为高类型(长字节)；例如： int型转换成double型，char型转换成int型等等；

3、函数调用时，将实参的值传递给形参，系统首先会自动隐式地把实参的值的类型转换为形参的类型，然后再赋值给形参；

4、函数有返回值时，系统首先会自动隐式地将返回表达式的值的类型转换为函数的返回类型，然后再赋值给调用函数返回；

参考资料：

ja中数据类型的强制转换是通过强制转换语句完成的，强制转换语句的格式为“目标数据类型 变量 = (目标数据类型) 数据；”。下面给出例子：

2、根据强制转换语句的格式，易得“byte c = （byte）（a+b）;”；

3、这样就把整形数据的“3”赋值给字节数据类型的c了，其中完成数据的强制类型转换。

扩展资料：

基本类型 转换原则：

1、类型转换主要在在 赋值、方法调用、算术运算 三种情况下发生。

a、赋值和方法调用 转换规则：从低位类型到高位类型自动转换；从高位类型到低位类型需要强制类型转换：

（1）布尔型和其它基本数据类型之间不能相互转换；

（2）byte型可以转换为short、int、、long、float和double；

（3）short可转换为int、long、float和double；

（4）char可转换为int、long、float和double；

（5）int可转换为long、float和double；

（6）long可转换为float和double；

b、算术运算 中的类型转换：

1、基本就是先转换为高位数据类型，再参加运算，结果也是位的数据类型；

2、byte short char运算会转换为Int；

（1）如作数之一为double，则另一个作数先被转化为double，再参与算术运算。

（4）如两作数均不为double、float或long，则两作数先被转换为int，再参与运算。

特殊：

（1）如采用+=、=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。

(2) 当运算符为自动递增运算符（++）或自动递减运算符（--）时，如果作数为byte，short或char类型不发生改变；

参考资料：

一．Ja 的自动转换

如果下列2个条件都能满足，那么将一种类型的数据赋给另外一种类型变量时，将执行自动类型转换（automatic type conversion）：

1．这2种类型是兼容的。

2．目的类型数的范围比来源类型的大。

当以上2个条件都满足时，拓宽转换（widening conversion ）发生。例如，int 型的范围比所有byte 型的合法范围大，因此不要求显式强制类型转换语句。

对于拓宽转换，数字类型，包括整数（integer ）和浮点（floating-point ）类型都是彼此兼容的，但是，数字类型和字符类型（char）或布尔类型（bollean ）是不兼容的。字符类型（char ）和布尔类型（bollean ）也是互相不兼容的。

二． 不兼容类型的强制转换

尽管自动类型转换是很有帮助的，但并不能满足所有的编程需要。例如，如果你需要将int 型的值赋给一个byte 型的变量，你将怎么办？这种转换不会自动进行，因为byte 型的变化范围比int 型的要小。这种转换有时称为“缩小转换”（），因为你肯定要将源数据类型的值变小才能适合目标数据类型。

为了完成两种不兼容类型之间的转换，你就必须进行强制类型转换。所谓强制类型转换只不过是一种显式的类型变换。它的通用格式如下：

(target-type)value

其中，目标类型（target-type ）指定了要将指定值转换成的类型。例如，下面的程序段将int 型强制转换成byte 型。如果整数的值超出了byte 型的取值范围，它的值将会因为对byte 型值域取模（整数除以byte 得到的余数）而减少。

int a;

byte b;

// ...

b = (byte) a;

当把浮点值赋给整数类型时一种不同的类型转换发生了：截断（truncation ）。你知道整数没有小数部分。这样，当把浮点值赋给整数类型时，它的小数部分会被舍去。例如，如果将值1.23赋给一个整数，其结果值只是1，0.23 被丢弃了。当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为对目标类型值域取模而减少。

下面的程序说明了强制类型转换：

// Demonstrate casts.

class Conversion {

public static void main(String args[]) {

byte b;

int i = 257;

double d = 323.142;

System.out.println("nConversion of int to byte.");

b = (byte) i;

System.out.println("i and b " + i + " " + b);

System.out.println("nConversion of double to int.");

i = (int) d;

System.out.println("d and i " + d + " " + i);

System.out.println("nConversion of double to byte.");

b = (byte) d;

System.out.println("d and b " + d + " " + b);

}}

该程序的输出如下：

Conversion of int to byte.

i and b 257 1

Conversion of double to int.

d and i 323.142 323

d and b 323.142 67

让我们看看每一个类型转换。当值257被强制转换为byte 变量时，其结果是257除以256 （256是byte 类型的变化范围）的余数1。当把变量d转换为int 型，它的小数部分被舍弃了。当把变量d转换为byte 型，它的小数部分被舍弃了，而且它的值减少为256 的模，即67。

String 就是直接强制转化成String型的字符串，且有优先级限制，像int i=123;不能String s=(String)i。而String.valueOf()里面的参数转换可以是double、long、char[] 、long等等，没限制，所以String s=String.valueOf(i)。

比如valueOf(char[] data)

返回 char 数组参数的字符串表示形式。

valueOf(double d)

返回 double 参数的字符串表示形式。

valueOf(int i)

返回 int 参数的字符串表示形式。

valueOf(Object obj)

返回 Object 参数的字符串表示形式。等等

Ja的强制类型转换，可以分成编译和运行两个阶段来分析。

1、编译期间：

被转型变量的编译时类型与目标类型相同；

被转型变量的编译时类型是目标类型的父类；

被转型变量的编译时类型是目标类型的子类，这种情况是自动向上转换。

2、运行期间：

被转型变量所引用的对象的实际类型必须是目标类型的实例，或者是目标类型的子类，实现类的实力，否则运行时将引发ClassCastException异常。

扩展资料：

强制转换是还需要注意一次额问题：

无继承关系的引用类型间的转换是非法的，编译时会出错;

并不是任意的父类类型数据都可以被造型为子类类型，在造型前可以使用 instanceof 作符测试一个对象的类型，以避免运行是出错。

参考资料：

hibernate级联删除

有两张表 结构如下

t_ t_bid

id int id int

name varchar name varchar

_id int

其中表t_的主键id是表t_bid的_id字段的外键 那么在这种情况下 如果删除表t_中的记录 并且该记录中的id主键被t_bid中的_id字段所引用 就会抛出如下异常

ERROR ( ): Cannot delete or update a parent row: a foreign key constraint fails (`test/t_bid` CONSTRAINT `fk_id` FOREIGN KEY (`id`) REFERENCES `t_

` (`id`))2、赋值表达式中，等号右边表达式的值的类型自动隐式地转换为左边变量的类型，并赋值给它；

解决方法 级联删除 即在删除t_表中的记录时同时删除t_bid表中的相关记录

( ) 增加外键约束时声明级联删除 即

alter table t_bid add constraint fk_id foreign key(id) references

key(id) on delete cascade

( ) 使用触发器 在删除t_表中记录之前先删除与之相关的t_bid表中的记录

触发器代码（MySQL）

delimiter //

create trigger tri_delete before delete on t_

for each row

begin

end //

Hibernate中的解决方案

这个问题在Hibernate中相对容易解决 只需设置cascade = delete 即可 此时观察发出的sql语句

Hibernate: select _ id as id _ _ _ name as name _ _ from t_ _ where _ id=?

Hibernate: select em_id as _ _ bids _ id as id _ bids _ id as id _ _ bids _ pr as pr _ _ em_id as _ _ _ from t_bid bids _ where em_id=?

Hibernate: update t_bid set _id=null where _id=?

Hibernate: delete from t_bid where id=?

Hibernate: delete from t_bid where id=?

Hibernate: delete from t_ where id=?

发现在删除t_bid表中记录之前会先将它的_id字段值设置为null 但如果我们在映射文件中设置_id字段不能为null 即设置Bid hbm xml文件为 Ja代码

注意不能在Item hbm xml文件中进行如下设置(即在key元素中指定not null= true )

这样会抛出 Repeated column in mapping for entity 异常

如果我们指定_id字段值不能为null 那么在删除时会抛出如下异常

hibernate exception GenericJDBCException: Could not execute JDBC batch update···

Caused by: ja sql BatchUpdateException: Data truncation: Column set to default value; NULL supplied to NOT NULL column _id at row

???

此时的解决方法是设置inverse= true 这在Hibernate文档中有相应的描述 Ja代码

Very Important Note: If the co捕获处理的格式：lumn of a association is declared NOT NULL Hibernate may cause constraint violations when it creates or updates the association To prnt this problem you must use a bidirectional association with the many valued end (the set or bag) marked as inverse= true

观察此时发出的sql语句

Hibernate: select _ id as id _ _ _ name as name _ _ from t_ _ where _ id=?

Hibernate: select em_id as _ _ bids _ id as id _ bids _ id as id _ _ bids _ amount as amount _ _ em_id as _ _ _ from t_bid bids _ where em_id=?

Hibernate: delete from t_bid where id=?

Hibernate: delete from t_bid where id=?

Hibernate: delete from t_ where id=?

没有发出update语句 关于inverse= true 的理解

se update: 级联保存(load以后如果子对象发生了更新 也会级联更新) 但它不会级联删除

delete: 级联删除 但不具备级联保存和更新

all delete orphan: 在解除父子关系时 自动删除不属于父对象的子对象 也支持级联删除和级联保存更新

all: 级联删除 级联更新 但解除父子关系时不会自动删除子对象

delete orphan:删除所有和当前对象解除关联关系的对象

注意 以上设在哪一段就是指对哪一端的作而言 比如delete 如果设在one的一端的属性里 就是当one被删除的时候 自动删除所有的子记录

如果设在many一端的标签里 就是在删除many一端的数据时 会试图删除one一端的数据 如果仍然有many外键引用one 就会报 存在子记录 的错误 如果在one的一端同时也设置了cascade＝ delete 属性 就会发生很危险的情况 删除many一端的一条记录 会试图级联删除对应的one端记录 因为one也设置了级联删除many 所以其他所有与one关联的many都会被删掉

所以 千万谨慎在many一端设置cascade＝ delete 属性

故此cascade一般用在和中

one to many中设置级联删除 比如:

[x]

name= entryvalues

lazy= false

inverse= true

order by= VALUEID

cascade= all delete orphan

>

class= Entryvalue

/>

如果用Hiberante的SchemaExport导出表到数据库 是不会在数据库中设置外键的cascade属性的 查看ENTRYVALUE表 其中的外键CONTEXTENTRYID的on delete属性是no action

但是使用Hiberante管理事务 它是会维护这种级联关系的 比如这样作:

[ja]

public void testCascadeDelete() {

Session s = HibernateUtil getSession();

Transaction tx;

tx = s beginTransaction();

Contextentry ce = (Contextentry)s load(Contextentry class new Long( ));

s delete(ce);

} catch (HibernateException e) {

}}

则引用此Contextentry的Entryvalue是会被正确级联删除的

[ja]

public void testCascadeDeleteSQL() {

Session s = HibernateUtil getSession();

Transaction tx;

String sql = delete contextentry where id= ;

tx = s beginTransaction();

Connection con = nnection();

Statement st = con createStatement();

st execute(sql);

} catch (HibernateException e) {

} catch (SQLException e) {

}}

则会报 存在子记录 的错误 这里的Transaction实际上是无效的 因为用的是JDBC的Connection和Statement 已经脱离了Hibernate的管理 如果手动将ENTRYVALUE表的相关外键ON DELETE属性设为CASCADE 则上面的作当然正确执行——级联删除子记录

all delete－orphan 的能力

当保存或更新父方对象时 级联保存或更新所有关联的子方对象 相当于 cascade 为 se update

当删除父方对象时 级联删除所有关联的子方对象 相当于 cascade 为 delete

删除不再和父方对象关联的所有子方对象 当然 不再和父方对象关联的所有子方对象 必须是在本次事务中发生的

解除父子关系的 ja 语句例如

[ja]

public void testCascadeDelete() {

Session s = HibernateUtil getSession();

Transaction tx;

tx = s beginTransaction();

Contextentry ce = (Contextentry)s load(Contextentry class new Long( ));

Entryvalue ev = (Entryvalue)s load(Entryvalue class new Long( ));

ev setContextentry(null);

s delete(ce);

} catch (HibernateException e) {

}}

如果 cascade 属性取默认值 null 当解除父子关系时 会执行如下 sql

update ENTRYVALUE set CONTEXTENTRYID=null where ID=

lishixinzhi/Article/program/Ja/ky/201311/28140

往数据库插入时间

mit();

一般有两种访问： 方法一： $sql="INSERT INTO `test` (`id`,`content`,`datetime`)values(NULL,'hello',now())"; $query=mysql_query($sql); //执行sql语句 //这种方法，你datetime字段要设计成date类型，now() 是mysql数据库提供的一个获取当前时间函数 方法二： $sql="INSERT INTO `test` (`id`,`content`,`datetime`)values(NULL,'hello',".time().")"; $query=mysql_query($sql); //执行sql语句 //这种方法：datetime字段设计成int(10)类型。time()是php提供获取时间戳的函数。 使用方法二，因为这种方式，一.排序速度快，二.方便转换时间区。主流的开源程序都有采用这方式。像discuz phpwind dedecms等等。

// TODO Auto generated catch block

哪有ja代码编程的练习题带的那种？

（7）float可转换为double；

基于UDP通信，可用类创建一个对象表delete from t_bid where id = old id;示一个发送数据包，这个类是() A.?DataSocket B.?DatagramSocket C.?DataPacket D.?DatagramPacket D

基于UDP通信，在创建了发送数据包的对象后，如果想获得数据包的目标端口号，可调用方法() A.?getTargetPort() B.?getPort() C.?getTargetName() D.?getName() B

基于UDP通信，在创建了发送数据包的对象后，如果想获得数据包的目标地址，可调用方法() A.?getIP() B.?getPort() C.?getAddress() D.?getName() C

如果想发送数据包，还必须创建一个有多个参数的DatagramSocket的对象负责发送数据包，这个参数的个数() A.?0 B.?1 C.?2 D.?3 A

基于UDP通信，可用类的对象表示一个接收数据包，这个类是() A.?DataSocket B.?DatagramSocket C.?DataPacket D.?DatagramPacket D

基于UDP通信，接收数据包的端口号应() A.?0~65535 B.?0~1023 C.?1024~65535 D.?与发送数据包的端口号相同 D

基于UDP通信，一个接收数据包应调用方法接收数据包的是() A.?connect() B.?receive() C.?accept() D.?get() B

如果要接收一个数据包，必须先准备一个数据包用于接收，这个准备接收数据的数据包应是一个类的对象，这个类是() A.?DatagramSocket B.?DatagramPacket C.?DataSocket D.?DataPacket B

一个Applet程序，如果要从网络上加载一个图像，应使用方法() A.?getGraphics() B.?getSource() C.?getImage() D.?play() C

"要显示一幅图像,()" A.?直接将介质上的图像显示在屏幕上 B.?先读入内存，在显示在屏幕上 C.?将图像读入内存即可 D.?给出图像文件的文件名即可 B

在Applet程序中，如果想获得当前Applet程序的地址，应调用方法() A.?getAddress() B.?getIP() C.?getCodeBase() D.?getDocument() C

图像被加载，输出图像使用的方法是() A.?drawImage() B.?displayImage() C.?printImage() D.?pasteImage() A

屏幕上显示的图像，() A.?必须和实际图像大小一致 B.?在x方向可发生变化 C.?在y方向可发生变化 D.?可以和实际的图像大小不一致 D

"调用方法drawImage(Image img,int x,int y,int width,int height)，显示的图像按比例自动调整，此比例为()" A.?width/height B.?width/img.getWidth() C.?height/img.getHeight() D.?x方向width/img.getWidth()，y方向height/img.getHeight() D

在一个图形方式的Application程序中，() A.?可以直接在窗口中显示一幅图像 B.?可以在窗口中添加一个Canvas组件，在这个组件上显示一幅图像 C.?另外建立一个可以显示图像的窗口 D.?Application程序不能显示图像 B

在图形方式的Application中，要获取一幅图像，必须先得到一个类的对象，这个类是() A.?Image B.?ToolKit C.?Frame D.?Cas B

在图形方式的Application中，要设置窗口的图标，应调用方法() A.?drawImage() B.?drawIcon() C.?drawIconImage() D.?setIconImage() D

JDBC() A.?能与数据库建立连接 B.?能向数据库发送SQL语句 C.?能返回对数据库的处理结果 "D.?能完成上述A,B,C" D

JDBC和数据连接的一种方式是先建立一个桥接器，这个桥是() A.?JDBC B.?ODBC C.?JDBC-ODBC D.?SQL C

要与一个数据库进行连接，首先配置一个数据源是() A.?ODBC B.?JDB C.?ODBC-JDBC D.?Excel A

建立一个数据库桥接器，应使用Class类中的方法是() A.?forName() B.?getClasses() C.?getIntece() D.?getMods() A

建立桥接器时，可能会发生异常的是() A.?FileNotFoundException B.?ClassNotFoundException C.?ClassCastException D.?RuntimeException B

JDBC建立数据库连接时，应使用类DriverMar中的静态方法创建一个Conection对象，这个方法是() A.?getDriver() B.?getLogStream() C.?registerDriver() D.?getConnection() D

JDBC和数据库连接时，可能会产生异常的是() A.?IOException B.?NoSuchFieldException C.?SecurityException D.?SQLException D

JDBC中向数据库发送SQL语句，首先应创建一个类的SQL语句对象，这个类是() A.?Statement B.?Driver C.?PreparedStatement D.?Connection A

JDBC中创建SQL语句对象可能产生例外的是() A.?IOException B.?DataTruncation C.?SQLException D.?SQLWaring C

JDBC中执行一条SQL语句应调用方法() A.?sendQuery() B.?sendSQL() C.?executeQuery() D.?executeSQL() C

JDBC中，一条语句的执行结果放在一个类的对象中，这个类是() A.?ResultSetMetaData B.?ResultSet C.?DatabaseMetaData D.?Driver B

要在Applet程序中播放声音文件，获得一个AudioClip的对象，应调用的方法是() A.?getAppletInfo() B.?getAudioClip() C.?getDocumentBase() D.?getImage() B

要播放一个音频对象表示的音频文件，应调用的方法是() A.?stop() B.?start() C.?init() D.?play() D

用Vector创建了一个对象后，该向量() A.?大小不可改变 B.?根据使用要求，大小可以改变 C.?只能表示一个平面向量 D.?只能表示一个三维向量 B

向量中的元素不能是() A.?Object类的对象 B.?Integer类的对象 C.?String类的对象 D.?基本数据类型的数据 D

往一个向量类对象中加一个元素的方法public void add(Object obj)，其中参数obj表示() A.?所增加的元素只能是一个Object类的对象 B. 一个Class类的对象 C.?一个Process类的对象 D.?任何类的对象 D

向量类Vector中的方法的参数和方法的类型大多数为Object类型，是因为() A.?Object类是所有类的基类 B.?Object类包含所有类的属性和方法 C.?向量类中的元素只能为Object类的对象 D.?Object类是所有类的子类，能表示任何父类对象 A

使用JDK开发Ja程序时，编译一个源文件使用的命令是() A.?jac B.?ja C.?appletviewer D.?jap A

使用JDK开发Ja程序时，如果要解释一个Application程序，须使用命令() A.?jac B.?ja C.?appletviewer D.?jap B

使用JDK开发Ja Applet程序时，如果想看一下该程序的运行结果，使用命令() A.?jac B.?ja C.?appletviewer D.?jap C

InputStream类或Reader类的子类是所有的() A.?输入流 B.?输出流 C.?输入/输出流 D.?Ja通信类 A

OutputStream类或Writer类的子类是所有的() A.?输入流 B.?输出流 C.?输入/输出流 D.?Ja通信类 B

当构造一个输入流的对象时，可能产生异常的是() A.?InterruptedException B.?NoSuchFieldException C.?RuntimeException D.?FileNotFoundException D

构造一个输入流的对象时，可用一个类的对象作为构造方法的参数，这个类是() A.?FileReader B.?FileWriter C.?Inputstream D.?File D

一个输入流的对象用int read()方法从流中读数据时，该方法的返回值() A.?一个字符 B.?在0~255之间 C.?一行字符 D.?在0~65535之间 B

从一个FileInputStream流中用read方法读数据时，表示流结束，则该方法返回() A.?-1 B.?0 C.?255 D.?65535 A

当对一个流作完毕时，可以保证作系统将缓冲区中的数据写入到目的地，应调用方法() A.?ailable() B.?pack() C.?skip() D.?close() D

类RandomAccessFile不同于其它的I/O流，该流的对象() A.?只读 B.?只写 C.?读和写 D.?不能单独读写流，只有和其它流连接才能读写 C

将一个RandomAccessFile对象中的文件指针移动到文件中的一个确定位置，应调用方法() A.?skipBytes() B.?seek() C.?moveBytes() D.?seekBytes() B

PipedInputStream()构造的一个管道输入流，与另一个管道输入流连接，应调用方法() A.?connect() B.?receive() C.?read() D.?link() A

构造方法PipedOutputStream(PipedInputStream in)生成的输出流，() A.?须调用方法与另一个管道输入流连接 B.?已经与一个管道输入流in连接 C.?应连接到一个文件输入流 D.?应连接到一个文件输出流 B

构造方法PipedInputStream()或PipedOutputStream()创建对象时，() A.?可能产生IOException异常 B.?可能产生FileNotFoundException异常 C.?可能产生NotActiveException异常 D.?不可能产生异常 D

DataInputStream与DataOutputStream的特点() A.?读写数据时与具体的机器无关 B.?读写数据时与具体的机器有关 C.?读数据时与机器有关，而写数据时与机器无关 D.?读数据时与机器无关，而写数据时与机器有关 A

对象流可以将一个数据从流中读出，也可以写入流中，这个数据是() A.?整型数 B.?字符 C.?浮点数 D.?对象 D

如果一个用户自定义的类以对象为单位进行读写时，该类定义时应实现一个接口() A.?DataInput B.?DataOutput C.?ObjectOutput D.?Serializable D

用PushbackInputStream类定义的流，() A.?可将读出的所有字节退回到流中 B.?可将指定字节数退回到流中 C.?可将刚读出的字节退回到流中 D.?每读一个字节就自动退回一个字节到流中 D? ?

hibernate怎么插入时间？数据库时间类型是datetime，实体时间是ja.util.Date，映射文件没写类型属性

如果使用普通JDBC作 比如:

你好

hJa代码bm 中设定

FreeMarker template error!

（3）如两作数均不为double或float，当作数之一为long，、则另一作数先被转换为long，再参与try {算术运算。

字段太长 Data truncation: Data too long for column 'sText' at row 1 到数据库里面把 sText 的数据长度改大一点

满意请采纳。

String data right truncation 异常是怎么产生的

在Ja中我们可以通如果这2种类型是兼容的，那么Ja 将自动地进行转换。例如，把int 类型的值赋给long 类型的变量，总是可行的。然而，不是所有的类型都是兼容的，因此，不是所有的类型转换都是可以隐式实现的。例如，没有将double 型转换为byte 型的定义。幸好，获得不兼容的类型之间的转换仍然是可能的。要达到这个目的，你必须使用一个强制类型转换，它能完成两个不兼容的类型之间的显式变换。让我们看看自动类型转换和强制类型转换。过继承、向上转型的关系使用父类类型来引用它，这个时候我们是使用功能较弱的类型引用功能较强的对象，这是可行的。但是将功能较弱的类型强制转功能较强的对象时，就不一定可以行了。

日志里面报一个这样的错误

String data, right truncation

c++执行一个带有select语句的存储过程

看起来是数据库的，但是有别于那种带[]的错误，然后直接运行存储过程不能再现

只有用c++代码运行存储过程才能再现。

调查后发现，原因是这个select语句返回的长度和c++为了取结果声明的数组长度有距

c++的数组小了，才会这样

把存储过程处理一下，截取和c++代码等长的就好了

State = CONVERT(NCHAR(2), pa.State),