新手求教java中类型转换问题 谁可以介绍一JAVA里的类型转换
新手求教java中类型转换问题
类型转换主要在在 赋值、方法调用、算术运算 三种情况下发生。大概来说有两种：自动转换和强制转换。对于自动转换：
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；
（7）float可转换为double；
b、算术运算 中的类型转换：1 基本就是先转换为高位数据类型，再参加运算，结果也是最高位的数据类型；2 byte short char运算会转换为Int；
（1）如操作数之一为double，则另一个操作数先被转化为double，再参与算术运算。
（2）如两操作数均不为double，当操作数之一为float，则另一操作数先被转换为float，再参与运算。
（3）如两操作数均不为double或float，当操作数之一为long，、则另一操作数先被转换为long，再参与算术运算。
（4）如两操作数均不为double、float或long，则两操作数先被转换为int，再参与运算。
特殊：
（1）如采用 =、*=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。
(2) 当运算符为自动递增运算符（ ）或自动递减运算符（--）时，如果操作数为byte，short或char类型不发生改变
对于强制转换，参考该文章网页链接
谁可以介绍一JAVA里的类型转换？
Java语言是一种强类型的语言。强类型的语言有以下几个要求：
l 变量或常量必须有类型
要求声明变量或常量时必须声明类型，而且只能在声明以后才能使用。
l 赋值时类型必须一致
值的类型必须和变量或常量的类型完全一致。
l 运算时类型必须一致
参与运算的数据类型必须一致才能运算。
但是在实际的使用中，经常需要在不同类型的值之间进行操作，这就需要一种新的语法来适应这种需要，这个语法就是数据类型转换。
在数值处理这部分，计算机和现实的逻辑不太一样，对于现实来说，1和1.0没有什么区别，但是对于计算机来说，1是整数类型，而1.0是小数类型，其在内存中的存储方式以及占用的空间都不一样，所以类型转换在计算机内部是必须的。Java语言中的数据类型转换有两种：
l 自动类型转换
编译器自动完成类型转换，不需要在程序中编写代码。
l 强制类型转换
强制编译器进行类型转换，必须在程序中编写代码。
由于基本数据类型中boolean类型不是数字型，所以基本数据类型的转换是出了boolean类型以外的其它7种类型之间的转换。下面来具体介绍两种类型转换的规则、适用场合以及使用时需要注意的问题。
3.7.1 自动类型转换
自动类型转换，也称隐式类型转换，是指不需要书写代码，由系统自动完成的类型转换。由于实际开发中这样的类型转换很多，所以Java语言在设计时，没有为该操作设计语法，而是由JVM自动完成。
l 转换规则
从存储范围小的类型到存储范围大的类型。
具体规则为：
byte→short(char)→int→long→float→double
也就是说byte类型的变量可以自动转换为short类型，示例代码：
byte b = 10
short sh = b
这里在赋值时，JVM首先将b的值转换为short类型，然后再赋值给sh。
在类型转换时可以跳跃。示例代码：
byte b1 = 100
int n = b1
l 注意问题
在整数之间进行类型转换时，数值不发生改变，而将整数类型，特别是比较大的整数类型转换成小数类型时，由于存储方式不同，有可能存在数据精度的损失。
3.7.2 强制类型转换
强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。
l 转换规则
从存储范围大的类型到存储范围小的类型。
具体规则为：
double→float→long→int→short(char)→byte
语法格式为：
(转换到的类型)需要转换的值
示例代码：
double d = 3.10
int n = (int)d
这里将double类型的变量d强制转换成int类型，然后赋值给变量n。需要说明的是小数强制转换为整数，采用的是“去1法”，也就是无条件的舍弃小数点的所有数字，则以上转换出的结果是3。整数强制转换为整数时取数字的低位，例如int类型的变量转换为byte类型时，则只去int类型的低8位(也就是最后一个字节)的值。
示例代码：
int n = 123
byte b = (byte)n
int m = 1234
byte b1 = (byte)m
则b的值还是123，而b1的值为-46。b1的计算方法如下：m的值转换为二进制是10011010010，取该数字低8位的值作为b1的值，则b1的二进制值是11010010，按照机器数的规定，最高位是符号位，1代表负数，在计算机中负数存储的是补码，则该负数的原码是10101110，该值就是十进制的-46。
l 注意问题
强制类型转换通常都会存储精度的损失，所以使用时需要谨慎
java 数据类型转换
这是JAVA的自动拆包和解包。。
八种数据类型都有相对的包装类。
在JAVA 5以后就有自动实现拆装功能。。
所以当遇到Integer Integer会变成int int的样子
你的赋值也会实现自动转换的功能，
而不用.parseInt（）；
在java中什么是强制类型转换！
1 ) 整数 int 转换成字串 String , 有三种方法 :
String s = String.valueOf(i)
String s = Integer.toString(i)
String s = "" i
2 ) String 转 int
int i = Integer.parseInt([String])
i = Integer.parseInt([String],[int radix])
int i = Integer.valueOf(my_str).intValue()
3 ) 布尔类型 转 String
1. 第一种方法
boolean bool = true
String s = new Boolean(bool).toString()//将bool利用对象封装器转化为对象
2. 第二种方法
boolean bool = true
String s = String.valueOf( bool )
4 ) String 转 Date
1 . 导入 java.util.Date date=null
2 . date=java.sql.Date.valueOf(String s)
5 ) 数字类型间的转换
转型有两种: 向上转型和向下转型(强制转型)
两种分别如下:
第一种是向上转型
对于基础数据类型 , 可以自动转型 ,比如:
int a = 10
long b = a
这里就是把int型转成了long型 , 因为 long范围比int大 , 这样的转型不会有任何影响 , 所以可以自动转型
第二种是向下转型 , 也就是强制
这种需要强转 , 比如
long a = 10
int b = (int) a
通过 (int)可以强制转型 , 但是这样会丢失精度 , 比如a如果超过了b的范围 , 那么强转成int型, 只会等于int的最大值
又如 : int a = ( int ) 8.8
如果对编程感兴趣可以来我这个看看，希望对您有所帮助！~
简述java类型转换机制。
string和int之间的转换?
字符串转换成数据
Java代码
String MyNumber ="1234"
int MyInt = Integer.parseInt(MyNumber)
String MyNumber ="1234"
int MyInt = Integer.parseInt(MyNumber)
字符串转换成byte, short, int, float, double, long等数据类型，可以分别参考Byte, Short, Integer, Float, Double, Long类的parseXXX 方法。
Java代码
a1=Integer.parseInt(s1)
s1=Integer.toString(a1)
a1=Integer.parseInt(s1)
s1=Integer.toString(a1)
数据转换成字符串
Java代码
int MyInt = 1234
String MyString = "" MyInt
int MyInt = 1234
String MyString = "" MyInt
其它数据类型可以利用同样的方法转换成字符串。
十进制到其他进制的转换
十进制整数转换成二进制整数，返回结果是一个字符串：
Integer.toBinaryString(int i)
Integer和Long提供了toBinaryString, toHexString和toOctalString方法，可以方便的将数据转换成二进制、十六进制和八进制字符串。功能更加强大的是其 toString(int/long i, int radix)方法，可以将一个十进制数转换成任意进制的字符串形式。
byte, short, float和double等数据类型，可以利用Integer或者是Long的toBinaryString, toHexString, to OctalString和toString方法转换成其他进制的字符串形式。
其它进制到十进制的转换
五进制字符串14414转换成十进制整数，结果是1234：
System.out.println(Integer.valueOf("14414", 5)
Integer和Long提供的valueOf(String source, int radix)方法，可以
将任意进制的字符串转换成十进制数据。
把String类型转换成16进制的整数
Java代码
public static void main(String args[]){
String x = "0x300C8"
int y = Integer.decode(x).intvalue()
System.out.println(y)
}
public static void main(String args[]){
String x = "0x300C8"
int y = Integer.decode(x).intvalue()
System.out.println(y)
}
int、char、double与byte相互转换的程序
整数到字节数组的转换
Java代码
public static byte[] intToByte(int number) {
int temp = number
byte[] b=new byte[4]
for (int i=b.length-1i>-1i--){
b[i] = new Integer(temp&0xff).byteValue() //将最高位保存在最低位
temp = temp >> 8 //向右移8位
}
return b
}
public static byte[] intToByte(int number) {
int temp = number
byte[] b=new byte[4]
for (int i=b.length-1i>-1i--){
b[i] = new Integer(temp&0xff).byteValue() //将最高位保存在最低位
temp = temp >> 8 //向右移8位
}
return b
}
字节数组到整数的转换
Java代码
public static int byteToInt(byte[] b) {
int s = 0
for (int i = 0 i < 3 i ) {
if (b[i] >= 0)
s = s b[i]
else
s = s 256 b[i]
s = s * 256
}
if (b[3] >= 0) //最后一个之所以不乘，是因为可能会溢出
s = s b[3]
else
s = s 256 b[3]
return s
}
public static int byteToInt(byte[] b) {
int s = 0
for (int i = 0 i < 3 i ) {
if (b[i] >= 0)
s = s b[i]
else
s = s 256 b[i]
s = s * 256
}
if (b[3] >= 0) //最后一个之所以不乘，是因为可能会溢出
s = s b[3]
else
s = s 256 b[3]
return s
}
短整数与字节数组之间的相互转换
short与int之间的区别在于short是两个字节的，而int是四个字节的。因此，只需要将5 与6 中的范例程序小做改动，即可实现短整数与字节数组之间的相互转换。
字符到字节转换
Java代码
public static byte[] charToByte(char ch){
int temp=(int)ch
byte[] b=new byte[2]
for (int i=b.length-1i>-1i--){
b[i] = new Integer(temp&0xff).bytevalue() //将最高位保存在最低位
temp = temp >> 8 //向右移8位
}
Java中的强制类型转换,如果这2种类型是兼容的，那么Java 将自动地进行转换。例如，把int 类型的值赋给long 类型的变量，总是可行的。然而，不是所有的类型都是兼容的，因此，不是所有的类型转换都是可以隐式实现的。例如，没有将double 型转换为byte 型的定义。幸好，获得不兼容的类型之间的转换仍然是可能的。要达到这个目的，你必须使用一个强制类型转换，它能完成两个不兼容的类型之间的显式变换。让我们看看自动类型转换和强制类型转换。
一．Java 的自动转换
如果下列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("
Conversion of int to byte.")
b = (byte) i
System.out.println("i and b " i " " b)
System.out.println("
Conversion of double to int.")
i = (int) d
System.out.println("d and i " d " " i)
System.out.println("
Conversion 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
Conversion of double to byte.
d and b 323.142 67
让我们看看每一个类型转换。当值257被强制转换为byte 变量时，其结果是257除以256 （256是byte 类型的变化范围）的余数1。当把变量d转换为int 型，它的小数部分被舍弃了。当把变量d转换为byte 型，它的小数部分被舍弃了，而且它的值减少为256 的模，即67。
java 不同类型间转换
问题1：
这个说法是不准确的，应该是任何基本数据类型，因为String这个对象比较特殊，其实，它也是对char型的“封装”，char也可以说是整数型的变量，因为JAVA用的是UNICODE编码，类如，char c=97 跟char o=a,这两个是相等的，char c=97,int i=c这样语法也是对的，char的范围是0~255，对应的每个数值都有相应的字符，比如char c=98，则c=b,比如现在有个字符串String s="info",则对String的处理是这样的，java.lang.String 对象中的数据是一个字符数组，由管理和控制对字符数组的访问的
java.lang.String 对象封装。
所以当基本数据类型遇到String的时候，确切的讲是将其变为char型数组，然后交由String这个对象来管理和控制。所以也就是通常所说的“任何基本数据类型遇到String时，都会自动转换成String型”
问题2：
如1所言，只有基本数据类型才会自动转换为String，当数据类型是引用（类）或数组的时候，此时自动调用引用(类)或数组对象的继承自Object类的toString方法，如果没有覆写toString方法，则自动输出实例化对象的堆内存地址（当然这么说不一定准确，但是输出的一定是个内存地址）。
所以，你这两个问题归根到底就是一个问题。就是当遇到String类型的时候，基本数据类型（如，char，int，byte，short等）会转成String类型，引用（类）/数组会自动调用继承自Object类的toString方法，如果toString没有被覆写，则自动返回此实例化对象的堆内存地址。