class Father {
String Fname = "爸爸";
public void sleep() {
//睡觉方法
System.out.println(Fname + "睡觉");
}
}
class Son extends Father {
String Sname = "儿子";
public void p() {
//调皮方法
System.out.println(Sname + "调皮");
}
}
public class Test {
public static void main(String[] args) {
Father f= new Son();
f.sleep();
System.out.println(f.Fname);
//System.out.println(f.Sname); 编译器报错
//f.p(); 编译器报错
System.out.println();
System.out.println(((Son)f).Fname);
System.out.println(((Son)f).Sname);
((Son)f).sleep();
((Son)f).p();;
}
}
//程序输出结果为
// 爸爸睡觉
// 爸爸
//
// 爸爸
// 儿子
// 爸爸睡觉
// 儿子调皮
当一个父类的对象引用的是子类的实例时，我们可以把这个父类对象叫做上转型对象。
这里有两种方法创建上转型对象
1.Father f= new Son();
2.Son son= new Son();
Father f=(Father)son;
Son是Father的子类，f就是上转型对象
（1）上转型对象不能操作子类声明定义的成员变量（失掉了这部分属性），不能使用子类声明定义的方法（失掉了一些功能）。这里f失去了Sname这个成员变量,失去了P这个方法，可以看作是一种”瘦身”。
（2）上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法
（3）可以将上转型对象再强制转换成子类对象，这样，该子类对象又具备了子类具有所有属性和方法。
（4）如果子类重写了父类的某个方法后，当对象的上转型对象调用这个方法时一定是调用了这个重写的方法。这里我们再展开来讲一下,我们给Father类和Son类分别添加speak方法
class Father {
String Fname = "爸爸";
public void sleep() {
//睡觉方法
System.out.println(Fname + "睡觉");
}
public void speak() {
System.out.println("我是爸爸");
}
}
class Son extends Father {
String Sname = "儿子";
public void p() {
//调皮方法
System.out.println(Sname + "调皮");
}
public void speak() {
System.out.println("我是儿子");
}
}
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Father f= new Son();
f.speak();
//调用子类重写的方法
System.out.println();
((Son)f).speak();
}
}
//程序输出结果为:
// 我是儿子
//
// 我是儿子
Son重写了Father类的speak方法，上转型对象调用的是son类的speak方法，所以输出”我是儿子”。
接下来，我们就需要了解上转型对象的实现意义，为什么 java开发人员要设计一个上转型对象呢。
class Animal {
void cry() {
}
}
class Dog extends Animal {
void cry() {
System.out.println("汪汪");
}
}
class Cat extends Animal {
void cry() {
System.out.println("喵喵");
}
}
public class 上转型对象多态 {
public static void beat(Dog dog) {
System.out.println("打了它一下");
dog.cry();
}
public static void beat(Cat cat) {
System.out.println("打了它一下");
cat.cry();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog dog= new Dog();
Cat cat= new Cat();
beat(dog);
beat(cat);
}
}
//程序输出结果:
// 打了它一下
// 汪汪
// 打了它一下
// 喵喵
这里我们没有使用上转型对象,beat方法写了两种。
public class 上转型对象多态 {
public static void beat(Animal animal) {
System.out.println("打了它一下");
animal.cry();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Dog dog= new Dog();
Cat cat= new Cat();
beat(dog);
beat(cat);
}
}
//程序输出结果:
// 打了它一下
// 汪汪
// 打了它一下
// 喵喵
原来需要写两个beat函数才能实现的功能，现在只需写一个就行了
我们使用了上转型对象，上转型对象调用子类重写的方法，实现了方法的多态，还降低了程序之间关联性。
比如说我现在想要再写一个Animal类的子类，如果不用上转型对象，那我还要再添加一个beat方法，但是有了上转型对象，Animal的子类想怎么添加，怎么添加，beat方法到最后都可以使用。
同时，我们还注意到，上转型对象会调用子类重写的方法，父类隐藏的那个方法永远都用不到。上面的例子中Cat和Dog重写了Animal的cry()方法,Animal中的cry()的方法体是什么根本无所谓。Java开发人员想了想，反正隐藏的方法体是什么无所谓，要不我们直接定义一个结构，方法只可以声明（没有方法体）。于是这样，抽象类就被发明了。后来，由于java只支持单继承，抽象类有时不能满足开发需求，开发人员又发明了接口，接口可以实现多重继承，一个类可以实现多个接口。
面向对象编程，代码多态和复用的思想贯串始终。这种编程思想真的非常好，极大的降低了程序之间的关联性
==============================================================================
参考博客:
Java向上转型和向下转型的通俗简单理解以及使用用途
Java向上转型的作用（有详细代码介绍）
这边还有一个解释抽象类和接口区别的深度好文,大家也可以看看:
Java 接口(interface)的用途和好处