多态的详细介绍

多态：
定义：某一类事物的多种存在形态
列：动物中 猫 狗；
猫这这个对象对应的类型是猫类型；
猫 a = new 猫()；
同时猫也是动物中的一种，也可以把猫称为动物；
动物 b = new 猫();
动物是猫和狗具体事物中抽取出来的父类型
父类型引用指向子类型对象。

对象的多态性：
class 动物{
class 猫 extends 动物{}
class 狗 extends 动物{}
猫 a = new 猫();
动物  b = new 猫();//一个对象两种形态
猫这类事物即具备猫的形态又具备动物的形态，也就算对象的多态性；
简单的说：就是一个对象对应着不同的类型；

多态在代码中的体现：
父类或者接口的引用指向其子类对象

多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期定义的内容；

abstract class Animal{
abstract void eat();

}

class Dog extends Animal{

void eat(){
System.out.println("啃骨头")；
}
void lookHome(){
System.out.println("看家")；
}

}

class Cat extends Animal{
void eat(){
System.out.println("吃鱼")；
}
void catchMouse(){
System.out.println("抓老鼠")；
}

}
class DuoTaiDemo{

public static void main(String[] args){

Cat c = new Cat();
Dog d = new Dog();
Animal a = new Dog();
method1(a);
method1(c);
method1(d);

}

public static viod method1(Animal a){
a.eat();
a.catchMouse();//编译报错，动物里没有抓老鼠的方法。

}

}
《多态的弊端：
前期定义的内容不能调用后期子类中特有的内容。
多态的前提：
1：必须有关系 ：继承 实现 。
2：要有覆盖。
》

if(a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse();
/*
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一

个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性判断；
*/

}

Animal a = new Cat();//自动类型提升猫对象，提升了动物类型，但是特有的功能无法访问
//作用就是限制了对特有功能的访问；
//专业上讲：向上转型将子类型隐藏，就不使用子类的特有方法；
//如果还想使用具体动物猫的特有功能，可以将该对象进行向下转型；
//向下转型的目的是为了使用子类中的特有方法。
a.eat();
Cat c = (Cat)a;
c.eat();
c.catchMouse();

/*注意：对于转型，自始至终都是子类对象在做着类型的变化(如小猫转动物，小猫转小猫)

Animal an = new Dog();
Cat c = (Cat)an;
错误：报classCatException 类型转换异常

*/

class 毕姥爷{
viod 讲课(){
System.out.println("管理课")；

}
viod 钓鱼(){
System.out.println("钓鱼")；

}
}

class 毕老师 extends 毕姥爷{
viod 讲课(){
System.out.println("java")；

}
viod 看电影(){
System.out.println("无间道")；

}
}

class DuoTaiDemo{

public static void main(String[] args){
//毕老师 b = new 毕老师();
//   b.讲课();
//   b.看电影();

毕姥爷 bl = new 毕老师();
bl.讲课();   -----------System.out.println("java")；
bl.钓鱼();   -----------System.out.println("钓鱼")；
//   bl.看电影();  错误

}
}

多态时 成员的特点：

1，成团变量：

编译时参考引用型变量所属的类中是否有调用的变量，有，编译通过；没有，编译失败；
运行时参考引用型变量所属的类中是否有调用的变量，并运行该属性类中的成员变量；
简单说：编译和运行都参考等号的左边。
2，成员函数：

编译时参考引用型变量所属的类中是否有调用的函数，有，编译通过；没有，编译失败；
运行时参考的是对象所属的类中是否有调用的函数；
简单说：编译看左边，运行看右边。
3，静态函数：

编译时参考引用型变量所属的类中是否有调用的静态方法；
运行时参考引用型变量所属的类中是否有调用的静态方法；
简单说：编译和运行都看左边。
<!--静态方法是不需要对象的，直接类名调用即可-->

---------------------------------------
成员变量：
class Fu{

int num = 3;
}
class Zi extends Fu{

int num = 4;
}
class DuoTaiDemo{

public static void main(String[] args){

Fu f = new Zi();
System.out.println(f.num)；//运行结果等于3  编译和运行都看左边
}
}
------------------------------------------
成员函数：
class Fu{

void Show(){
System.out.println("fu show")；

}
}

class Zi extends Fu{

void Show(){
System.out.println("zi show")；

}
}

public static void main(String[] args){

Fu f = new Zi();
f.show()；//运行结果等于"zi show"  编译看左边和运行看右边
}
}