java造型

A. 谁能给我讲讲java中的强制造型啊最好以代码形式讲下，加下注释，谢谢喔！

分为两种：一种是基础数据类型的强制转型，另一种是引用类型的转型。 基础数据的转型：表数范围小的自动向表数范围大的转型，也叫做向上转型。表数范围大的向表数范围小的转型则需要强制类型转换。例：1、java中的整数默认为int类型。但是我们可以这样写： double a = 10; //自动向上转型， 打印结果：10.0 2、java中的小数默认为double类型。用int类型接收一个double类型的数据， 则需要强制类型转换： int b = (int)10.9; //强制转型，必须显示声明转型（也就是在10.9前面加（int））， //打印结果10 //注意：这里不是四舍五入，而是去掉了所有的小数部分。 另一种强制转型的方式： float c = 10.9f //这是转型的另一种方式。 3、字符串与int,float,double等转型，这主要依靠三种基础数据类型的封装类 的parseXxx()方法来实现(parseInt(),parseFloat(),parseDouble()等), 而整形和浮点型向字符串转型 则依靠String类的valueOf（）方法。 int d = Integer.parseInt("100"); //将字符串转成int类型数据, //注意：字符串的内容必须全为数字，不然会出现类型转换异常。 引用数据类型转型和基础数据类型转型类似，也是自动向上转型。Object为java的基类，它可以接收任意类型。例： 有一个Person类： public class Person { ....... } 可以用Object接收Person类的对象: Object obj = new Person(); //自动向上转型 引用类型的向下转型则需要先建立父类与子类之间的关系： class Person { //父类
......
} class Student extends Person { //子类
.......
} 上面的是一个继承的关系，如果要让父类的Person对象可以转型为子类的Student对象， 则首先要建立一个向上转型的关联，即： Person p = new Student(); //首先向上转型建立关联（必须，否则不能向下转型） Student s = (Student)p; //强制转型到Student对象 父类引用指向子类的对象是多态的表现手段，接口和实现类之间也是这样。 希望对你有所帮助。

B. Java 什么情况下,造型会发生异常如何避免造型出现异常

构造函数中的代码出现未捕获异常会发生。
如何避免：
1、 将构造函数中的异常捕获并处理；
2、将构造函数中容易出现异常的代码 剥离到初始化函数中，并在构造后调用。

C. java向上造型强制转换的好处

向上造型是指父类的引用指向子类对象。向上造型可以提高程序的扩展性，利于代码维护

D. java 对象造型的意义 java

模块与重用

以你的例子来说吧。你那例子是课本用来告诉我们怎么用父类引用子类对象的，所以根本没有意义，于是你自然会问“为什么不直接使用B b1=new B();?”这样的问题了。

要知道把子类的引用给父类有什么意义，这要在够大型的架构里面才能体现的。比如说Java的awt、swing等GUI的框架里面，你随处可以看到继承重用。

就好像说，一个按钮和一个文本框，这两个都是可以显示出来的图形组件；而你要把这两个组件添加到某某窗口frame。那么在这个窗口frame应该有一个方法是可以添加图形组件的，而这个方法必须带有一个参数，这个参数表示要添加的组件，如果让你来设计，你觉得这个参数的类型是什么？显然，这个参数的类型应该表示所有可以被绘制的图形组件（如果只表示按钮或文本框的话，那么以后你新设计了一个单选框，那不是要把frame的代码改动了）。实际上它的这个添加方法是这么被定义的：add(Component comp)。这里的Component是你要添加的按钮或文本框的顶级父类了。

E. java向上造型

正确的有 P0=P1 P0=P2 P4=P2 只要创建对象没错 就直接看引用，谁是爸爸谁在左边等着儿子赋值就行了。

F. java向上造型强转类型的好处

类的加载机制是先加载父类再加载子类，我感觉它的好处是可以让程序运行更快。

G. java向上造型的意义

向上转型是子类对象当成父类对象来使用，也就可以这样理解，父类引用指向子类对象。

那么比如有一个方法m，它传的参数是父类的类型，m(father
f)，执行的父类中已有的某个方法

而你实际传的是它的子类
son，如果子类中有重写父类的方法，那么java机制就会自动的执行子类的那个方法。

想象下，如果你不用父类对象引用，那么你实现每个动物的m方法的时候都要去写一次，而用了这个，java自动判断实际上是哪个对象就用哪个的方法。

而且你如果添加别的子类，也只需要重写出这个类和重写的父类方法就可以了，否则你还要去改m方法。

也就是说，向上转型体现了面向对象的特点，也增加了程序的扩展性。

H. java向上造型有什么作用为什么要造型，有什么效果

