java--隐含的向上转型和向下转型

我们在操作中，经常会遇到对象与数组之间的转换问题，因为有些数组使用的方法在对象就不能调用。比如说对象没有length方法，但在数组中却常用。（注意：集合也没有length，只有size方法，返回int型数据。）我们可以先看看一个操作：

length属性是针对Java中的数组来说的，要求数组的长度可以用其length属性；
public static void main(String[] args) {String []list={"ma","cao","yuan"};
System.out.println(list.length);
List
}

好了，扯远了。那我们看看在集合框架中，遍历一个集合的代码：

1.

import java.util.ArrayList;
import java.util.Collection;

/*
 * 集合的遍历。其实就是依次获取集合中的每一个元素。
 * 
 * Object[] toArray():把集合转成数组，可以实现集合的遍历
 */
public class CollectionDemo3 {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();

		// 添加元素
		c.add("hello"); // Object obj = "hello"; 向上转型
		c.add("world");
		c.add("java");

		// 遍历
		// Object[] toArray():把集合转成数组，可以实现集合的遍历
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
			// System.out.println(objs[x]);
			// 我知道元素是字符串，我在获取到元素的的同时，还想知道元素的长度。
			// System.out.println(objs[x] + "---" + objs[x].length());
			// 上面的实现不了，原因是Object中没有length()方法
			// 我们要想使用字符串的方法，就必须把元素还原成字符串
			// 向下转型
			String s = (String) objs[x];
			System.out.println(s + "---" + s.length());
		}
	}
}

这是一个最简单的向下向上转型问题，从这个问题类推，我们用在面向对象的问题上就具有很现实的意义了。

2.

class A{	
public void A1(){	
System.out.println("父类方法1");	
}
public void A2()	{	
System.out.println("父类方法2");	
}
}

class B extends A{	
public void A1()	{	
System.out.println("子类方法1");	
}	
public void B2()	{	
System.out.println("子类方法2");
 }
}

public class C{
 public static void main(String args[]){		
A a=new B();	//upcast	
}
}

好，这是类的简单转型：

向上转型，通俗点就是说先创建一个B子类对象，然后把它强制转型为A类对象。所以A类A1()方法被子类B中的A1()方法覆盖，而子类中的B2()丢失。

3.

那我们看看多态中的转型：

我们知道多态的弊端是不能使用子类的特有功能。父对象不能给子，但是父的引用可以强制被赋给子的引用。

提出：对象间的转型问题：
向上转型：
Fu f = new Zi();     //子对象Zi转成父对象f
向下转型：
Zi  z = (Zi)f;        //要求该f必须是能够转换为Zi的。这样就可以访问子的方法了。

class Fu {
	public void show() {
		System.out.println("show fu");
	}
}

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();
		//f.method();
		
		//创建子类对象
		//Zi z = new Zi();
		//z.show();
		//z.method();
		
		//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
		//如果可以，但是如下
		Zi z = (Zi)f;
		z.show();
		z.method();
	}
}

也可以参考大神的博客详细讲解：点击打开链接

再看一个向上向下转型的例子：

public class StudentDemo {
	public static void main(String[] args) {
		// 创建集合对象
		Collection c = new ArrayList();

		// 创建学生对象
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("风清扬", 30);
		Student s3 = new Student("令狐冲", 33);
		Student s4 = new Student("武鑫", 25);
		Student s5 = new Student("刘晓曲", 22);

		// 把学生添加到集合
		c.add(s1); //注意：放置数据的时候有个隐含的向上转型
		c.add(s2);
		c.add(s3);
		c.add(s4);
		c.add(s5);

		// 把集合转成数组
		Object[] objs = c.toArray();
		// 遍历数组
		for (int x = 0; x < objs.length; x++) {
			// System.out.println(objs[x]);

			Student s = (Student) objs[x]; //向下转型
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}