Java继承与多态的关系，关键字 “instanceof”的使用

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{
	
}