Java多态

多态存在的条件

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态。
多态的三个必要条件：

• 继承
• 重写
• 父类变量指向子类实例
  多态实际上就是指 “相同类型的变量，调用同一个方法时呈现出多种不同的行为特征”，就是说当一个子类重写了父类的方法，然后定义一个父类引用指向子类实例的时候，这个父类引用再调用那个重写的方法，就和父类的方法所展现的结果不一样了，这就是多态。
  《暂时理解到这个程度，不要想太多！》

package ObjectOriented;


class BaseClass{
    public int a = 5;

    public void test(){
        System.out.println("父类被覆盖的方法");
    }
    public void base(){
        System.out.println("父类的普通方法");
    }
}
public class SubClass extends BaseClass {
    public int a = 7;
    public void test(){
        System.out.println("子类覆盖父类的方法");
    }
    public void sub(){
        System.out.println("子类的普通方法");
    }
    public void accessOwner(){
        System.out.println(this.a);
    }
    public void accessBase(){
        System.out.println(super.a);
    }

    public static void main(String[] args) {
        BaseClass bc = new SubClass();
        bc.test();  // 运行的是子类覆盖父类的那个方法，而不是父类自己的test方法
        bc.base();
        //bc.sub();基类中没有sub方法，因此编译会出错
        System.out.println(bc.a);// 实例变量不具备多态性，多态是针对方法的。
        BaseClass bc1 = new BaseClass();
        bc1.test();  // bc1和bc是相同类型的变量，且调用了相同的方法，但是出现了不同的行为特征，这就是多态。
    }
}
输出：
子类覆盖父类的方法
父类的普通方法
5
父类被覆盖的方法

为什么实例变量没有所谓的多态性质呢？我的理解是：对于实例变量，Java都是会为其分配单独的存储空间的，因此父类引用是指向它自己的实例变量空间，至于方法，我现在的理解是共用的空间，父类还是调用它的方法，但是它已经被子类改变了。

强制类型转换

由于多态的发生条件之一是父类变量指向子类对象，因此这里不可避免的要涉及到强制类型转换的内容了。
引用变量只能调用它编译时类型的方法，而不能调用它运行时类型的方法，即使它实际指向的对象确实包含该方法。如果想让它调用这个方法，只能通过强制类型转换来实现。

• 基本类型之间的转换只能在数值类型之间进行，这里所说的数值类型包括整数型，字符型，浮点型。数值类型和布尔类型之间不能相互转换。数值类型小转大，自动转，无所谓，大转小，需要强制类型转换。

        long l1 = 23; // int型转为long
        int a = (int)3.14; // double转int，使用强制类型转换

• 引用类型之间，也可以进行这样的转换，但是又很大的不同。必须要求引用变量之间有继承关系。
  1. 没有什么小到大的自动转换了，那个叫父类引用指向子类对象。
  2. 大到小的转换也是有条件的，即大的引用指向的对象的运行时类型必须是小类型的实例或者 其子类实例。
  3. 小到大的转换可以使用强制类型转换，但是转换之后还是原来那个类型

    var bc3 = new SubClass();
    var bc4 = (BaseClass)bc3;
    System.out.println(bc4.getClass());
   输出： class ObjectOriented.SubClass

还有就是要记住，Java有编译时类型和运行时类型，编译时类型即其定义的类型，运行时类型是它实际指向的对象的类型。因此有时候会出现编译通过，但是运行出错的问题。

package ObjectOriented;

public class ConversionTest {
    public static void main(String[] args) {
        var d = 13.4;  // 默认是double类型
        var l = (long) d; // 将double型强制类型转换为long型
       // var b = (boolean) d; 编译出错，无法将基本数据类转换为布尔类型
        Object obj = "hello";
        System.out.println(obj);
        var objstr = (String)obj;
        System.out.println(objstr);
        Object opjPri = Integer.valueOf(7);
        //var str = (String)opjPri;  实际类型是int，是无法转换成为string类型的，因此在运行时会出错。
        var o = (Object)"rjk"; // 小转大，没有任何问题，直接转
        System.out.println(o.getClass());
        long l1 = 23; // int型转为long
        int a = (int)3.14; // double转int，使用强制类型转换
    }
}

当将一个父类对象赋给子类变量时，是需要进行强制类型转换的，而且这种转换有可能出现ClassCastException。因此需要使用instanceof运算符来做一个预先的判断。判断被转换的引用运行时类型是否是要转换类型的实例或者子类实例。
语法规则为：

引用名  instanceof 类名

这个运算符同样要求二者之间存在继承关系，否则编译直接不通过，运行时判断的是引用的运行时类型是否是要转换的那个类型的实例或者子类实例，是则返回true，否则返回false。

package ObjectOriented;

public class InstanceofTest {
  public static void main(String[] args) {
    Object hello = "hello";
    System.out.println(hello instanceof Object);//true
    System.out.println(hello instanceof String);//true
    System.out.println(hello instanceof Math); //false，string和math是不一样的
    var a = "hello";
    //System.out.println(a instanceof Math);编译会报错，二者之间并没有继承关系
  }
}

instanceof 运算符一般是和强制类型转换绑定在一块的，这样可以使得程序更加得健壮。