Java类型转换

1. 隐式转换（自动类型转换）

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

• 两种数据类型彼此兼容
• 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）

这个时候进行的转换也叫拓宽转换（widening conversion）

• 数值型数据的转换：byte→short→int→long→float→double
• 字符型转换为整型：char→int

① 自定转换就是隐式转换，只能是小转大不能大转小

byte b;int i=b; long l=b; float f=b; double d=b;//可以通过
float a; int i = a;//不能通过，要强制转换 

② 如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c'; int i=c;
System.out.println("output:"+i);//输出：output:99;

③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换

short i=99 ; 
char c=(char)i; 
System.out.println("output:"+c);//输出：output:c;

2. 显示类型转换

所以当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换。

2.1 基本类型的强制转换

对基本类型而言，目标类型的取值范围小于源类型时要强转

int a = 3;
double b = 5.0;
a = (int)b;

在强制类型转换中，如果是将浮点类型的值转换为整数，直接去掉小数点后边的所有数字；而如果是整数类型强制转换为浮点类型时，将在小数点后面补零。

如果想对浮点数进行舍人运算， 以便得到最接近的整数（在很多情况下， 这种操作更有 用)，那就需要使用 Math_round 方法

double x z 9.997; 
int nx = (int) Math.round(x);

现在， 变量 nx 的值为 10。 当调用 round 的时候， 仍然需要使用强制类型转换（int)。其原因 是 round 方法返回的结果为 long 类型，由于存在信息丢失的可能性，所以只有使用显式的强 制类型转换才能够将 long 类型转换成 int 类型

如果试图将一个数值从一种类型强制转换为另一种类型， 而又超出了目标类型的 表示范围，结果就会截断成一个完全不同的值
例如，（byte) 300 的实际值为 44

对于结合赋值和运算符的情况
如果运算符得到一个值， 其类型与左侧操作数的类型不同， 就会发生强制类型转 换。 例如，如果 x 是一个 int

x += 3.5; 

是合法的， 将把 x设置为（int)(x+ 3.5)。

2.2 对于对象的强制转换

正像有时候需要将浮点型数值转换成整型数值一样，有时候也可能需要将某个类的对象 引用转换成另外一个类的对象引用

进行类型转换的唯一原因是：在暂时忽视对象的实际类型之后，使用对象的全部功能

将一个值存人变量时， 编译器将检查是否允许该操作。将一个子类的引用赋给一个超类 变量， 编译器是允许的。但将一个超类的引用赋给一个子类变量， 必须进行类型转换， 这样 才能够通过运行时的检査

对于具有继承关系的类或接口，向下转型需要强转
也就是说父类转子类的时候需要强制类型转换，苹果肯定是果子，但果子不一定是苹果。如果想让某果子变成苹果，只好强制性称呼某个果子为“苹果”

在每次进行强制转换时使用instanceof判断一下是否存在关系，然后再进行转换，否则可能会存在ClassCastException

public class SuperClass {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

public class SubClass extends SuperClass {
	private String performance;
	public String getPerformance() {
		return performance;
	}
 
	public void setPerformance(String performance) {
		this.performance = performance;
	}
}

public static void main(String[] args) {
	SuperClass superClass = new SuperClass();
	if(superClass instanceof SubClass){
		subClass = (SubClass) superClass;
		subClass.setName("abc");
		System.out.println(subClass.getName());
	}
}

综上所述：

• 只能在继承层次内进行类型转换
• 在将超类转换成子类之前，应该使用 instanceof进行检查

注意：
如果 x 为 null, 进行测试 x instanceof C 不会产生异常， 只是返回 false，之所以这样处理是因为 null 没有引用任何对象， 当 然也不会引用 C 类型的对象

实际上，通过类型转换调整对象的类型并不是一种好的做法，基于里氏替换原则来说， 大多数情况并不需要将父类对象转换成 子类 对象， 两个类的对象都能够正确地调用方法，这是因为实现多态性的动态绑定机制能够自动地找到相应的方法。 如果需要强转那么就应该检查一下超类 的设计是否合理。重新设计一下超类

3. String的类型转换

① 其他转String

//①调用类的串转换方法:
X.toString();

//②自动转换:
X+"";

//③使用String的方法:
String.volueOf(X);

② String转其他

//① 先转换成相应的封装器实例,再调用对应的方法转换成其它类型
Double.valueOf("32.1").doubleValue()

//②静态parseXXX方法
String s = "1";

byte b = Byte.parseByte( s );

short t = Short.parseShort( s );

int i = Integer.parseInt( s );

long l = Long.parseLong( s );

Float f = Float.parseFloat( s );

Double d = Double.parseDouble( s );

//③Character的getNumericValue(char ch)方法