向上类型转换：

1.可以通过父类引用变量调用的方法是子类覆盖或继承父类的方法。

2.父类引用变量无法调用子类新增成员变量和新增成员方法。

举个例子

public classAnimal {

public voidsleep() {

System.out.println("Animal sleep");

}

public voidjump(){

System.out.println("Animal jump");

}

}

class Tom extendsAnimal {

@Override

public voidsleep() {

System.out.println("Tom sleep");

}

public voidjump() {

System.out.println("Tom jump");

}

public static voidmain(String[] args) {

Animal animal = new Tom();//向上转型

animal.sleep();

// animal.jump();

// animal.jump(); 找不到这个方法

}

}

class Jerry extendsAnimal{

public voidsleep() {

System.out.println("Jerry sleep");

}

public voidjump() {

System.out.println("Jerry jump");

}

}

可以看到父类引用变量animal指向子类对象，Animal.sleep的结果是:

Tom sleep

而且animal不能调用子类中新增的方法，这是向上转型的不足之处，那么向上转型的作用体现在哪里呢？我们再创建一个类和一个测试类

public classAction{

public voidmotion(Tom tom){

tom.sleep();

}

public voidmotion(Jerry jerry){

jerry.sleep();

}

}

public classTest {

public static voidmain(String[] args) {

Tom tom = newTom();

Jerry jerry = newJerry();

Action action= newAction();

action.motion(tom);

action.mootion(jerry);

}

}

Action类中有多个motion()方法，feed()的参数都是Animal类的子类。如果频繁修改，代码可扩展性、可维护性差。如何优化呢，使用多态，同一个引用类型，使用不同的实例操作不同的对象；

修改Action类：

public class Action {

// public void motion(Tom tom){

// tom.sleep();

// }

//

// public void motion(Jerry jerry){

// jerry.sleep();

// }

public void motion(Animal animal){

animal.sleep();

}

}

修改完Action后结果是一样的，如此一来，无所谓有多少个子类继承Animal都不需要继续添加motion方法了。

示例

public class Animal { 
    public void eat(){ 
        System.out.println("animal eatting..."); 
    } 
} 
class Bird extends Animal{
    public void eat(){
        System.out.println("bird eatting..."); 
}
    public void fly(){
        System.out.println("bird flying...");
    }
}
class Main{
    public static void main(String[] args) { 
        Animal b=new Bird(); //向上转型
        b.eat(); //! error: b.fly(); b虽指向子类对象，但此时丢失fly()方法
        dosleep(new Male()); dosleep(new Female()); 
    } 
    public static void dosleep(Human h) {
        h.sleep();
    }
}

示例

public class Human {
  public void sleep() {
    System.out.println("Human sleep..");
  }
}
class Male extends Human {
  @Override
  public void sleep() {
    System.out.println("Male sleep..");
  }
}
class Female extends Human {
  @Override
  public void sleep() {
    System.out.println("Female sleep..");
  }
}

Java向上转型和向下转型(附详细例子)

Java向上转型和向下转型(附详细例子)

熬夜整理的关于Java向上和向下转型的例子，非常的通俗易懂哦~~~~

一.向上转型

package com.sheepmu;

class Animal

{

public void eat()

{

System.out.println("父类的 eating...");

}

}

class Bird extends Animal

{

@Override

public void eat()

{

System.out.println("子类重写的父类的 eatting...");

}

public void fly()

{

System.out.println("子类新方法 flying...");

}

}

public class Sys

{

public static void main(String[] args)

{

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

b.eat();

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

sleep(new Male());

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

}

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

{

h.sleep();

}

}package com.sheepmu;

public class Human

{

public void sleep()

{

System.out.println("父类人类 sleep..");

}

}

class Male extends Human

{

@Override

public void sleep()

{

System.out.println("男人 sleep..");

}

}

class Female extends Human

{

@Override

public void sleep()

{

System.out.println("女人 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();

}

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

二.向下转型

package com.sheepmu;

class Fruit

{

public void myName()

{

System.out.println("我是父类 水果...");

}

}

class Apple extends Fruit

{

@Override

public void myName()

{

System.out.println("我是子类 苹果...");

}

public void myMore()

{

System.out.println("我是你的小呀小苹果~~~~~~");

}

}

public class Sys{

public static void main(String[] args) {

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

a.myName();

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

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

aa.myMore();;

Fruit f=new Fruit();

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

aaa.myName();

aaa.myMore();

}

}输出：

我是子类  苹果...

我是子类  苹果...

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

Exception in thread "main" java.lang.ClassCastException: com.sheepmu.Fruit cannot be cast to com.sheepmu.Apple

at com.sheepmu.Sys.main(Sys.java:30)

详解：

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) 判断一下下~~