※静态入参匹配、动态入参匹配和动态入参匹配plus

※静态入参匹配

- -根据入参变量的编译时类型决定调用哪个方法

（谁入参到这个方法就根据谁的编译时类型来决定）

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
public class Test03 {
	
	//定义方法
	public void test(A a) {
		System.out.println("test-------------A");
	}
	public void test(B b) {
		System.out.println("test-------------B");
	}
	public void test(C c) {
		System.out.println("test-------------C");
	}

public static void main(String[] args) {
	//创建实例对象
	Test03 test03 = new Test03();
	//操作一:
	A a = new A();
	B b = new B();
	//
	test03.test(a);//test-------------A
	test03.test(b);//test-------------B
	
	//操作二:
	A a1 = new B();
	B b1 = new C();
	A a_b = b1;
	//(没有多态时):在确认同一个类时，根据方法签名【入参的变量的编译时类型】决定
	//根据方法签名
	test03.test(a1);//test-------------A
	test03.test(b1);//test-------------B
	test03.test(a_b);//test-------------A
}
}
// A --> B --> C
class A{
}
class B extends A{
}
class C extends B{
}

※动态入参匹配

- -根据调用方法的引用变量的运行时类型决定调用哪个类

（谁调用了这个方法就根据谁的运行时类型来决定）

1、确定调用哪个类【调用方法的变量的运行时类型确定】

2、确定调用哪个方法【入参的变量的编译时类型确定】

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */
package com.g0714work;

public class Test04 {
	public static void main(String[] args) {

//		//操作一:
//		A a = new A();
//		B b = new B();
//		C c = new C();
//		
//		//输出结果:
//		a.test(c);//A----c
//		b.test(a);//B----a

		// 操作二:
		// 1、确定调用哪个类【调用方法的变量的运行时类型确定】
		// 2、确定调用哪个方法【入参的变量的编译时类型确定】
		A a = new A();
		B b = new B();
		A a_c = new C();
		A a_b = b;

		// 输出结果:
		a_c.test(b);// C-------------b
		// 简单来说就是先确认运行时类型的就是new C();C类型，
		// 然后再确认编译时类型为B b,为b
		a_b.test(a);// B-------------a
		// 先确认运行时类型的就是new B();B类型，
		// 然后再确认编译时类型为A a,为a
		// 操作三:
		C cc = (C) a_c;
		cc.test(a_b);// C------------a
		// 先确认运行时类型的就是new C();C类型，
		// 然后再确认编译时类型为A a_b,为a

	}
}

// A --> B --> C
class A {
	// 定义方法
	public void test(A a) {
		System.out.println("A-------------a");
	}

	public void test(B b) {
		System.out.println("A-------------b");
	}

	public void test(C c) {
		System.out.println("A-------------c");
	}
}

class B extends A {
	// 定义方法
	public void test(A a) {
		System.out.println("B-------------a");
	}

	public void test(B b) {
		System.out.println("B-------------b");
	}

	public void test(C c) {
		System.out.println("B-------------c");
	}
}

class C extends B {
	// 定义方法
	public void test(A a) {
		System.out.println("C-------------a");
	}

	public void test(B b) {
		System.out.println("C-------------b");
	}

	public void test(C c) {
		System.out.println("C-------------c");
	}
}

※动态入参匹配plus

// 方法调用在编译的时候已经确定了，如果运行时类型有重写方法则显示子类特征

--// 1、先编译【test(A a)】，后运行【test(A a)】（看得见和看不见的问题）

--// 2、确定调用在哪个类中的方法【根据引用变量的运行时类型】

--// 3、确定调用在哪个方法【根据引用变量的编译时类型】

/**
 * @author Lantzrung
 * @date 2022年7月22日
 * @Description
 */

public class Test05 {
	public static void main(String[] args) {

		// 操作一:
		A a = new B();
		B b = new B();

		// 方法调用在编译的时候已经确认了，如果运行时类型有重写方法则显示子类特征
		// 编译的时候已经确定了类型了，运行的时候是确认有没有进行方法重写

		// 1、先编译【test(A a)】，后运行【test(A a)】
		// 2、确定调用哪个类【调用方法的变量的运行时类型确定】
		// 3、确定调用哪个方法【入参的变量的编译时类型确定】
//      注意:这里是还没有在classA中加入方法的 以下方法是操作二才加入的
//      public void test(B b) {
//		System.out.println("A-------------b");
//	    }
		a.test(b);// B------------a

//		//操作二:
//		A a = new B();
//		B b = new B();
//		a.test(b);// B------------b

	}
}

// A --> B --> C
class A {
	// 定义方法
	public void test(A a) {
		System.out.println("A-------------a");
	}

	public void test(B b) {
		System.out.println("A-------------b");
	}
}

class B extends A {
	// 定义方法
	public void test(A a) {
		System.out.println("B-------------a");
	}
	public void test(B b) {
		System.out.println("B-------------b");
	}
}