多态，覆盖，重载
多态：
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("1--" + a1.show(b));
/*
*a1是 A是自身的实例，且A是父类
* a1是A的实例，b是B的实例，且A是父类
* A中没有show(B b)方法
* 根据优先级法则：再按优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
* 因为A是父类，所以this.show(O)、super.show(O)不符合条件（即引用的对象不符合要求）
* this.show((super)O)进行检查：(即进行参数检验)b的父类是A，则变成判断A中有没有show(A a)方法，(这里只看参数)
* 发现有，则执行，A中的show(A obj)方法， return ("A and A");
* */
System.out.println("2--" + a1.show(c));
/*
* 同上，
* a1是A是自身的实例，且A是父类
* A中没有show(C c)方法，又因为B是C的父类
* 则看A中没有show(B b)方法,发现也没有，又因为A是B的父类，
* 则看A中没有show(A a)方法,发现有
* 执行A.show（A a）输出return ("A and A");
*
*/
System.out.println("3--" + a1.show(d));
/*
* 同上，
*/
System.out.println("4--" + a2.show(b));
//4--B and A .首先a2是A引用，B实例，调用show（B b）方法，
//此方法在父类A中没有定义，所以B中方法show(B b)不会调用（多态必须父类中已定义该方法），
//再按优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
//，即先查this对象的父类，没有重头再查参数的父类。查找super.show((super)O)时，B中没有，再向上，找到A中show(A a),因此执行。
System.out.println("5--" + a2.show(c)); //同上
System.out.println("6--" + a2.show(d));
/*//A and D .查找B中没有show(D d)方法，再查A中，有，执行。
* a2是A的引用，B的实例
* 先看B中有没有show(D d)，没有（即根据this.show(O)判断），又因为A是B的父类
* 再看A中有没有show(D d)，有（即根据super.show(O)判断），则执行A.show(D d)方法，return ("A and D");
* */
System.out.println("7--" + b.show(b));
/*调用B.show(B b)方法*/
System.out.println("8--" + b.show(c));
/* //B and B .
* b是B的实例
* 先看B中有没有show(C c)方法，没有。 又因为A是B的父类
* 再看A中有没有show(C c)方法，，没有。又因为B是C的父类
* 再看B中有没有show(B b)方法，。有，执行B.show(B b),return ("B and B"); ;
* */
System.out.println("9--" + b.show(d));
}
}
class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
class B extends A{
public String show(B obj){
return ("B and B");
}
public String show(A obj){
return ("B and A");
}
}
class C extends B{
}
class D extends B{
}
class C1
{
public void f() {
System.out.println("C1.f");
}
}
//c1.f()与c2.f()覆盖
//c3.g(C1 one)与c3.g(C2 two)重载
class C2 extends C1
{
public void f() {
System.out.println("C2.f");
}
}
class C3 {
public void g(C1 one) {
System.out.println("g(C1)");
one.f();
}
public void g(C2 two) {
System.out.println("g(C2)");
two.f();
}
}
public class Main1
{
public static void main(String[] args) {
C1 one = new C2();
C3 three = new C3();
three.g(one);
/*
*
* three是C3的实例
* three.g(one);根据重载的原理，根据参数判断，执行的是 three.g(C1 one)方法，System.out.println("g(C1)");one.f();
* 在该方法里面调用one.f();
* one是C1的引用，C2的实例
* 先看父类C1里面有没有f()方法，有
* 再看C2里面有没有继承该f()方法，也有，继承了父类的该方法
* 则执行C2里的f()方法，System.out.println("C2.f");
*
*
*/
}
}
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
我们将介绍在Java中，当设计类时，被重写的方法的行为怎样影响多态性。
我们已经讨论了方法的重写，也就是子类能够重写父类的方法。
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字super。
Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。
覆盖与重载：