向上造型：父类的引用指向子类的对象。
向上造型可以大大提高程序的可扩展性。利于代码维护。
面向对象的三大特性：封装；继承；多态。向上造型可以看做多态的一种体现。即允许一种类型有不同的实现（可以理解为事物存在的多种体现形态）。
典型应用：接口。
没有什么效果，只是是代码精简而已

I. java里面的向上造型中，父类引用指向子类对象时，父类引用只能访问父类的方法，变量等

这是“动态绑定”，动态绑定是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

而想实现“动态绑定”，必须有继承、重写且父类引用指向子类对象，满足了这3条就属于“动态绑定”，而它的好处就是像你说的那样，父类引用访问的是子类对象的方法，你看下边的例子吧：

publicclassA
{
publicstaticvoidmain(Stringargs[])
{
Aa=newB();
print(ainstanceofA);
print(ainstanceofB);
a.sayHello();
a=newC();
print(ainstanceofA);
print(ainstanceofC);
a.sayHello();
}
voidsayHello()
{
print("Hello!");
}
publicstaticvoidprint(Objectobj)
{
System.out.println(obj);
}
publicstaticvoidprint()
{
System.out.println();
}
}
classBextendsA
{
voidsayHello()
{
print("Hello,I'mB!");
}
}
classCextendsA
{
voidsayHello()
{
print("Hello,I'mC!");
}
}

它的输出结果是：

而不是输出的“Hello”，从输出的2个true可以看出这里采用的就是“父类引用指向子类对象”，你先别问为什么输出的不是“Hello”，其实实际情况也正是我们希望输出“Hello,I'm B”要好一些，因为我们new的是A类的子类B和C，虽然它们2个都可以直接采用a.sayHello来调用，但如果输出2个“Hello”，那跟我们直接new一个A类的对象没什么区别。如果我们要想不管A有多少子类，都采用a.sayHello来调用（好记、易写、易改），且java没有“动态绑定机制”，那么父类A的sayHello方法可就不好写了，得先判断是哪个子类，再调用相关子类的sayHello方法，这跟不采用继承，直接new个B和C的对象，再采用b.sayHello、c.sayHello没什么2样，那么这里的“继承”将毫无意义，而且如果日后你你还需要加一个子类D，你还需要new个D的对象，再采用d.sayHello。

顺便，这里你应该还看到了我的父类A还自定义了一个print方法，它的参数既不是String也不是int、double，而是String类、int的包装类、double的包装类等类的父类对象Object类，所以我的sayHello方法里给print函数传递的是String类（父类Object的引用指向子类对象String类），而main方法里的print(a instanceof A)语句传递的是boolean的包装类（父类Object的引用指向子类对象Boolean类），所以这2种调用也是用了“动态绑定”，如果不用呢？不是很多新手都希望java能像C那样直接print("Hello World")多好，那么如果不用“动态绑定”，光是8个基本类型你就需要重写8个print函数，而且，System.out.println语句传递的参数个数也是不确定的(尽管最后都连接成1个String参数)，你不用“动态绑定”如何重写？你写不出来！

再举个例子，如果你写了一个小游戏，几十中坦克都继承于同一个父类：Tank类，然后，你想在游戏界面新建1个坦克，那你的main方法只需要统统采用类似于a.Draw()的语句去画一个坦克即可（全用父类对象的引用），而不需要先判断是哪个子类，再采用类似【case b:b.Draw();break;case c:c.Draw();break;……case n:n.Draw();break;】的语句（几十、几百个子类，你光判断语句恐怕就几百行了吧？），同样开火、移动都只需要调用a.Fire()、a.up()、a.down()、a.Left()、a.Right()即可。而且，如果日后你再想新加1个叫Tank99的子类，那么你的主方法里关于生成一辆Tank99坦克和Tank99的开火、移动等一系列语句都无需修改，你只需要写一个Tank99类，继承并重写Tank父类的方法即可（你不采用“动态绑定”，那么主方法里的一切相关方法全部都需要修改，忘了1个地方，程序就出错了）。程序的可扩展性和健壮性很好，这就是java中“动态绑定机制”的好处。

J. java对象造型问题

Dog d1=(Dog)a;
因为这一句的定义是把父类对象强制转换为子类对象，又因为子类对象有name和furColor两个属性，所以可以去调用,而"bigyellow"已经被赋给了父类的name属性,所以你再调用子类的name属性时就没有了,只能是null.
其实你程序里把子类都又重新定义一个name属性是多余的.
应该这样写.子类不要再定义name属性,而是直接super(name),这样的话,父类和子类都通用一个name属性,就不会出现错误了.而更加符合继承的思想.