java多态性

//A类是B类的父类                          
A  ab = new B();   //多态 父类的引用指向子类的实例
ab.show();

当有继承关系时，可能发生编译期类型和运行期类型不同的情况，
即编译期类型是父类类型 (A)，运行期类型是子类类型。(B)

class  Animal{
    …… 
}
class Cat  extends Animal{
    ……
}
class Dog extends Animal {
    ……
}
Cat m = new Cat() 
Animal x = new Cat()  //Animal 的引用指向Cat的对象

对象m可以调用猫类中的所有方法，x只能调用动物类中定义的方法，猫类扩展的新方法不能调用

多态环境下对成员方法的调用

简单的说：编译看左边，运行看右边。

class  Animal{
           void show() {
             System.out.println(“Anmial");
          }
}
class Cat  extends Animal{
              void show() {
                    System.out.println(“cat");
              }
}
…….
Animal x = new Cat() 
   x.show() //调用的是子类中的方法  cat方法

多态环境下对静态成员方法的调用

class  Animal{
          static  void show() {
             System.out.println(“Animal");
          }
}
class Cat extends Animal {
             static  void show() {
                    System.out.println(“Cat");
              }
}
…….
Animal x = new Cat() ;
   x.show() //调用的是动物类中的静态成员方法。

简单的说：编译和运行都看左边 也可以理解为静态方法可以用类名直接调用 ，那个类调用 就运行哪一个方法

多态环境下对成员成员方法的调用

class Animal{
       int num = 3;   
}
class Cat  extends Animal {
       int  num = 4;
}
…….
Animal x = new Cat() 
   x.num; //调用的是动物类中的成员变量。

***简单的说：编译和运行都看等号左边。  
注意：变量不存在被子类覆写这一说法，只有方法存在覆写***

多态参数

public static void main(String[] args) {
		// Animals 编译类型     Animals() 运行期类型 
		Animals animal=new Cat();
		animal.run();
		//animal.work();  编译失败  在Animals 里面没有改方法
		// 访问子类独有的方法 必须强制转成子类类型    对象。方法
		Cat cat=(Cat)animal;
		cat.work();
		
		test(new Cat());
		test(new Dog());
		
		Animals d=new Dog();
		Animals c =new Cat();
		
		System.out.println(d instanceof Animals);
		System.out.println(d instanceof Dog );
		System.err.println(d instanceof Cat);
		
		
		
	}
	//判断传入参数类型  实现子类特有的方法 
	public static void test(Animals animal){
		if(animal instanceof Cat){
			Cat cat=(Cat) animal;
			cat.work();
		}else if(animal instanceof Dog){
			Dog dog=(Dog) animal;
			dog.work();
		}
	}

result = 对象名称 instanceof  类型
参数：
result：布尔类型。

class Super {
	public static void m1() {
		System.out.println("m1 in Super");
	}

	public void m2() {
		System.out.println("m2 in Super");
	}
}

class Sub extends Super {
	public static void m1() {
		System.out.println("m1 in Sub");
	}

	public void m2() {
		System.out.println("m2 in Sub");
	}
}

public class Test {
	public static void main(String args[]) {
		Super sup = new Sub();
		sup.m1();
		sup.m2();
		Sub sub = (Sub) sup;
		sub.m1();
		sub.m2();
	}
}

静态的方法不能重写 所以看左边
m1 in Super
m2 in Sub
m1 in Sub
m2 in Sub