java 转型概念_转型（java）（.net）

/**

* 父类*/

classAnimal {public voideat() {//输出 父类吃。。。。

}

}classBird extends Animal {public voideat() {//鸟儿吃。。。

}public voidfly() {//鸟儿飞

}

}/**

* 父类人类*/

public classHuman {public voidsleep() {//人类

}

}classMale extends Human {public voidsleep() {//男人

}

}classFemale extends Human {public voidsleep() {//女人

}

}public classSys {public static voidmain(String[] args) {

Animal b= new Bird(); //向上转型

b.eat();//b.fly(); b虽指向子类对象，但此时子类作为向上的代价丢失和父类不同的fly()方法

sleep(newMale());

sleep(new Female()); //传入的参数是子类-----！！

}public static void sleep(Human h) //方法的参数是父类------！！！

{

h.sleep();

}

}

子类重写的父类的  eatting...

男人 sleep..

女人 sleep..

详解：

1.  向上转型的实现

Animal b=new Bird(); //向上转型

b.eat(); // 调用的是子类的eat()方法

b.fly(); // 报错!!!!!-------b虽指向子类对象，但此时子类作为向上转型的代价丢失和父类不同的fly()方法------

2.为何不直接Bird b=new Bird();b.eat() 呢？

这样就没有体现出面向对象的抽象的编程思想呀，降低了代码的可扩展性.

3.向上转型的好处？

sleep(new Male());//调用方法时传入的参数是子类

sleep(new Female());

public static void sleep(Human h) //方法的参数是父类

{

h.sleep();

}

如上代码就是用的向上转型，若是不用向上转型，那么有多少个子类就得在这儿写多少种不同的睡觉方法~~~~~~

classFruit {public voidmyName() {//水果

}

}classApple extends Fruit {public voidmyName() {//苹果

}public voidmyMore() {

苹果1233333

}

}public classSys {public static voidmain(String[] args) {

Fruit a= new Apple(); //向上转型

a.myName();

Apple aa= (Apple) a; //向下转型,编译和运行皆不会出错(正确的)

aa.myName(); //向下转型时调用的是子类的

aa.myMore();;

Fruit f= newFruit();

Apple aaa= (Apple) f; //-不安全的---向下转型,编译无错但会运行会出错

aaa.myName();

aaa.myMore();

}

}

我是子类  苹果...

我是子类  苹果...

我是你的小呀小苹果~~~~~~

出错。。。。。。。。

详解：

1.正确的向下转型

Fruit a=new Apple(); //向上转型

a.myName();

Apple aa=(Apple)a; //向下转型,编译和运行皆不会出错(正确的)

aa.myName();

aa.myMore();

a指向子类的对象，所以子类的实例aa也可以指向a啊~~

向下转型后因为都是指向子类对象，所以调用的当然全是子类的方法~~

2.不安全的向下转型

Fruit f=new Fruit();

Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会运行会出错

aaa.myName();

aaa.myMore();

f是父类对象，子类的实例aaa肯定不能指向父类f啊~~~

3.Java为了解决不安全的向下转型问题，引入泛型的概念

4.为了安全的类型转换，最好先用 if(A instanceof  B) 判断一下下~~