67,512
社区成员
发帖
与我相关
我的任务
分享
public class A{}
public class B extents A{
A a = (B)new A();//这句话会抛出异常么 为什么??
}
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
[/quote]谢谢 大概理解了 但是感觉向下转型没啥用[/quote]
这个看你以后项目需要了,如果项目中,子类不允许添加父类没有的方法,那么就不会用的,如果子类中添加了父类中没有的方法,那么就会遇到向下转型为更具体的子类,已调用子类自今的方法!
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
[/quote]谢谢 大概理解了 但是感觉向下转型没啥用[/quote]
class Animal{
void eat(){
}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat fish");
}
public void catchMouse(){
System.out.println("Cat catch mouse");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat bone");
}
public void watchDoor(){
System.out.println("Dog watch door");
}
}
public class Demo{
public static void main(String[] arg){
Animal a = new Animal();
testAnimal(a);
}
public static void testAnimal(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
}
if(a instanceof Dog){
Dog d = (Dog)a;
d.watchDoor();
}
}
}
这里就是向下转型
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
[/quote]谢谢 大概理解了 但是感觉向下转型没啥用[/quote]
class Animal{
void eat(){
}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat fish");
}
public void catchMouse(){
System.out.println("Cat catch mouse");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat bone");
}
public void watchDoor(){
System.out.println("Dog watch door");
}
}
public class Demo{
public static void main(String[] arg){
Animal a = new Animal();
testAnimal(a);
}
public static void testAnimal(Animal a){
a.eat();
if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
}
if(a instanceof Dog){
Dog d = (Dog)a;
d.watchDoor();
}
}
}
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
[/quote]谢谢 大概理解了 但是感觉向下转型没啥用[/quote]
哥么,你还不知道封装的重要性
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
[/quote]谢谢 大概理解了 但是感觉向下转型没啥用public class A{
public void fxh(){
System.out.print("a fxh");
}
}
public class B extents A{
public void fxh(){
System.out.print("b fxh");
}
B b = new B();
A a = (A)b;
a.fxh();//向上转型成功了 编译过了 为什么输出是:b fxh
}
[/quote]
你new的是一个B对象 当然输出B的方法哦[/quote]
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了[/quote]恩 这个理解了 那向下转型有什么作用 能举个例子体现一下么?[/quote]
可以调用只有子类才就与的方法啊...
多态体现在动态绑定,这样才能确保能正确调用某个对象的覆盖父类某个方法的方法,子类可能还有其他方法,这是候当然是 谁的私有方法 由谁来调用了啊,这就是向下转型的目的...[/quote]谁的私有方法谁来调用需要用到向下转型么?不需要吧 有例子么?
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?[/quote]
if(a instanceof B){
B b = (B)a;
b.tell();
}
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]向下转型的作用就是使a.tell()正确吧 怎么做到?public class A{
public void fxh(){
System.out.print("a fxh");
}
}
public class B extents A{
public void fxh(){
System.out.print("b fxh");
}
B b = new B();
A a = (A)b;
a.fxh();//向上转型成功了 编译过了 为什么输出是:b fxh
}
[/quote]
你new的是一个B对象 当然输出B的方法哦[/quote]
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了[/quote]恩 这个理解了 那向下转型有什么作用 能举个例子体现一下么?[/quote]
就是多态啊
比如我有一个车类
是父类
他有跑的方法
然后我有一个汽车类
继承了车类
实现这个跑的方法
我还有一个单车类也继承他实现他这个方法
然后我有一个地方要调用一个方法
就是去某地
那么我调用去某地的时候只用吧参数写成车就行了
我想用汽车去就传汽车
想用单车去就传单车
随便扯的一个例子
不知道看得懂不 [/quote]多态是懂的 不明白的是向下转型的作用public class A{
public void fxh(){
System.out.print("a fxh");
}
}
public class B extents A{
public void fxh(){
System.out.print("b fxh");
}
B b = new B();
A a = (A)b;
a.fxh();//向上转型成功了 编译过了 为什么输出是:b fxh
}
[/quote]
你new的是一个B对象 当然输出B的方法哦[/quote]
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了[/quote]恩 这个理解了 那向下转型有什么作用 能举个例子体现一下么?[/quote]
就是多态啊
比如我有一个车类
是父类
他有跑的方法
然后我有一个汽车类
继承了车类
实现这个跑的方法
我还有一个单车类也继承他实现他这个方法
然后我有一个地方要调用一个方法
就是去某地
那么我调用去某地的时候只用吧参数写成车就行了
我想用汽车去就传汽车
想用单车去就传单车
随便扯的一个例子
不知道看得懂不
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]
这个不会错误吧....[/quote]
对不住,看错了,你说的注释的...
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
[/quote]
这个不会错误吧....
class A{
public void say(){
System.out.println("say方法被调用");
}
}
class B extends A{
public void tell(){
System.out.println("tell 方法被调用");
}
}
public static void main(String[] args){
A a = new B();
a.say();
//a.tell(); 错误,无法调用此方法,因为父类中没有声明此方法
}
public class A{
public void fxh(){
System.out.print("a fxh");
}
}
public class B extents A{
public void fxh(){
System.out.print("b fxh");
}
B b = new B();
A a = (A)b;
a.fxh();//向上转型成功了 编译过了 为什么输出是:b fxh
}
[/quote]
你new的是一个B对象 当然输出B的方法哦[/quote]
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了[/quote]恩 这个理解了 那向下转型有什么作用 能举个例子体现一下么?[/quote]
可以调用只有子类才就与的方法啊...
多态体现在动态绑定,这样才能确保能正确调用某个对象的覆盖父类某个方法的方法,子类可能还有其他方法,这是候当然是 谁的私有方法 由谁来调用了啊,这就是向下转型的目的...public class A{
public void fxh(){
System.out.print("a fxh");
}
}
public class B extents A{
public void fxh(){
System.out.print("b fxh");
}
B b = new B();
A a = (A)b;
a.fxh();//向上转型成功了 编译过了 为什么输出是:b fxh
}
[/quote]
你new的是一个B对象 当然输出B的方法哦[/quote]
我这样理解的 你new的一个B对象 就算你给它强转成A 但是他实际上还是B对象 只不过A是B的父类 可以把B当成A来用罢了[/quote]恩 这个理解了 那向下转型有什么作用 能举个例子体现一下么?