㈠ java中向上转型和向下转型有何用途
无论是上转还是下转都是为了让类的使用范围和适用范围发生变化，以便操作不同范围的变量或者方法。
1上转型是指将子类对象使用父类引用进行引用。
得：上转型对象可以操作和使用子类继承或者重写的方法。
失：上转型对象丧失了对子类新增成员变量或新增的方法的操作和使用。
2与向上转型相反，即是把父类对象转为子类对象：作用也与上转相反。
java 转型问题其实并不复杂，只要记住一句话：父类引用指向子类对象。子类和父类中定义同名的变量时，仅仅是隐藏了，变量没有多态性；而对于覆盖的方法，Java表现出多态性，会调用更具体的子类里面的方法，无论从哪里调用，无论使用什么引用类型调用。
㈡ java中向下转型后的对象对于访问父类 或者子类的方法有什么限制
不能访问父类没有的方法和属性
就是这个限制了，其他没有
-------
不能，就好象 你懂电脑，但是不是所有的人都懂电脑
所以无法让一个 "人" 去操作电脑，而只能让“懂电脑的人”去操作电脑。
懂电脑的人 是 人 的子类。
初学者一般都会有这样的问题，先强转成B
以后学了设计的方法学就会很少遇到这样的编码方式了
㈢ 关于JAVA向下转型的问题
有意思
向下转型的最终结果是，子类变量的指针指向了父类的实例化对象。简单点讲，就是把爹当儿子用。
比如：此时你想比较一下两个儿子的年龄和体重是否一样。【采用equals方法】
第一，在object父辈继承得来的equals方法，不能完成年龄和体重对比的要求，故要重写
第二，对象那里找呢？子类自身可以new出一个来，剩下的那个只能通过向下转型，把爹变成儿子
呵呵，为了保证变出来的是儿子类的，在变之前就需要采用 { 出来的对象名称 intanceof 子类名称 } 筛选一下，这样就获得了两个跟题目要求类型一致的对象。
㈣ java当中向上向下转型的作用是什么向下转型的语法
向上转型和向下转型涉及到面向对象三大特性之一的继承，也就是子类和父类之间的关系。
这里以 父类 动物(Animal) 和子类 狗(Dog) 为例：
向上转型：顾名思义，就是把子类强转为父类。代码 Animal a = new Dog();
注意，这里的a是没有办法执行Dog类的独有方法的，因为JVM认为a 是Animal类型的。如果需要使用Dog类独有的方法，就要使用向下转型，也就是通俗意义上的强转。
向下转型：就是把父类强转为子类，代码：
Animal a = new Dog();
Dog d = (Dog)a; // 向下转型，这种写法是完全正确的
/** 下面这种写法会报错 */
Animal a = new Animal();
Dog d = (Dog)a; // 这里会报错，无法转换。
报错的原因很简单，因为你可以说狗是动物，但是你无法说动物是狗。
写了这么多，希望你能明白
㈤ java中向上转型和向下转型什么意思是用来干什么的请高手解释下，通俗点，谢谢！
我们在现实中常常这样说：这个人会唱歌。在这里，我们并不关心这个人是黑人还是白人，是成人还是小孩，也就是说我们更倾向于使用抽象概念“人”。再例如，麻雀是鸟类的一种（鸟类的子类），而鸟类则是动物中的一种（动物的子类）。我们现实中也经常这样说：麻雀是鸟。这两种说法实际上就是所谓的向上转型，通俗地说就是子类转型成父类。这也符合Java提倡的面向抽象编程思想。
子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。但是，向下转型可能会带来一些问题：我们可以说麻雀是鸟，但不能说鸟就是麻雀。
㈥ java的向下转型问题
首先还是给出解决办法吧：
package d;
import c.F;
public class A extends F
{
public static void main(String[] args)
{
A temp = new A();
F f = (F) temp;
if (f instanceof A)
{
A a = (A) f;
System.out.println(a.a());
}
}
输出结果：
还有不理解可以追问。
㈦ JAVA中关于向下转型
下转型就是你上转型后才能做的操作；
例如：Map map = new HashMap(); 上转型
HashMap hmap = map;下转型
一般上转型都是实现接口编程的，减少两个类之间的偶合；
下转型一般是封装好的对象在解封而已。
㈧ java向下转型有什么用
呵呵，这个问题有意思了。
最大的用处是java的泛型编程，用处很大，java的集合类都是这样的，不过由于是向下转型，所以不是安全的。 下面是向下转型的例子：
子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。但是，向下转型可能会带来一些问题：我们可以说麻雀是鸟，但不能说鸟就是麻雀。来看下面的例子：
A类：
package a.b;
public class A {
void aMthod() {
System.out.println("A method");
}
}
A的子类B：
package a.b;
public class B extends A {
void bMethod1() {
System.out.println("B method 1");
}
void bMethod2() {
System.out.println("B method 2");
}
}
C类：
package a.b;
public class C {
public static void main(String[] args) {
A a1 = new B(); // 向上转型
a1.aMthod(); // 调用父类aMthod()，a1遗失B类方法bMethod1()、bMethod2()
B b1 = (B) a1; // 向下转型，编译无错误，运行时无错误
b1.aMthod(); // 调用父类A方法
b1.bMethod1(); // 调用B类方法
b1.bMethod2(); // 调用B类方法
A a2 = new A();
B b2 = (B) a2; // 向下转型，编译无错误，运行时将出错
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}
}
从上面的代码我们可以得出这样一个结论：向下转型需要使用强制转换。运行C程序，控制台将输出：
Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at
a.b.C.main(C.java:14)
A method
A method
B method 1
B method 2
其实黑体部分的向下转型代码后的注释已经提示你将发生运行时错误。为什么前一句向下转型代码可以，而后一句代码却出错？这是因为a1指向一个子类B的对象，所以子类B的实例对象b1当然也可以指向a1。而a2是一个父类对象，子类对象b2不能指向父类对象a2。那么如何避免在执行向下转型时发生运行时ClassCastException异常？使用5.7.7节学过的instanceof就可以了。我们修改一下C类的代码：
A a2 = new A();
if (a2 instanceof B) {
B b2 = (B) a2;
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}
这样处理后，就不用担心类型转换时发生ClassCastException异常了。
㈨ java向下转型，有啥作用。求解
向下转型
将超类的引用强制转换为子类类型就叫做向下转型。
注意：将超类的引用赋给为子类类型的变量（没有进行显示地强制转换）是一个编译
错误。
例子：
还是上面的for循环代码
for(int i=0;i<x.length;i++)
{
if(x[i] instanceof MoreUseful2) // 判断instanceof左边的对象是否是右边的类的实例。
{
MoreUseful2 moreuseful2 = (MoreUseful2)x[i]; // 向下转型
moreuseful2.u();
}
x[i].g();
}
分析：x[i]可以代表具体的Useful对象类型，当它是MoreUseful2或ExtendsMoreUseful2
对象类型时，就可以调用该对象的额外方法u(),v(),w()，也就是当对象x[i]和Moreusful对
象存在is-a关系时，才可以进行向下转型，如果要转换的对象类型与指定的对象类型不
存在is-a关系时，会产生一个ClassCastException异常。
总之：
向下转型时，对象只能强制转换为其本身类型或者其超类类型。比如，
当x[i]ExtendsMoreUseful2对象时，可以把他转换为其本身ExtendsMoreUseful2对象类
型，也可以把它转换为其基类MoreUseful2类型。但是在编译时候还不知道这个x[i]是代
表那个具体对象类型只知道这个x[i]是基类类型引用，所以要用这样的形式" （想要要得
到的类型）x[i] " 进行转换。x[i]在这里是就我这个例子来说明的，你也可以使用其它的
英文代替，其意义是一切符合规定的需要被转换的对象。
下面还有个关于向上转型和向下转型的例子，
abstract class ClassAbstract1{}
class ClassDerived1 extends ClassAbstract1
{
public void play1()
{
System.out.println("play1() is in the ClassDerived1");
}
}
abstract class ClassAbstract2{public abstract void play2();}
class ClassDerived2 extends ClassAbstract2
{
public void play2()
{
System.out.println("play2() is in the ClassDerived2");
}
}
public class E14_UnCast {
public static void playDemo1(ClassAbstract1 ObjectParameter)
{
((ClassDerived1)ObjectParameter).play1();//向下转型，可以调用导出类中的扩展方法
}
public static void playDemo2(ClassAbstract2 ObjectParameter)
{
ObjectParameter.play2();//向上转型，可以调用导出类中的覆盖方法
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassAbstract1 classabstract = new ClassDerived1();
playDemo1(classabstract);
ClassAbstract2 classabstract2 = new ClassDerived2();
playDemo2(classabstract2);
}
}
运行结果：
play1() is in the ClassDerived1
play2() is in the ClassDerived2
㈩ java中对象的向上向下转型在开发中用于实现什么功能
无论是上转还是下转都是为了让类的使用范围和适用范围发生变化，以便操作不同范围的变量或者方法。
1上转型是指将子类对象使用父类引用进行引用。
得：上转型对象可以操作和使用子类继承或者重写的方法。
失：上转型对象丧失了对子类新增成员变量或新增的方法的操作和使用。
2与向上转型相反，即是把父类对象转为子类对象：作用也与上转相反。
java
转型问题其实并不复杂，只要记住一句话：父类引用指向子类对象。子类和父类中定义同名的变量时，仅仅是隐藏了，变量没有多态性；而对于覆盖的方法，Java表现出多态性，会调用更具体的子类里面的方法，无论从哪里调用，无论使用什么引用类型调用。