Java继承与多态的关系：
继承是一种由已有的类创建型类的机制，需要用到关键字 import 来实现；
多态是面向编程的重要特征，有两种意义的多态：
1、一种多态是操作名称的多态，即类中有多个操作具有相同的名字，但这些操作所接收的信息类型必须不同（方法参数）；实现代表：方法重载；
如下代码↗：
//方法重载
void test(int x){
System.out.println("输出x的值"+x);
}
void test(int x,int y){
System.out.println("输出x+y的值"+(x+y));
}
void test(double x,int y){
System.out.println("输出x*y的值"+(x*y));
}2、一种多态是和继承有关的多态，是指同一个操作被不同类型的对象调用时可能产生不同的行为；实现代表：方法重写；
如下代码↗：
//父类
public class methodRewrite {
//被子类重写方法
void Method(){
System.out.println("父类的Method方法，被子类继承或重写");
}
}
//子类
public class methodRewrite_Test extends methodRewrite {
//对继承的父类方法进行重写
void Method(){
System.out.println("我重写了父类的Method方法，产生了自己的行为");
}
public static void main(String[] args) {
methodRewrite_Test mrt = new methodRewrite_Test();
mrt.Method();
}
}
代码中 子类对父类的 Method() 方法进行了重写，从而产生了另一种行为；
对于继承：一个父类可以有多个子类，但是一个子类只能有一个父类；
所有继承与多态的关系就是：
通过继承机制，可以实现一种意义上的多态；
扩展：
有两种形式可以调用重写后的方法：
1、子类 ---》 重写方法 ---》子类对象.重写方法
2、子类 ---》 重写方法 ---》上转型对象.重写方法
如以上代码中，还可以改成：
//第一种：子类对象.重写方法
methodRewrite_Test mrt = new methodRewrite_Test();
mrt.Method();
//第二种：上转型对象.重写方法
methodRewrite mr = new methodRewrite_Test();
mr.Method();Java关键字 “instanceof”的使用：
1、Java关键字 instanceof 是Java独有的双目运算符，其左边的操作元是 对象，右边的操作元是 类；
如： 对象名 instanceof 类名
2、当左边的操作员（对象）是 右边的类 或 其子类所创建的对象 时，instanceof运算符的结果是 true，否则是 false ；
如下代码↗：
//创建父类
public class instanceof_Fa {
}//创建子类
public class instanceof_Test extends instanceof_Fa {
public static void main(String[] args) {
//创建子类对象 it ，并判断
instanceof_Test it = new instanceof_Test();
boolean bo = it instanceof instanceof_Test;
System.out.println("判断类instanceof_Test 是否为对象it所在的类或 所在类的父类: "+ bo);
//创建子类对象 its ，并判断
instanceof_Test its = new instanceof_Test();
boolean bos = its instanceof instanceof_Fa;
System.out.println("判断类instanceof_Fa 是否为对象its所在的类或 所在类的父类: "+ bos);
//创建父类对象 iFa ，并判断
instanceof_Fa iFa = new instanceof_Fa();
boolean boFa = iFa instanceof instanceof_Fa;
System.out.println("判断类instanceof_Fa 是否为对象iFa所在的类或 所在类的父类: "+ boFa);
boolean boFas = iFa instanceof instanceof_Test;
System.out.println("判断类instanceof_Fa 是否为对象iFa所在的类或 所在类的父类: "+ boFas);
//创建其他类对象，并判断
A as = new A();
boolean lean = as instanceof A; //正确
// boolean leanx = as instanceof instanceof_Fa; //错误
//报错：Incompatible conditional operand types A and instanceof_Fa
}
}
class A{
}代码输出结果：
判断类instanceof_Test 是否为对象it所在的类或 所在类的父类: true
判断类instanceof_Fa 是否为对象its所在的类或 所在类的父类: true
判断类instanceof_Fa 是否为对象iFa所在的类或 所在类的父类: true
判断类instanceof_Fa 是否为对象iFa所在的类或 所在类的父类: false
总结出：
自己对象 instanceof 自己类 ---》 true
子类对象 instanceof 父类 ---》 true
父类对象 instanceof 子类 ---》 false
一般类对象 instanceof 其他类 ---》报错：Incompatible conditional operand types A and 其他类
如：
//创建其他类对象，并判断
A as = new A();
boolean lean = as instanceof A; //正确
// boolean leanx = as instanceof B; //错误
//报错：Incompatible conditional operand types A and B
class A{
}
class B{
}