1.向上/向下转型

 public class Father {   
     int age=48; 
     static String name="灭霸";
     public void eat(){
         System.out.println("我是父类的方法吃。。。。。");
    }
    public static void EarnMoney(){
         System.out.println("我是父类的方法挣钱。。。。。");
    }
 }
********************************
public class Son extends Father{
     int age=12; 
     static String name="小蜘蛛";
    int String gender="男";
    public void eat(){
        System.out.println("我是Son的方法吃。。。。。");
    }
    public void sleep(){
        System.out.println("Son睡觉");
    }
}
**************************************************
public static void main(String[] args) {

      Father father=new Son();//子类向上转型           
      f.eat();    
      //f.sleep();无法调用此方法 此方法不存在
      System.out.println(father.age);
      System.out.println(father.name);    //father.gender调用不了，应为这是子类有而父类没有的方法
        
    }    
 运行结果： 我是子类的方法吃
                    48
                    灭霸
*************************************************************************
总结：当使用向上转型的时候，我们可以调用的属性和方法，都是父子类当中共有的，当调用普通方法时调用的是子类的方法，当是其他时(变量，类变量，静态方法)，调用的是父类的，当调用的普通方法当中有属性时，按照父类计算

public static void main(String[] args) {

      Father father=new Son();//子类向上转型           
      Son  son=(Son) father;//向下转型
      //此时，son可以调用他自己的所有的方法
    
      Father f=new Father();
      //报错：Exception in thread "main" java.lang.ClassCastException: 
      Son son1=(Son) f;
        
    }    

2.总结

引用：https://www.cnblogs.com/chanchan/p/7787453.html

Girl g1=new MMGirl(); //向上转型
　　　　g1.smile();
      //此时子类的所有方法皆可以调用
　　　　MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错
　　　　这里的向下转型是安全的。因为g1指向的是子类对象。
　　　　　　　　而
　　　　Girl g2=new Girl();
　　　　MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
　　　　运行出错：
　　　　Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
　　　　at com.wensefu.other1.Main.main(Girl.java:36)


假设父类为Person，子类为Student，有下面的两行定义：
Student sTest = new Student();
Person pTest = sTest;

当pTest引用变量/静态变量/静态方法是，调用的是父类的，sTest只能访问子类的，这称为隐藏，可以理解成父类的这些变量和静态成员方法被放到抽屉里暂时藏起来了，当用父类对象引用访问或调用时，把抽屉拉开就可以看到了

当pTest调用的是普通方法时，调用的是子类复写的方法，用sTest调用未覆盖的父类成员方法时，该方法中如果使用到了被隐藏的变量或方法时，规则同上；
即，当sTest调用未被复写的方法时，如方法当中有父类的属性，则这些属性的值是获得不到的。






假设父类为Person，子类为Student，有下面的两行定义：
Student sTest = new Student();
Person pTest = sTest;
其中，pTest就是父类的对象引用，sTest是子类的对象引用；pTest和sTest指向了同一个子类对象。
那么，
(1).如果子类的成员变量与父类的成员变量的类型及名称都相同，则用sTest访问时，访问到的是子类的成员变量；用pTest访问时，访问到的是父类的成员变量；
(2).如果子类的静态成员变量与父类的静态成员变量的类型及名称都相同，则用sTest访问时，访问到的是子类的静态成员变量；用pTest访问时，访问到的是父类的静态成员变量；
(3).如果子类的静态成员方法重写了父类的静态成员方法，则用sTest调用时，调用的是子类的静态成员方法；用pTest调用时，调用的是父类的静态成员方法；
      (1)、(2)、(3)都称为隐藏，可以理解成父类的这些变量和静态成员方法被放到抽屉里暂时藏起来了，当用父类对象引用访问或调用时，把抽屉拉开就可以看到了；
(4).如果子类的成员方法重写了父类的成员方法，则用sTest调用时，调用到的是子类的成员方法；用pTest调用时，调用的也是子类的成员方法；
      此时称为覆盖，可以理解成父类的这些方法被子类重写后的方法用胶带给粘上了，撕不下来了，即使父类对象引用调用时也只能看到子类重写后的方法；
(5).用sTest调用未覆盖的父类成员方法时，该方法中如果使用到了被隐藏的变量或方法时，规则同上；